Macros
Compile time constraints

Macros

#define BLAZE_CONSTRAINT_MUST_BE_ADAPTOR_TYPE(T)   static_assert( ::blaze::IsAdaptor_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_BAND_TYPE(T)   static_assert( ::blaze::IsBand_v<T>, "Non-band type detected" )
 Constraint on the data type.In case the given data type T is not a band type (i.e. a dense or sparse band), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BAND_TYPE(T)   static_assert( !::blaze::IsBand_v<T>, "Band type detected" )
 Constraint on the data type.In case the given data type T is a band type (i.e. a dense or sparse band), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_BINARYMAPEXPR_TYPE(T)   static_assert( ::blaze::IsBinaryMapExpr_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_BE_COLUMNS_TYPE(T)   static_assert( ::blaze::IsColumns_v<T>, "Non-columns type detected" )
 Constraint on the data type.In case the given data type T is not a column selection (i.e. a view on selected columns of a dense or sparse matrix), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMNS_TYPE(T)   static_assert( !::blaze::IsColumns_v<T>, "Columns type detected" )
 Constraint on the data type.In case the given data type T is a column selection type (i.e. a view on selected columns of a dense or sparse matrix), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_VECTOR_TYPE(T)   static_assert( ::blaze::IsColumnVector_v<T>, "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_v<T>, "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_COMMUTATIVE_TYPES(T1, T2)   static_assert( ::blaze::IsCommutative_v<T1,T2>, "Non-commutative types detected" )
 Constraint on the data type.In case the given data types T1 and T2 are not commutative (i.e. cannot be swapped in mathematical operations), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMMUTATIVE_TYPES(T1, T2)   static_assert( !::blaze::IsCommutative_v<T1,T2>, "Commutative types detected" )
 Constraint on the data type.In case the given data types T1 and T2 are commutative (i.e. can be swapped in mathematical operations), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_COMPUTATION_TYPE(T)   static_assert( ::blaze::IsComputation_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_CONTIGUOUS_TYPE(T)   static_assert( ::blaze::IsContiguous_v<T>, "Non-contiguous type detected" )
 Constraint on the data type.In case the given data type T is not an array-like data type with contiguous elements a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONTIGUOUS_TYPE(T)   static_assert( !::blaze::IsContiguous_v<T>, "Contiguous type detected" )
 Constraint on the data type.In case the given data type T is an array-like data type with contiguous elements a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_CROSSEXPR_TYPE(T)   static_assert( ::blaze::IsCrossExpr_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_ELEMENTS_TYPE(T)   static_assert( ::blaze::IsElements_v<T>, "Non-elements type detected" )
 Constraint on the data type.In case the given data type T is not an element selection (i.e. a view on selected elements of a dense or sparse vector), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ELEMENTS_TYPE(T)   static_assert( !::blaze::IsElements_v<T>, "Elements type detected" )
 Constraint on the data type.In case the given data type T is an element selection (i.e. a view on selected elements of a dense or sparse vector), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_EVALEXPR_TYPE(T)   static_assert( ::blaze::IsEvalExpr_v<T>, "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_v<T>, "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_EXPANDEXPR_TYPE(T)   static_assert( ::blaze::IsExpandExpr_v<T>, "Non-expansion expression type detected" )
 Constraint on the data type.In case the given data type T is not an expansion expression (i.e. a type derived from the ExpandExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EXPANDEXPR_TYPE(T)   static_assert( !::blaze::IsExpandExpr_v<T>, "Expansion expression type detected" )
 Constraint on the data type.In case the given data type T is an expansion expression (i.e. a type derived from the ExpandExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_EXPRESSION_TYPE(T)   static_assert( ::blaze::IsExpression_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_INITIALIZER_TYPE(T)   static_assert( ::blaze::IsInitialiizer_v<T>, "Non-initializer type detected" )
 Constraint on the data type.In case the given data type T is not an initializer data type, i.e. an initializer vector or matrix, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_INITIALIZER_TYPE(T)   static_assert( !::blaze::IsInitializer_v<T>, "Initializer type dected" )
 Constraint on the data type.In case the given data type T is an initializer data type, i.e. an initializer vector or matrix, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_INVERTIBLE_TYPE(T)   static_assert( ::blaze::IsInvertible_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_MATREDUCEEXPR_TYPE(T)   static_assert( ::blaze::IsMatReduceExpr_v<T>, "Non-matrix reduction expression type detected" )
 Constraint on the data type.In case the given data type T is not a matrix reduction expression (i.e. a type derived from the MatReduceExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATREDUCEEXPR_TYPE(T)   static_assert( !::blaze::IsMatReduceExpr_v<T>, "Matrix reduction expression type detected" )
 Constraint on the data type.In case the given data type T is a matrix reduction expression (i.e. a type derived from the MatReduceExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_TYPE(T)   static_assert( ::blaze::IsMatrix_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_PADDING_ENABLED(T)   static_assert( ::blaze::IsPaddingEnabled_v<T>, "Non-padding enabled type detected" )
 Constraint on the data type.In case the given data type T does not provide support for padding (i.e. does not properly treat padding elements), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_PADDING_ENABLED(T)   static_assert( !::blaze::IsPaddingEnabled_v<T>, "Padding enabled type detected" )
 Constraint on the data type.In case the given data type T does provide support for padding (i.e. properly treats padding elements), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_PROXY_TYPE(T)   static_assert( ::blaze::IsProxy_v<T>, "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_v<T>, "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_BE_REDUCEEXPR_TYPE(T)   static_assert( ::blaze::IsReduceExpr_v<T>, "Non-reduce expression type detected" )
 Constraint on the data type.In case the given data type T is not a reduce expression (i.e. a type derived from the ReduceExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REDUCEEXPR_TYPE(T)   static_assert( !::blaze::IsReduceExpr_v<T>, "Reduce expression type detected" )
 Constraint on the data type.In case the given data type T is a reduce expression (i.e. a type derived from the ReduceExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_REQUIRE_EVALUATION(T)   static_assert( ::blaze::RequiresEvaluation_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_BE_ROWS_TYPE(T)   static_assert( ::blaze::IsRows_v<T>, "Non-rows type detected" )
 Constraint on the data type.In case the given data type T is not a row selection (i.e. a view on selected rows of a dense or sparse matrix), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ROWS_TYPE(T)   static_assert( !::blaze::IsRows_v<T>, "Rows type detected" )
 Constraint on the data type.In case the given data type T is a row selection type (i.e. a view on selected rows of a dense or sparse matrix), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_ROW_VECTOR_TYPE(T)   static_assert( ::blaze::IsRowVector_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T1,T2>, "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_v<T1,T2>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_BE_SMP_ASSIGNABLE(T)   static_assert( ::blaze::IsSMPAssignable_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_VECEXPANDEXPR_TYPE(T)   static_assert( ::blaze::IsVecExpandExpr_v<T>, "Non-vector expansion expression type detected" )
 Constraint on the data type.In case the given data type T is not a vector expansion expression (i.e. a type derived from the VecExpandExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECEXPANDEXPR_TYPE(T)   static_assert( !::blaze::IsVecExpandExpr_v<T>, "Vector expansion expression type detected" )
 Constraint on the data type.In case the given data type T is a vector expansion expression (i.e. a type derived from the VecExpandExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_VECMAPEXPR_TYPE(T)   static_assert( ::blaze::IsVecMapExpr_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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_v<T>, "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.
 
#define BLAZE_CONSTRAINT_MUST_BE_ZERO_TYPE(T)   static_assert( ::blaze::IsZero_v<T>, "Non-zero type detected" )
 Constraint on the data type.In case the given data type T is not a zero vector or matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ZERO_TYPE(T)   static_assert( !::blaze::IsZero_v<T>, "Zero type detected" )
 Constraint on the data type.In case the given data type T is a zero vector or matrix type, 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_v<T1> && \
::blaze::IsMatrix_v<T2> && \
::blaze::StorageOrder_v<T1> != ::blaze::StorageOrder_v<T2>, "Invalid storage order detected" )

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_v<T1> && \
::blaze::IsMatrix_v<T2> && \
::blaze::StorageOrder_v<T1> == ::blaze::StorageOrder_v<T2>, "Invalid storage order failed" )

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_v<T> && \
::blaze::StorageOrder_v<T> == SO, "Invalid storage order detected" )

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_v<T> && \
::blaze::TransposeFlag_v<T> == TF, "Invalid transpose flag detected" )

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::IsMatrix_v<T1> && \
::blaze::IsMatrix_v<T2> && \
( ( ::blaze::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
( ::blaze::Size_v<T1,0UL> == ::blaze::Size_v<T2,0UL> ) ) && \
( ( ::blaze::Size_v<T1,1UL> == -1L ) || \
( ::blaze::Size_v<T2,1UL> == -1L ) || \
( ::blaze::Size_v<T1,1UL> == ::blaze::Size_v<T2,1UL> ) ) \
, "Invalid matrix/matrix addition expression detected" )

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::IsMatrix_v<T1> && \
::blaze::IsMatrix_v<T2> && \
( ( ::blaze::Size_v<T1,1UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
( ::blaze::Size_v<T1,1UL> == ::blaze::Size_v<T2,0UL> ) ) \
, "Invalid matrix/matrix multiplication expression detected" )

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::IsMatrix_v<T1> && \
::blaze::IsMatrix_v<T2> && \
( ( ::blaze::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
( ::blaze::Size_v<T1,0UL> == ::blaze::Size_v<T2,0UL> ) ) && \
( ( ::blaze::Size_v<T1,1UL> == -1L ) || \
( ::blaze::Size_v<T2,1UL> == -1L ) || \
( ::blaze::Size_v<T1,1UL> == ::blaze::Size_v<T2,1UL> ) ) \
, "Invalid matrix/matrix subtraction expression detected" )

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::IsMatrix_v<T1> && \
::blaze::IsColumnVector_v<T2> && \
( ( ::blaze::Size_v<T1,1UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
( ::blaze::Size_v<T1,1UL> == ::blaze::Size_v<T2,0UL> ) ) \
, "Invalid matrix/vector multiplication expression detected" )

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::IsMatrix_v<T1> && \
::blaze::IsMatrix_v<T2> && \
( ( ::blaze::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
( ::blaze::Size_v<T1,0UL> == ::blaze::Size_v<T2,0UL> ) ) && \
( ( ::blaze::Size_v<T1,1UL> == -1L ) || \
( ::blaze::Size_v<T2,1UL> == -1L ) || \
( ::blaze::Size_v<T1,1UL> == ::blaze::Size_v<T2,1UL> ) ) \
, "Invalid matrix/matrix addition expression detected" )

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::IsRowVector_v<T1> && \
::blaze::IsMatrix_v<T2> && \
( ( ::blaze::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
( ::blaze::Size_v<T1,0UL> == ::blaze::Size_v<T2,0UL> ) ) \
, "Invalid vector/matrix multiplication expression detected" )

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:
static_assert( ::blaze::IsColumnVector_v<T1> && \
::blaze::IsRowVector_v<T2> \
, "Invalid vector/vector multiplication expression detected" )

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:
static_assert( ( ( ::blaze::IsRowVector_v<T1> && ::blaze::IsRowVector_v<T2> ) || \
( ::blaze::IsColumnVector_v<T1> && ::blaze::IsColumnVector_v<T2> ) ) && \
( ( ::blaze::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
( ::blaze::Size_v<T1,0UL> == ::blaze::Size_v<T2,0UL> ) ) \
, "Invalid vector/vector addition expression detected" )

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:
static_assert( ( ( ::blaze::IsRowVector_v<T1> && ::blaze::IsRowVector_v<T2> ) || \
( ::blaze::IsColumnVector_v<T1> && ::blaze::IsColumnVector_v<T2> ) ) && \
( ( ::blaze::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
( ::blaze::Size_v<T1,0UL> == ::blaze::Size_v<T2,0UL> ) ) \
, "Invalid vector/vector division expression detected" )

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:
static_assert( ( ( ::blaze::IsRowVector_v<T1> && ::blaze::IsRowVector_v<T2> ) || \
( ::blaze::IsColumnVector_v<T1> && ::blaze::IsColumnVector_v<T2> ) ) && \
( ( ::blaze::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
( ::blaze::Size_v<T1,0UL> == ::blaze::Size_v<T2,0UL> ) ) \
, "Invalid vector/vector multiplication expression detected" )

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:
static_assert( ( ( ::blaze::IsRowVector_v<T1> && ::blaze::IsRowVector_v<T2> ) || \
( ::blaze::IsColumnVector_v<T1> && ::blaze::IsColumnVector_v<T2> ) ) && \
( ( ::blaze::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
( ::blaze::Size_v<T1,0UL> == ::blaze::Size_v<T2,0UL> ) ) \
, "Invalid vector/vector subtraction expression detected" )

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_VECTORS_MUST_HAVE_DIFFERENT_TRANSPOSE_FLAG

#define BLAZE_CONSTRAINT_VECTORS_MUST_HAVE_DIFFERENT_TRANSPOSE_FLAG (   T1,
  T2 
)
Value:
static_assert( ::blaze::IsVector_v<T1> && \
::blaze::IsVector_v<T2> && \
::blaze::TransposeFlag_v<T1> != ::blaze::TransposeFlag_v<T2>, "Invalid transpose flag detected" )

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_v<T1> && \
::blaze::IsVector_v<T2> && \
::blaze::TransposeFlag_v<T1> == ::blaze::TransposeFlag_v<T2>, "Invalid transpose flag detected" )

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.