Blaze 3.9
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. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ADAPTOR_TYPE(T)    static_assert( !::blaze::IsAdaptor_v<T>, "Adaptor type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_ADDEXPR_TYPE(T)    static_assert( ::blaze::IsAddExpr_v<T>, "Non-addition expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ADDEXPR_TYPE(T)    static_assert( !::blaze::IsAddExpr_v<T>, "Addition expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_ALIGNED_TYPE(T)    static_assert( ::blaze::IsAligned_v<T>, "Non-aligned type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ALIGNED_TYPE(T)    static_assert( !::blaze::IsAligned_v<T>, "Aligned type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_BAND_TYPE(T)    static_assert( ::blaze::IsBand_v<T>, "Non-band type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BAND_TYPE(T)    static_assert( !::blaze::IsBand_v<T>, "Band type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_CLEARABLE_TYPE(T)    static_assert( ::blaze::IsClearable_v<T>, "Non-clearable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CLEARABLE_TYPE(T)    static_assert( !::blaze::IsClearable_v<T>, "Clearable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_TYPE(T)    static_assert( ::blaze::IsColumn_v<T>, "Non-column type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMN_TYPE(T)    static_assert( !::blaze::IsColumn_v<T>, "Column type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_COLUMNS_TYPE(T)    static_assert( ::blaze::IsColumns_v<T>, "Non-columns type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMNS_TYPE(T)    static_assert( !::blaze::IsColumns_v<T>, "Columns type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_COMPOSITE_TYPE(T)    static_assert( ::blaze::HasCompositeType_v<T>, "Type without composite type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_COMPOSITE_TYPE(T)    static_assert( !::blaze::HasCompositeType_v<T>, "Type with composite type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_COMPUTATION_TYPE(T)    static_assert( ::blaze::IsComputation_v<T>, "Non-computation type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE(T)    static_assert( !::blaze::IsComputation_v<T>, "Computation type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_CONTIGUOUS_TYPE(T)    static_assert( ::blaze::IsContiguous_v<T>, "Non-contiguous type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONTIGUOUS_TYPE(T)    static_assert( !::blaze::IsContiguous_v<T>, "Contiguous type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_CUDA_ASSIGNABLE(T)    static_assert( ::blaze::IsCUDAAssignable_v<T>, "Non-CUDA assignable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CUDA_ASSIGNABLE(T)    static_assert( !::blaze::IsCUDAAssignable_v<T>, "CUDA-assignable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_CUSTOM_TYPE(T)    static_assert( ::blaze::IsCustom_v<T>, "Non-custom type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CUSTOM_TYPE(T)    static_assert( !::blaze::IsCustom_v<T>, "Custom type dected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLARATION_TYPE(T)    static_assert( ::blaze::IsDeclaration_v<T>, "Non-declaration type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLARATION_TYPE(T)    static_assert( !::blaze::IsDeclaration_v<T>, "Declaration type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLDIAGEXPR_TYPE(T)    static_assert( ::blaze::IsDeclDiagExpr_v<T>, "Non-decldiag expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLDIAGEXPR_TYPE(T)    static_assert( !::blaze::IsDeclDiagExpr_v<T>, "Decldiag expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLEXPR_TYPE(T)    static_assert( ::blaze::IsDeclExpr_v<T>, "Non-declaration expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLEXPR_TYPE(T)    static_assert( !::blaze::IsDeclExpr_v<T>, "Declaration expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLHERMEXPR_TYPE(T)    static_assert( ::blaze::IsDeclHermExpr_v<T>, "Non-declherm expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLHERMEXPR_TYPE(T)    static_assert( !::blaze::IsDeclHermExpr_v<T>, "Declherm expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLLOWEXPR_TYPE(T)    static_assert( ::blaze::IsDeclLowExpr_v<T>, "Non-decllow expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLLOWEXPR_TYPE(T)    static_assert( !::blaze::IsDeclLowExpr_v<T>, "Decllow expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLSTRLOWEXPR_TYPE(T)    static_assert( ::blaze::IsDeclStrLowExpr_v<T>, "Non-declstrlow expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLSTRLOWEXPR_TYPE(T)    static_assert( !::blaze::IsDeclStrLowExpr_v<T>, "Declstrlow expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLSTRUPPEXPR_TYPE(T)    static_assert( ::blaze::IsDeclStrUppExpr_v<T>, "Non-declstrupp expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLSTRUPPEXPR_TYPE(T)    static_assert( !::blaze::IsDeclStrUppExpr_v<T>, "Declstrupp expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLSYMEXPR_TYPE(T)    static_assert( ::blaze::IsDeclSymExpr_v<T>, "Non-declsym expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLSYMEXPR_TYPE(T)    static_assert( !::blaze::IsDeclSymExpr_v<T>, "Declsym expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLUNILOWEXPR_TYPE(T)    static_assert( ::blaze::IsDeclUniLowExpr_v<T>, "Non-declunilow expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLUNILOWEXPR_TYPE(T)    static_assert( !::blaze::IsDeclUniLowExpr_v<T>, "Declunilow expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLUNIUPPEXPR_TYPE(T)    static_assert( ::blaze::IsDeclUniUppExpr_v<T>, "Non-decluniupp expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLUNIUPPEXPR_TYPE(T)    static_assert( !::blaze::IsDeclUniUppExpr_v<T>, "Decluniupp expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLUPPEXPR_TYPE(T)    static_assert( ::blaze::IsDeclUppExpr_v<T>, "Non-declupp expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLUPPEXPR_TYPE(T)    static_assert( !::blaze::IsDeclUppExpr_v<T>, "Declupp expression type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_DIVEXPR_TYPE(T)    static_assert( ::blaze::IsDivExpr_v<T>, "Non-division expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DIVEXPR_TYPE(T)    static_assert( !::blaze::IsDivExpr_v<T>, "Division expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_EIGENEXPR_TYPE(T)    static_assert( ::blaze::IsEigenExpr_v<T>, "Non-eigenvalue expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EIGENEXPR_TYPE(T)    static_assert( !::blaze::IsEigenExpr_v<T>, "Eigenvalue expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_ELEMENTS_TYPE(T)    static_assert( ::blaze::IsElements_v<T>, "Non-elements type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ELEMENTS_TYPE(T)    static_assert( !::blaze::IsElements_v<T>, "Elements type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_EVALEXPR_TYPE(T)    static_assert( ::blaze::IsEvalExpr_v<T>, "Non-evaluation expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EVALEXPR_TYPE(T)    static_assert( !::blaze::IsEvalExpr_v<T>, "Evaluation expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_EXPANDEXPR_TYPE(T)    static_assert( ::blaze::IsExpandExpr_v<T>, "Non-expansion expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EXPANDEXPR_TYPE(T)    static_assert( !::blaze::IsExpandExpr_v<T>, "Expansion expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_EXPRESSION_TYPE(T)    static_assert( ::blaze::IsExpression_v<T>, "Non-expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EXPRESSION_TYPE(T)    static_assert( !::blaze::IsExpression_v<T>, "Expression type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_GENEXPR_TYPE(T)    static_assert( ::blaze::IsGenExpr_v<T>, "Non-generator expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_GENEXPR_TYPE(T)    static_assert( !::blaze::IsGenExpr_v<T>, "Generator expression type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_INITIALIZER_TYPE(T)    static_assert( ::blaze::IsInitialiizer_v<T>, "Non-initializer type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_INITIALIZER_TYPE(T)    static_assert( !::blaze::IsInitializer_v<T>, "Initializer type dected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_INVERTIBLE_TYPE(T)    static_assert( ::blaze::IsInvertible_v<T>, "Non-invertible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_INVERTIBLE_TYPE(T)    static_assert( !blaze::IsInvertible_v<T>, "Invertible type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_KRONEXPR_TYPE(T)    static_assert( ::blaze::IsKronExpr_v<T>, "Non-Kronecker product expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_KRONEXPR_TYPE(T)    static_assert( !::blaze::IsKronExpr_v<T>, "Kronecker product expression type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MATEXPEXPR_TYPE(T)    static_assert( ::blaze::IsMatExpExpr_v<T>, "Non-matrix exponential expression detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATEXPEXPR_TYPE(T)    static_assert( !::blaze::IsMatExpExpr_v<T>, "Matrix exponential expression detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MATGENEXPR_TYPE(T)    static_assert( ::blaze::IsMatGenExpr_v<T>, "Non-matrix generator expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATGENEXPR_TYPE(T)    static_assert( !::blaze::IsMatGenExpr_v<T>, "Matrix generator expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MATINVEXPR_TYPE(T)    static_assert( ::blaze::IsMatInvExpr_v<T>, "Non-matrix inversion expression detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATINVEXPR_TYPE(T)    static_assert( !::blaze::IsMatInvExpr_v<T>, "Matrix inversion expression detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATADDEXPR(T1, T2)
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MATMATKRONEXPR_TYPE(T)    static_assert( ::blaze::IsMatMatKronExpr_v<T>, "Non-matrix/matrix Kronecker product expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATKRONEXPR_TYPE(T)    static_assert( !::blaze::IsMatMatKronExpr_v<T>, "Matrix/matrix Kronecker product expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATKRONEXPR(T1, T2)
 Constraint on the data type. 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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATMULTEXPR(T1, T2)
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MATMATSOLVEEXPR_TYPE(T)    static_assert( ::blaze::IsMatMatSolveExpr_v<T>, "Non-matrix/matrix solver expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATSOLVEEXPR_TYPE(T)    static_assert( !::blaze::IsMatMattSolveExpr_v<T>, "Matrix/matrix solver expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATSOLVEEXPR(T1, T2)
 Constraint on the data type. 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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATSUBEXPR(T1, T2)
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MATNOALIASEXPR_TYPE(T)    static_assert( ::blaze::IsMatNoAliasExpr_v<T>, "Non-matrix no-alias expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATNOALIASEXPR_TYPE(T)    static_assert( !::blaze::IsMatNoAliasExpr_v<T>, "Matrix no-alias expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MATNOSIMDEXPR_TYPE(T)    static_assert( ::blaze::IsMatNoSIMDExpr_v<T>, "Non-matrix no-SIMD expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATNOSIMDEXPR_TYPE(T)    static_assert( !::blaze::IsMatNoSIMDExpr_v<T>, "Matrix no-SIMD expression type detected" )
 Constraint on the data type. 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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MATREPEATEXPR_TYPE(T)    static_assert( ::blaze::IsMatRepeatExpr_v<T>, "Non-matrix repeater expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATREPEATEXPR_TYPE(T)    static_assert( !::blaze::IsMatRepeatExpr_v<T>, "Matrix repeater expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_TYPE(T)    static_assert( ::blaze::IsMatrix_v<T>, "Non-matrix type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATRIX_TYPE(T)    static_assert( !::blaze::IsMatrix_v<T>, "Matrix type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATVECMULTEXPR(T1, T2)
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MATVECSOLVEEXPR_TYPE(T)    static_assert( ::blaze::IsMatVecSolveExpr_v<T>, "Non-matrix/vector solver expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATVECSOLVEEXPR_TYPE(T)    static_assert( !::blaze::IsMatVecSolveExpr_v<T>, "Matrix/vector solver expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATVECSOLVEEXPR(T1, T2)
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MODIFICATION_TYPE(T)    static_assert( ::blaze::IsModification_v<T>, "Non-modification type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MODIFICATION_TYPE(T)    static_assert( !::blaze::IsModification_v<T>, "Modification type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MULTEXPR_TYPE(T)    static_assert( ::blaze::IsMultExpr_v<T>, "Non-multiplication expression detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MULTEXPR_TYPE(T)    static_assert( !::blaze::IsMultExpr_v<T>, "Multiplication expression detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_NOALIASEXPR_TYPE(T)    static_assert( ::blaze::IsNoAliasExpr_v<T>, "Non-no-alias expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOALIASEXPR_TYPE(T)    static_assert( !::blaze::IsNoAliasExpr_v<T>, "No-alias expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_NOSIMDEXPR_TYPE(T)    static_assert( ::blaze::IsNoSIMDExpr_v<T>, "Non-no-SIMD expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOSIMDEXPR_TYPE(T)    static_assert( !::blaze::IsNoSIMDExpr_v<T>, "No-SIMD expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_OPERATION_TYPE(T)    static_assert( ::blaze::IsOperation_v<T>, "Non-operation type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_OPERATION_TYPE(T)    static_assert( !::blaze::IsOperation_v<T>, "Operation type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_OPPOSED_VIEW(T)    static_assert( ::blaze::IsOpposedView_v<T>, "Non-opposed view detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_OPPOSED_VIEW(T)    static_assert( !::blaze::IsOpposedView_v<T>, "Opposed view detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_PADDED_TYPE(T)    static_assert( ::blaze::IsPadded_v<T>, "Non-padded type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_PADDED_TYPE(T)    static_assert( !::blaze::IsPadded_v<T>, "Padded type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_PADDING_ENABLED(T)    static_assert( ::blaze::IsPaddingEnabled_v<T>, "Non-padding enabled type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_PADDING_ENABLED(T)    static_assert( !::blaze::IsPaddingEnabled_v<T>, "Padding enabled type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_PROXY_TYPE(T)    static_assert( ::blaze::IsProxy_v<T>, "Non-proxy type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_PROXY_TYPE(T)    static_assert( !::blaze::IsProxy_v<T>, "Proxy type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_REDUCEEXPR_TYPE(T)    static_assert( ::blaze::IsReduceExpr_v<T>, "Non-reduce expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REDUCEEXPR_TYPE(T)    static_assert( !::blaze::IsReduceExpr_v<T>, "Reduce expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_REPEATEXPR_TYPE(T)    static_assert( ::blaze::IsRepeatExpr_v<T>, "Non-repeater expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REPEATEXPR_TYPE(T)    static_assert( !::blaze::IsRepeatExpr_v<T>, "Repeater expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_REQUIRE_EVALUATION(T)    static_assert( ::blaze::RequiresEvaluation_v<T>, "Type without evaluation requirement detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)    static_assert( !::blaze::RequiresEvaluation_v<T>, "Type with evaluation requirement detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_RESIZABLE_TYPE(T)    static_assert( ::blaze::IsResizable_v<T>, "Non-resizable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_RESIZABLE_TYPE(T)    static_assert( !::blaze::IsResizable_v<T>, "Resizable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_RESTRICTED(T)    static_assert( ::blaze::IsRestricted_v<T>, "Unrestricted type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_RESTRICTED(T)    static_assert( !::blaze::IsRestricted_v<T>, "Restricted type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_HAVE_RESULT_TYPE(T)    static_assert( ::blaze::HasResultType_v<T>, "Type without result type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_RESULT_TYPE(T)    static_assert( !::blaze::HasResultType_v<T>, "Type with result type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_ROW_TYPE(T)    static_assert( ::blaze::IsRow_v<T>, "Non-row type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ROW_TYPE(T)    static_assert( !::blaze::IsRow_v<T>, "Row type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_ROWS_TYPE(T)    static_assert( ::blaze::IsRows_v<T>, "Non-rows type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ROWS_TYPE(T)    static_assert( !::blaze::IsRows_v<T>, "Rows type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SCALAR_TYPE(T)    static_assert( ::blaze::IsScalar_v<T>, "Non-scalar type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SCALAR_TYPE(T)    static_assert( !::blaze::IsScalar_v<T>, "Scalar type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_SCHUREXPR(T1, T2)
 Constraint on the data type. 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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SHRINKABLE_TYPE(T)    static_assert( ::blaze::IsShrinkable_v<T>, "Non-shrinkable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SHRINKABLE_TYPE(T)    static_assert( !::blaze::IsShrinkable_v<T>, "Shrinkable type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SIMD_ENABLED(T)    static_assert( ::blaze::IsSIMDEnabled_v<T>, "Non-SIMD enabled type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SIMD_ENABLED(T)    static_assert( !::blaze::IsSIMDEnabled_v<T>, "SIMD enabled type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SIMD_PACK(T)    static_assert( ::blaze::IsSIMDPack_v<T>, "Non-SIMD pack detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SIMD_PACK(T)    static_assert( !::blaze::IsSIMDPack_v<T>, "SIMD pack detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SMP_ASSIGNABLE(T)    static_assert( ::blaze::IsSMPAssignable_v<T>, "Non-SMP assignable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SMP_ASSIGNABLE(T)    static_assert( !::blaze::IsSMPAssignable_v<T>, "SMP assignable type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SOLVEEXPR_TYPE(T)    static_assert( ::blaze::IsSolveExpr_v<T>, "Non-solver expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SOLVEEXPR_TYPE(T)    static_assert( !::blaze::IsSolveExpr_v<T>, "Solver expression type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_STATIC_TYPE(T)    static_assert( ::blaze::IsStatic_v<T>, "Non-static type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STATIC_TYPE(T)    static_assert( !::blaze::IsStatic_v<T>, "Static type dected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER(T1, T2)
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_DIFFERENT_STORAGE_ORDER(T1, T2)
 Constraint on the data type. 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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SUBEXPR_TYPE(T)    static_assert( ::blaze::IsSubExpr_v<T>, "Non-subtraction expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SUBEXPR_TYPE(T)    static_assert( !::blaze::IsSubExpr_v<T>, "Subtraction expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SUBMATRIX_TYPE(T)    static_assert( ::blaze::IsSubmatrix_v<T>, "Non-submatrix type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SUBMATRIX_TYPE(T)    static_assert( !::blaze::IsSubmatrix_v<T>, "Submatrix type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SUBVECTOR_TYPE(T)    static_assert( ::blaze::IsSubvector_v<T>, "Non-subvector type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SUBVECTOR_TYPE(T)    static_assert( !::blaze::IsSubvector_v<T>, "Subvector type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SVDEXPR_TYPE(T)    static_assert( ::blaze::IsSVDExpr_v<T>, "Non-singular value expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SVDEXPR_TYPE(T)    static_assert( !::blaze::IsSVDExpr_v<T>, "Singular value expression type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_TRANSEXPR_TYPE(T)    static_assert( ::blaze::IsTransExpr_v<T>, "Non-transposition expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_TRANSEXPR_TYPE(T)    static_assert( !::blaze::IsTransExpr_v<T>, "Transposition expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_TRANSFORMATION_TYPE(T)    static_assert( ::blaze::IsTransformation_v<T>, "Non-transformation type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_TRANSFORMATION_TYPE(T)    static_assert( !::blaze::IsTransformation_v<T>, "Transformation type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VECTOR_WITH_TRANSPOSE_FLAG(T, TF)
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_VECTORS_MUST_HAVE_SAME_TRANSPOSE_FLAG(T1, T2)
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_VECTORS_MUST_HAVE_DIFFERENT_TRANSPOSE_FLAG(T1, T2)
 Constraint on the data type. 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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_TVECMATMULTEXPR(T1, T2)
 Constraint on the data type. 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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_UNIFORM_TYPE(T)    static_assert( ::blaze::IsUniform_v<T>, "Non-uniform type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNIFORM_TYPE(T)    static_assert( !::blaze::IsUniform_v<T>, "Uniform type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VECGENEXPR_TYPE(T)    static_assert( ::blaze::IsVecGenExpr_v<T>, "Non-vector generator expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECGENEXPR_TYPE(T)    static_assert( !::blaze::IsVecGenExpr_v<T>, "Vector generator expression type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VECNOALIASEXPR_TYPE(T)    static_assert( ::blaze::IsVecNoAliasExpr_v<T>, "Non-vector no-alias expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECNOALIASEXPR_TYPE(T)    static_assert( !::blaze::IsVecNoAliasExpr_v<T>, "Vector no-alias expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VECNOSIMDEXPR_TYPE(T)    static_assert( ::blaze::IsVecNoSIMDExpr_v<T>, "Non-vector no-SIMD expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECNOSIMDEXPR_TYPE(T)    static_assert( !::blaze::IsVecNoSIMDExpr_v<T>, "Vector no-SIMD expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VECREPEATTEXPR_TYPE(T)    static_assert( ::blaze::IsVecRepeatExpr_v<T>, "Non-vector repeater expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECREPEATEXPR_TYPE(T)    static_assert( !::blaze::IsVecRepeatExpr_v<T>, "Vector repeater expression type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VECTOR_TYPE(T)    static_assert( ::blaze::IsVector_v<T>, "Non-vector type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECTOR_TYPE(T)    static_assert( !::blaze::IsVector_v<T>, "Vector type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VECTVECMAPEXPR_TYPE(T)    static_assert( ::blaze::IsVecTVecMapExpr_v<T>, "Non-outer map expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECTVECMAPEXPR_TYPE(T)    static_assert( !::blaze::IsVecTVecMapExpr_v<T>, "Outer map expression type detected" )
 Constraint on the data type. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECTVECMULTEXPR(T1, T2)
 Constraint on the data type. 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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECADDEXPR(T1, T2)
 Constraint on the data type. 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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECDIVEXPR(T1, T2)
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VECVECKRONEXPR_TYPE(T)    static_assert( ::blaze::IsVecVecKronExpr_v<T>, "Non-vector/vector Kronecker product expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECKRONEXPR_TYPE(T)    static_assert( !::blaze::IsVecVecKronExpr_v<T>, "Vector/vector Kronecker product expression type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECKRONEXPR(T1, T2)
 Constraint on the data type. 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. More...
 
#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. More...
 
#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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECMULTEXPR(T1, T2)
 Constraint on the data type. 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. More...
 
#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. More...
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECSUBEXPR(T1, T2)
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VIEW_TYPE(T)    static_assert( ::blaze::IsView_v<T>, "Non-view type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VIEW_TYPE(T)    static_assert( !::blaze::IsView_v<T>, "View type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_ZERO_TYPE(T)    static_assert( ::blaze::IsZero_v<T>, "Non-zero type detected" )
 Constraint on the data type. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ZERO_TYPE(T)    static_assert( !::blaze::IsZero_v<T>, "Zero type detected" )
 Constraint on the data type. More...
 

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_ADAPTOR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_ADDEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_ALIGNED_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_BAND_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_BINARYMAPEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_BLAS_COMPATIBLE_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_CLEARABLE_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_CLEARABLE_TYPE (   T)     static_assert( ::blaze::IsClearable_v<T>, "Non-clearable type detected" )

Constraint on the data type.

In case the given data type T is not clearable, i.e. does not have a clear() member function, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_COLUMN_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_COLUMN_VECTOR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_COLUMNS_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_COMMUTATIVE_TYPES

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_COMPUTATION_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_CONTIGUOUS_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_CROSSEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_CUDA_ASSIGNABLE

#define BLAZE_CONSTRAINT_MUST_BE_CUDA_ASSIGNABLE (   T)     static_assert( ::blaze::IsCUDAAssignable_v<T>, "Non-CUDA assignable type detected" )

Constraint on the data type.

In case the given data type T is not CUDA-assignable (i.e. does not provide the according CUDA member constants or returns false), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_CUSTOM_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_DECLARATION_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_DECLDIAGEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_DECLEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_DECLHERMEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_DECLLOWEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_DECLSTRLOWEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_DECLSTRLOWEXPR_TYPE (   T)     static_assert( ::blaze::IsDeclStrLowExpr_v<T>, "Non-declstrlow expression type detected" )

Constraint on the data type.

In case the given data type T is not a declstrlow expression (i.e. a type derived from the DeclStrLowExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_DECLSTRUPPEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_DECLSTRUPPEXPR_TYPE (   T)     static_assert( ::blaze::IsDeclStrUppExpr_v<T>, "Non-declstrupp expression type detected" )

Constraint on the data type.

In case the given data type T is not a declstrupp expression (i.e. a type derived from the DeclStrUppExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_DECLSYMEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_DECLUNILOWEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_DECLUNILOWEXPR_TYPE (   T)     static_assert( ::blaze::IsDeclUniLowExpr_v<T>, "Non-declunilow expression type detected" )

Constraint on the data type.

In case the given data type T is not a declunilow expression (i.e. a type derived from the DeclUniLowExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_DECLUNIUPPEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_DECLUNIUPPEXPR_TYPE (   T)     static_assert( ::blaze::IsDeclUniUppExpr_v<T>, "Non-decluniupp expression type detected" )

Constraint on the data type.

In case the given data type T is not a decluniupp expression (i.e. a type derived from the DeclUniUppExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_DECLUPPEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE

#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 matrix type (i.e. a type that is derived from the DenseMatrix base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_DENSE_VECTOR_TYPE

#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 vector type (i.e. a type that is derived from the DenseVector base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_DIAGONAL_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_DIVEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_EIGENEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_EIGENEXPR_TYPE (   T)     static_assert( ::blaze::IsEigenExpr_v<T>, "Non-eigenvalue expression type detected" )

Constraint on the data type.

In case the given data type T is not an eigenvalue expression (i.e. a type derived from the EigenExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_ELEMENTS_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_EVALEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_EXPANDEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_EXPRESSION_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_GENERAL_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_GENEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_GENEXPR_TYPE (   T)     static_assert( ::blaze::IsGenExpr_v<T>, "Non-generator expression type detected" )

Constraint on the data type.

In case the given data type T is not a generator expression (i.e. a type derived from the GenExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_HERMITIAN_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_IDENTITY_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_INITIALIZER_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_INVERTIBLE_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_KRONEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_KRONEXPR_TYPE (   T)     static_assert( ::blaze::IsKronExpr_v<T>, "Non-Kronecker product expression type detected" )

Constraint on the data type.

In case the given data type T is not a Kronecker product expression (i.e. a type derived from the KronExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_MATEVALEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_MATEXPEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_MATEXPEXPR_TYPE (   T)     static_assert( ::blaze::IsMatExpExpr_v<T>, "Non-matrix exponential expression detected" )

Constraint on the data type.

In case the given data type T is not a matrix exponential expression (i.e. a type derived from the MatExpExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_MATGENEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_MATGENEXPR_TYPE (   T)     static_assert( ::blaze::IsMatGenExpr_v<T>, "Non-matrix generator expression type detected" )

Constraint on the data type.

In case the given data type T is not a matrix generator expression (i.e. a type derived from the MatGenExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_MATINVEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_MATMAPEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_MATMATADDEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_MATMATKRONEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_MATMATKRONEXPR_TYPE (   T)     static_assert( ::blaze::IsMatMatKronExpr_v<T>, "Non-matrix/matrix Kronecker product expression type detected" )

Constraint on the data type.

In case the given data type T is not a matrix/matrix Kronecker product expression (i.e. a type derived from the MatMatKronExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_MATMATMAPEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_MATMATMULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_MATMATSOLVEEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_MATMATSOLVEEXPR_TYPE (   T)     static_assert( ::blaze::IsMatMatSolveExpr_v<T>, "Non-matrix/matrix solver expression type detected" )

Constraint on the data type.

In case the given data type T is not a single LSE solver expression (i.e. a type derived from the MatMatSolveExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_MATMATSUBEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_MATNOALIASEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_MATNOALIASEXPR_TYPE (   T)     static_assert( ::blaze::IsMatNoAliasExpr_v<T>, "Non-matrix no-alias expression type detected" )

Constraint on the data type.

In case the given data type T is not a matrix no-alias expression (i.e. a type derived from the MatNoAliasExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_MATNOSIMDEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_MATNOSIMDEXPR_TYPE (   T)     static_assert( ::blaze::IsMatNoSIMDExpr_v<T>, "Non-matrix no-SIMD expression type detected" )

Constraint on the data type.

In case the given data type T is not a matrix no-SIMD expression (i.e. a type derived from the MatNoSIMDExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_MATREDUCEEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_MATREPEATEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_MATREPEATEXPR_TYPE (   T)     static_assert( ::blaze::IsMatRepeatExpr_v<T>, "Non-matrix repeater expression type detected" )

Constraint on the data type.

In case the given data type T is not a matrix repeater expression (i.e. a type derived from the MatRepeatExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_MATRIX_TYPE

#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 matrix type (i.e. a type that is derived from the Matrix base class), 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_MATSCALARDIVEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_MATSCALARMULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_MATSERIALEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_MATTRANSEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_MATVECMULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_MATVECSOLVEEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_MATVECSOLVEEXPR_TYPE (   T)     static_assert( ::blaze::IsMatVecSolveExpr_v<T>, "Non-matrix/vector solver expression type detected" )

Constraint on the data type.

In case the given data type T is not a single LSE solver expression (i.e. a type derived from the MatVecSolveExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_MODIFICATION_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_MODIFICATION_TYPE (   T)     static_assert( ::blaze::IsModification_v<T>, "Non-modification type detected" )

Constraint on the data type.

In case the given data type T is not a modification expression (i.e. a type derived from the Modification base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_MULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_NOALIASEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_NOALIASEXPR_TYPE (   T)     static_assert( ::blaze::IsNoAliasExpr_v<T>, "Non-no-alias expression type detected" )

Constraint on the data type.

In case the given data type T is not a no-alias expression (i.e. a type derived from the NoAliasExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_NOSIMDEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_NOSIMDEXPR_TYPE (   T)     static_assert( ::blaze::IsNoSIMDExpr_v<T>, "Non-no-SIMD expression type detected" )

Constraint on the data type.

In case the given data type T is not a no-SIMD expression (i.e. a type derived from the NoSIMDExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_OPERATION_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_OPPOSED_VIEW

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_PADDED_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_PADDING_ENABLED

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_PROXY_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_REDUCEEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_REPEATEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_REPEATEXPR_TYPE (   T)     static_assert( ::blaze::IsRepeatExpr_v<T>, "Non-repeater expression type detected" )

Constraint on the data type.

In case the given data type T is not a repeater expression (i.e. a type derived from the RepeatExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_RESIZABLE_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_RESTRICTED

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_ROW_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_ROW_VECTOR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_ROWS_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_SCALAR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_SCALAR_TYPE (   T)     static_assert( ::blaze::IsScalar_v<T>, "Non-scalar type detected" )

Constraint on the data type.

In case the given data type T is not a scalar type (i.e. a vector, matrix, reference or pointer type), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_SCHUREXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_SERIALEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_SHRINKABLE_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_SIMD_COMBINABLE_TYPES

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_SIMD_ENABLED

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_SIMD_PACK

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_SMP_ASSIGNABLE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_SOLVEEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_SOLVEEXPR_TYPE (   T)     static_assert( ::blaze::IsSolveExpr_v<T>, "Non-solver expression type detected" )

Constraint on the data type.

In case the given data type T is not a solver expression (i.e. a type derived from the SolveExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_SPARSE_ELEMENT_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE

#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 matrix type (i.e. whether T is derived from the SparseMatrix base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_SPARSE_VECTOR_TYPE

#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 vector type (i.e. a type that is derived from the SparseVector base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_SQUARE_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_STATIC_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_STRICTLY_LOWER_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_STRICTLY_TRIANGULAR_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_STRICTLY_UPPER_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_SUBEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_SUBMATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_SUBVECTOR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_SVDEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_SVDEXPR_TYPE (   T)     static_assert( ::blaze::IsSVDExpr_v<T>, "Non-singular value expression type detected" )

Constraint on the data type.

In case the given data type T is not a singular value expression (i.e. a type derived from the SVDExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_SYMMETRIC_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_TRANSEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_TRANSFORMATION_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_TRIANGULAR_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_TVECMATMULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_UNARYMAPEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_UNIFORM_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_UNILOWER_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_UNITRIANGULAR_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_UNIUPPER_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_UPPER_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_VECEVALEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_VECEXPANDEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_VECGENEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_VECGENEXPR_TYPE (   T)     static_assert( ::blaze::IsVecGenExpr_v<T>, "Non-vector generator expression type detected" )

Constraint on the data type.

In case the given data type T is not a vector generator expression (i.e. a type derived from the VecGenExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_VECMAPEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_VECNOALIASEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_VECNOALIASEXPR_TYPE (   T)     static_assert( ::blaze::IsVecNoAliasExpr_v<T>, "Non-vector no-alias expression type detected" )

Constraint on the data type.

In case the given data type T is not a vector no-alias expression (i.e. a type derived from the VecNoAliasExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_VECNOSIMDEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_VECNOSIMDEXPR_TYPE (   T)     static_assert( ::blaze::IsVecNoSIMDExpr_v<T>, "Non-vector no-SIMD expression type detected" )

Constraint on the data type.

In case the given data type T is not a vector no-SIMD expression (i.e. a type derived from the VecNoSIMDExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_VECREPEATTEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_VECREPEATTEXPR_TYPE (   T)     static_assert( ::blaze::IsVecRepeatExpr_v<T>, "Non-vector repeater expression type detected" )

Constraint on the data type.

In case the given data type T is not a vector repeater expression (i.e. a type derived from the VecRepeatExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_VECSCALARDIVEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_VECSCALARMULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_VECSERIALEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_VECTOR_TYPE

#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 vector type (i.e. a type that is derived from the Vector base class), 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_BE_VECTRANSEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_VECTVECMAPEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_VECTVECMAPEXPR_TYPE (   T)     static_assert( ::blaze::IsVecTVecMapExpr_v<T>, "Non-outer map expression type detected" )

Constraint on the data type.

In case the given data type T is not an outer map expression (i.e. a type derived from the VecTVecMapExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_VECTVECMULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_VECVECADDEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_VECVECDIVEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_VECVECKRONEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_BE_VECVECKRONEXPR_TYPE (   T)     static_assert( ::blaze::IsVecVecKronExpr_v<T>, "Non-vector/vector Kronecker product expression type detected" )

Constraint on the data type.

In case the given data type T is not a vector/vector Kronecker product expression (i.e. a type derived from the VecVecKronExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_BE_VECVECMAPEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_VECVECMULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_VECVECSUBEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_VIEW_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_BE_ZERO_TYPE

#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.

◆ 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_MATMATKRONEXPR

#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATKRONEXPR (   T1,
  T2 
)
Value:
static_assert( ::blaze::IsMatrix_v<T1> && \
::blaze::IsMatrix_v<T2> \
, "Invalid matrix/matrix Kronecker product expression detected" )

Constraint on the data type.

In case the given data types T1 and T2 do not form a valid matrix/matrix Kronecker product, 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_MATMATSOLVEEXPR

#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATSOLVEEXPR (   T1,
  T2 
)
Value:
static_assert( ::blaze::IsDenseMatrix_v<T1> && \
::blaze::IsDenseMatrix_v<T2> && \
( ::blaze::Size_v<T1,0UL> == -1L || \
::blaze::Size_v<T1,1UL> == -1L || \
::blaze::Size_v<T1,0UL> == ::blaze::Size_v<T1,1UL> ) && \
( ( ::blaze::Size_v<T1,0UL> == -1L && ::blaze::Size_v<T1,1UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
( ::blaze::Size_v<T1,0UL> == ::blaze::Size_v<T2,0UL> ) || \
( ::blaze::Size_v<T1,1UL> == ::blaze::Size_v<T2,0UL> ) ) \
, "Invalid matrix/matrix solver expression detected" )

Constraint on the data type.

In case the given data types T1 and T2 do not form a valid single LSE solver, 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_MATVECSOLVEEXPR

#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATVECSOLVEEXPR (   T1,
  T2 
)
Value:
static_assert( ::blaze::IsDenseMatrix_v<T1> && \
::blaze::IsDenseVector_v<T2> && \
( ::blaze::Size_v<T1,0UL> == -1L || \
::blaze::Size_v<T1,1UL> == -1L || \
::blaze::Size_v<T1,0UL> == ::blaze::Size_v<T1,1UL> ) && \
( ( ::blaze::Size_v<T1,0UL> == -1L && ::blaze::Size_v<T1,1UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
( ::blaze::Size_v<T1,0UL> == ::blaze::Size_v<T2,0UL> ) || \
( ::blaze::Size_v<T1,1UL> == ::blaze::Size_v<T2,0UL> ) ) \
, "Invalid matrix/vector solver expression detected" )

Constraint on the data type.

In case the given data types T1 and T2 do not form a valid single LSE solver, 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 Schur product expression detected" )

Constraint on the data type.

In case the given data types T1 and T2 do not form a valid Schur product, 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_VECVECKRONEXPR

#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECKRONEXPR (   T1,
  T2 
)
Value:
static_assert( ::blaze::IsVector_v<T1> && \
::blaze::IsVector_v<T2> \
, "Invalid vector/vector Kronecker product expression detected" )

Constraint on the data type.

In case the given data types T1 and T2 do not form a valid vector/vector Kronecker product, 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_MUST_HAVE_COMPOSITE_TYPE

#define BLAZE_CONSTRAINT_MUST_HAVE_COMPOSITE_TYPE (   T)     static_assert( ::blaze::HasCompositeType_v<T>, "Type without composite type detected" )

Constraint on the data type.

In case the given data type T does not provide a public nested type alias named CompositeType a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_HAVE_CONST_DATA_ACCESS

#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.

◆ BLAZE_CONSTRAINT_MUST_HAVE_MUTABLE_DATA_ACCESS

#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.

◆ BLAZE_CONSTRAINT_MUST_HAVE_RESULT_TYPE

#define BLAZE_CONSTRAINT_MUST_HAVE_RESULT_TYPE (   T)     static_assert( ::blaze::HasResultType_v<T>, "Type without result type detected" )

Constraint on the data type.

In case the given data type T does not provide a public nested type alias named ResultType a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_ADAPTOR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_ADDEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_ALIGNED_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_BAND_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_BINARYMAPEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_BLAS_COMPATIBLE_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_CLEARABLE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_CLEARABLE_TYPE (   T)     static_assert( !::blaze::IsClearable_v<T>, "Clearable type detected" )

Constraint on the data type.

In case the given data type T is clearable, i.e. has a clear() member function, a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMN_MAJOR_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMN_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMN_VECTOR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMNS_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_COMMUTATIVE_TYPES

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_CONTIGUOUS_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_CROSSEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_CUDA_ASSIGNABLE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_CUDA_ASSIGNABLE (   T)     static_assert( !::blaze::IsCUDAAssignable_v<T>, "CUDA-assignable type detected" )

Constraint on the data type.

In case the given data type T is CUDA-assignable (i.e. does provide the according CUDA member constants and returns true), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_CUSTOM_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DECLARATION_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DECLDIAGEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DECLEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DECLHERMEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DECLLOWEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DECLSTRLOWEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLSTRLOWEXPR_TYPE (   T)     static_assert( !::blaze::IsDeclStrLowExpr_v<T>, "Declstrlow expression type detected" )

Constraint on the data type.

In case the given data type T is a declstrlow expression (i.e. a type derived from the DeclStrLowExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DECLSTRUPPEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLSTRUPPEXPR_TYPE (   T)     static_assert( !::blaze::IsDeclStrUppExpr_v<T>, "Declstrupp expression type detected" )

Constraint on the data type.

In case the given data type T is a declstrupp expression (i.e. a type derived from the DeclStrUppExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DECLSYMEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DECLUNILOWEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLUNILOWEXPR_TYPE (   T)     static_assert( !::blaze::IsDeclUniLowExpr_v<T>, "Declunilow expression type detected" )

Constraint on the data type.

In case the given data type T is a declunilow expression (i.e. a type derived from the DeclUniLowExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DECLUNIUPPEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLUNIUPPEXPR_TYPE (   T)     static_assert( !::blaze::IsDeclUniUppExpr_v<T>, "Decluniupp expression type detected" )

Constraint on the data type.

In case the given data type T is a decluniupp expression (i.e. a type derived from the DeclUniUppExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DECLUPPEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DENSE_MATRIX_TYPE

#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 matrix type (i.e. a type that is derived from the DenseMatrix base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DENSE_VECTOR_TYPE

#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 vector type (i.e. a type that is derived from the DenseVector base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DIAGONAL_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_DIVEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_EIGENEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_EIGENEXPR_TYPE (   T)     static_assert( !::blaze::IsEigenExpr_v<T>, "Eigenvalue expression type detected" )

Constraint on the data type.

In case the given data type T is an eigenvalue expression (i.e. a type derived from the EigenExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_ELEMENTS_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_EVALEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_EXPANDEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_EXPRESSION_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_GENERAL_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_GENEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_GENEXPR_TYPE (   T)     static_assert( !::blaze::IsGenExpr_v<T>, "Generator expression type detected" )

Constraint on the data type.

In case the given data type T is a generator expression (i.e. a type derived from the GenExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_HERMITIAN_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_IDENTITY_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_INITIALIZER_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_INVERTIBLE_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_KRONEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_KRONEXPR_TYPE (   T)     static_assert( !::blaze::IsKronExpr_v<T>, "Kronecker product expression type detected" )

Constraint on the data type.

In case the given data type T is a Kronecker product expression (i.e. a type derived from the KronExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATEVALEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATEXPEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATEXPEXPR_TYPE (   T)     static_assert( !::blaze::IsMatExpExpr_v<T>, "Matrix exponential expression detected" )

Constraint on the data type.

In case the given data type T is a matrix exponential expression (i.e. a type derived from the MatExpExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATGENEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATGENEXPR_TYPE (   T)     static_assert( !::blaze::IsMatGenExpr_v<T>, "Matrix generator expression type detected" )

Constraint on the data type.

In case the given data type T is a matrix generator expression (i.e. a type derived from the MatGenExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATINVEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATMAPEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATADDEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATKRONEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATKRONEXPR_TYPE (   T)     static_assert( !::blaze::IsMatMatKronExpr_v<T>, "Matrix/matrix Kronecker product expression type detected" )

Constraint on the data type.

In case the given data type T is a matrix/matrix Kronecker product expression (i.e. a type derived from the MatMatKronExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATMAPEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATMULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATSOLVEEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATSOLVEEXPR_TYPE (   T)     static_assert( !::blaze::IsMatMattSolveExpr_v<T>, "Matrix/matrix solver expression type detected" )

Constraint on the data type.

In case the given data type T is a single LSE solver expression (i.e. a type derived from the MatMatSolveExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATSUBEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATNOALIASEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATNOALIASEXPR_TYPE (   T)     static_assert( !::blaze::IsMatNoAliasExpr_v<T>, "Matrix no-alias expression type detected" )

Constraint on the data type.

In case the given data type T is a matrix no-alias expression (i.e. a type derived from the MatNoAliasExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATNOSIMDEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATNOSIMDEXPR_TYPE (   T)     static_assert( !::blaze::IsMatNoSIMDExpr_v<T>, "Matrix no-SIMD expression type detected" )

Constraint on the data type.

In case the given data type T is a matrix no-SIMD expression (i.e. a type derived from the MatNoSIMDExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATREDUCEEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATREPEATEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATREPEATEXPR_TYPE (   T)     static_assert( !::blaze::IsMatRepeatExpr_v<T>, "Matrix repeater expression type detected" )

Constraint on the data type.

In case the given data type T is a matrix repeater expression (i.e. a type derived from the MatRepeatExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATRIX_TYPE

#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 matrix type (i.e. a type that is derived from the Matrix base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATSCALARDIVEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATSCALARMULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATSERIALEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATTRANSEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATVECMULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MATVECSOLVEEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATVECSOLVEEXPR_TYPE (   T)     static_assert( !::blaze::IsMatVecSolveExpr_v<T>, "Matrix/vector solver expression type detected" )

Constraint on the data type.

In case the given data type T is a single LSE solver expression (i.e. a type derived from the MatVecSolveExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MODIFICATION_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_MODIFICATION_TYPE (   T)     static_assert( !::blaze::IsModification_v<T>, "Modification type detected" )

Constraint on the data type.

In case the given data type T is a modification expression (i.e. a type derived from the Modification base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_MULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_NOALIASEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOALIASEXPR_TYPE (   T)     static_assert( !::blaze::IsNoAliasExpr_v<T>, "No-alias expression type detected" )

Constraint on the data type.

In case the given data type T is a no-alias expression (i.e. a type derived from the NoAliasExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_NOSIMDEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOSIMDEXPR_TYPE (   T)     static_assert( !::blaze::IsNoSIMDExpr_v<T>, "No-SIMD expression type detected" )

Constraint on the data type.

In case the given data type T is a no-SIMD expression (i.e. a type derived from the NoSIMDExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_OPERATION_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_OPPOSED_VIEW

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_PADDED_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_PADDING_ENABLED

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_PROXY_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_REDUCEEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_REPEATEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_REPEATEXPR_TYPE (   T)     static_assert( !::blaze::IsRepeatExpr_v<T>, "Repeater expression type detected" )

Constraint on the data type.

In case the given data type T is a repeater expression (i.e. a type derived from the RepeatExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_RESIZABLE_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_RESTRICTED

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_ROW_MAJOR_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_ROW_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_ROW_VECTOR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_ROWS_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SCALAR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_SCALAR_TYPE (   T)     static_assert( !::blaze::IsScalar_v<T>, "Scalar type detected" )

Constraint on the data type.

In case the given data type T is a scalar type (i.e. neither a vector type, nor a matrix, reference or pointer type), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SCHUREXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SERIALEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SHRINKABLE_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SIMD_COMBINABLE_TYPES

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SIMD_ENABLED

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SIMD_PACK

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SMP_ASSIGNABLE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SOLVEEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_SOLVEEXPR_TYPE (   T)     static_assert( !::blaze::IsSolveExpr_v<T>, "Solver expression type detected" )

Constraint on the data type.

In case the given data type T is a solver expression (i.e. a type derived from the SolveExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SPARSE_ELEMENT_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SPARSE_MATRIX_TYPE

#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 matrix type (i.e. whether T is derived from the SparseMatrix base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SPARSE_VECTOR_TYPE

#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 vector type (i.e. a type that is derived from the SparseVector base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SQUARE_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_STATIC_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_LOWER_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_TRIANGULAR_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_UPPER_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SUBEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SUBMATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SUBVECTOR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SVDEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_SVDEXPR_TYPE (   T)     static_assert( !::blaze::IsSVDExpr_v<T>, "Singular value expression type detected" )

Constraint on the data type.

In case the given data type T is a singular value expression (i.e. a type derived from the SVDExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_TRANSEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_TRANSFORMATION_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_TRIANGULAR_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_TVECMATMULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_UNARYMAPEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_UNIFORM_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_UNILOWER_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_UNITRIANGULAR_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_UNIUPPER_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_UPPER_MATRIX_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECEVALEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECEXPANDEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECGENEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECGENEXPR_TYPE (   T)     static_assert( !::blaze::IsVecGenExpr_v<T>, "Vector generator expression type detected" )

Constraint on the data type.

In case the given data type T is a vector generator expression (i.e. a type derived from the VecGenExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECMAPEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECNOALIASEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECNOALIASEXPR_TYPE (   T)     static_assert( !::blaze::IsVecNoAliasExpr_v<T>, "Vector no-alias expression type detected" )

Constraint on the data type.

In case the given data type T is a vector no-alias expression (i.e. a type derived from the VecNoAliasExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECNOSIMDEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECNOSIMDEXPR_TYPE (   T)     static_assert( !::blaze::IsVecNoSIMDExpr_v<T>, "Vector no-SIMD expression type detected" )

Constraint on the data type.

In case the given data type T is a vector no-SIMD expression (i.e. a type derived from the VecNoSIMDExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECREPEATEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECREPEATEXPR_TYPE (   T)     static_assert( !::blaze::IsVecRepeatExpr_v<T>, "Vector repeater expression type detected" )

Constraint on the data type.

In case the given data type T is a vector repeater expression (i.e. a type derived from the VecRepeatExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECSCALARDIVEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECSCALARMULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECSERIALEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECTOR_TYPE

#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 vector type (i.e. a type that is derived from the Vector base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECTRANSEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECTVECMAPEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECTVECMAPEXPR_TYPE (   T)     static_assert( !::blaze::IsVecTVecMapExpr_v<T>, "Outer map expression type detected" )

Constraint on the data type.

In case the given data type T is an outer map expression (i.e. a type derived from the VecTVecMapExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECTVECMULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECADDEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECDIVEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECKRONEXPR_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECKRONEXPR_TYPE (   T)     static_assert( !::blaze::IsVecVecKronExpr_v<T>, "Vector/vector Kronecker product expression type detected" )

Constraint on the data type.

In case the given data type T is a vector/vector Kronecker product expression (i.e. a type derived from the VecVecKronExpr base class), a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECMAPEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECMULTEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECSUBEXPR_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_VIEW_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_BE_ZERO_TYPE

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_COMPOSITE_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_COMPOSITE_TYPE (   T)     static_assert( !::blaze::HasCompositeType_v<T>, "Type with composite type detected" )

Constraint on the data type.

In case the given data type T does provide a public nested type alias named CompositeType a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_CONST_DATA_ACCESS

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_MUTABLE_DATA_ACCESS

#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.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_RESULT_TYPE

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_RESULT_TYPE (   T)     static_assert( !::blaze::HasResultType_v<T>, "Type with result type detected" )

Constraint on the data type.

In case the given data type T does provide a public nested type alias named ResultType a compilation error is created.

◆ BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION

#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.

◆ BLAZE_CONSTRAINT_MUST_REQUIRE_EVALUATION

#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.

◆ 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.