Blaze 3.9
Loading...
Searching...
No Matches
Compile time constraints

Macros

#define BLAZE_CONSTRAINT_MUST_BE_ADAPTOR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ADAPTOR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_ADDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ADDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_ALIGNED_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ALIGNED_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_BAND_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BAND_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_BINARYMAPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BINARYMAPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_BLAS_COMPATIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BLAS_COMPATIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_CLEARABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CLEARABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMN_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMN_MAJOR_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_COLUMNS_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMNS_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_VECTOR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMN_VECTOR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_COMMUTATIVE_TYPES(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMMUTATIVE_TYPES(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_HAVE_COMPOSITE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_COMPOSITE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_COMPUTATION_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_HAVE_CONST_DATA_ACCESS(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_CONST_DATA_ACCESS(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_CONTIGUOUS_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CONTIGUOUS_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_CROSSEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CROSSEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_CUDA_ASSIGNABLE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CUDA_ASSIGNABLE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_CUSTOM_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CUSTOM_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DECLARATION_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLARATION_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DECLDIAGEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLDIAGEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DECLEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DECLHERMEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLHERMEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DECLLOWEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLLOWEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DECLSTRLOWEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLSTRLOWEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DECLSTRUPPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLSTRUPPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DECLSYMEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLSYMEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DECLUNILOWEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLUNILOWEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DECLUNIUPPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLUNIUPPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DECLUPPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLUPPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DENSE_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_VECTOR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DENSE_VECTOR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DIAGONAL_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DIAGONAL_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_DIVEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DIVEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_EIGENEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EIGENEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_ELEMENTS_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ELEMENTS_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_EVALEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EVALEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_EXPANDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EXPANDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_EXPRESSION_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EXPRESSION_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_GENERAL_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_GENERAL_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_GENEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_GENEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_HERMITIAN_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_HERMITIAN_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_IDENTITY_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_IDENTITY_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_INITIALIZER_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_INITIALIZER_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_INVERTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_INVERTIBLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_KRONEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_KRONEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATEVALEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATEVALEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATEXPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATEXPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATGENEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATGENEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATINVEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATINVEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATMAPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMAPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATMATADDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATADDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATADDEXPR(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATMATKRONEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATKRONEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATKRONEXPR(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATMATMAPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATMAPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATMATMULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATMULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATMULTEXPR(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATMATSOLVEEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATSOLVEEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATSOLVEEXPR(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATMATSUBEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATSUBEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATSUBEXPR(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATNOALIASEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATNOALIASEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATNOSIMDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATNOSIMDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATREDUCEEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATREDUCEEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATREPEATEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATREPEATEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATSCALARDIVEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATSCALARDIVEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATSCALARMULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATSCALARMULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATSERIALEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATSERIALEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATTRANSEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATTRANSEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATVECMULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATVECMULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATVECMULTEXPR(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATVECSOLVEEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATVECSOLVEEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATVECSOLVEEXPR(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MODIFICATION_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MODIFICATION_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_HAVE_MUTABLE_DATA_ACCESS(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_MUTABLE_DATA_ACCESS(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_NOALIASEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOALIASEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_NOSIMDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NOSIMDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_OPERATION_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_OPERATION_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_OPPOSED_VIEW(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_OPPOSED_VIEW(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_PADDED_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_PADDED_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_PADDING_ENABLED(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_PADDING_ENABLED(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_PROXY_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_PROXY_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_REDUCEEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REDUCEEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_REPEATEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_REPEATEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_REQUIRE_EVALUATION(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_RESIZABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_RESIZABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_RESTRICTED(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_RESTRICTED(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_HAVE_RESULT_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_RESULT_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ROW_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ROW_MAJOR_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_ROWS_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ROWS_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_ROW_VECTOR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ROW_VECTOR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SCALAR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SCALAR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SCHUREXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SCHUREXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_SCHUREXPR(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SERIALEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SERIALEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SHRINKABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SHRINKABLE_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SIMD_COMBINABLE_TYPES(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SIMD_COMBINABLE_TYPES(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SIMD_ENABLED(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SIMD_ENABLED(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SIMD_PACK(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SIMD_PACK(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SMP_ASSIGNABLE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SMP_ASSIGNABLE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SOLVEEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SOLVEEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_ELEMENT_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SPARSE_ELEMENT_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SPARSE_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_VECTOR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SPARSE_VECTOR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SQUARE_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SQUARE_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_STATIC_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STATIC_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_DIFFERENT_STORAGE_ORDER(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_LOWER_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_LOWER_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_TRIANGULAR_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_TRIANGULAR_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_UPPER_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_UPPER_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SUBEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SUBEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SUBMATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SUBMATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SUBVECTOR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SUBVECTOR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SVDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SVDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_SYMMETRIC_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_TRANSEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_TRANSEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_TRANSFORMATION_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_TRANSFORMATION_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECTOR_WITH_TRANSPOSE_FLAG(T, TF)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_VECTORS_MUST_HAVE_SAME_TRANSPOSE_FLAG(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_VECTORS_MUST_HAVE_DIFFERENT_TRANSPOSE_FLAG(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_TRIANGULAR_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_TRIANGULAR_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_TVECMATMULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_TVECMATMULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_TVECMATMULTEXPR(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_UNARYMAPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNARYMAPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_UNIFORM_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNIFORM_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_UNILOWER_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNILOWER_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_UNITRIANGULAR_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNITRIANGULAR_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_UNIUPPER_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNIUPPER_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_UPPER_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UPPER_MATRIX_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECEVALEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECEVALEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECEXPANDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECEXPANDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECGENEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECGENEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECMAPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECMAPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECNOALIASEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECNOALIASEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECNOSIMDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECNOSIMDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECREPEATTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECREPEATEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECSCALARDIVEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECSCALARDIVEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECSCALARMULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECSCALARMULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECSERIALEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECSERIALEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECTOR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECTOR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECTRANSEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECTRANSEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECTVECMAPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECTVECMAPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECTVECMULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECTVECMULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECTVECMULTEXPR(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECVECADDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECADDEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECADDEXPR(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECVECDIVEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECDIVEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECDIVEXPR(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECVECKRONEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECKRONEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECKRONEXPR(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECVECMAPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECMAPEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECVECMULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECMULTEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECMULTEXPR(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VECVECSUBEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECSUBEXPR_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECSUBEXPR(T1, T2)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_VIEW_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VIEW_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_BE_ZERO_TYPE(T)
 Constraint on the data type.
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ZERO_TYPE(T)
 Constraint on the data type.

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::StorageOrder_v<T1> != ::blaze::StorageOrder_v<T2>, "Invalid storage order detected" )
constexpr bool StorageOrder_v
Auxiliary variable template for the StorageOrder type trait.
Definition StorageOrder.h:93
constexpr bool IsMatrix_v
Auxiliary variable template for the IsMatrix type trait.
Definition IsMatrix.h:124

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:

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)
Value:
static_assert( ::blaze::IsAdaptor_v<T>, "Non-adaptor type detected" )
constexpr bool IsAdaptor_v
Auxiliary variable template for the IsAdaptor type trait.
Definition IsAdaptor.h:146

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)
Value:
static_assert( ::blaze::IsAddExpr_v<T>, "Non-addition expression type detected" )
constexpr bool IsAddExpr_v
Auxiliary variable template for the IsAddExpr type trait.
Definition IsAddExpr.h:115

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)
Value:
static_assert( ::blaze::IsAligned_v<T>, "Non-aligned type detected" )
constexpr bool IsAligned_v
Auxiliary variable template for the IsAligned type trait.
Definition IsAligned.h:145

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)
Value:
static_assert( ::blaze::IsBand_v<T>, "Non-band type detected" )
constexpr bool IsBand_v
Auxiliary variable template for the IsBand type trait.
Definition IsBand.h:162

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)
Value:
static_assert( ::blaze::IsBinaryMapExpr_v<T>, "Non-binary map expression type detected" )
constexpr bool IsBinaryMapExpr_v
Auxiliary variable template for the IsBinaryMapExpr type trait.
Definition IsBinaryMapExpr.h:114

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)
Value:
static_assert( ::blaze::IsBLASCompatible_v<T>, "Non-BLAS compatible type detected" )
constexpr bool IsBLASCompatible_v
Auxiliary variable template for the IsBLASCompatible type trait.
Definition IsBLASCompatible.h:99

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)
Value:
static_assert( ::blaze::IsClearable_v<T>, "Non-clearable type detected" )
constexpr bool IsClearable_v
Auxiliary variable template for the IsClearable type trait.
Definition IsClearable.h:121

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)
Value:
static_assert( ::blaze::IsColumnMajorMatrix_v<T>, "Non-column-major matrix type detected" )
constexpr bool IsColumnMajorMatrix_v
Auxiliary variable template for the IsColumnMajorMatrix type trait.
Definition IsColumnMajorMatrix.h:129

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)
Value:
static_assert( ::blaze::IsColumn_v<T>, "Non-column type detected" )
constexpr bool IsColumn_v
Auxiliary variable template for the IsColumn type trait.
Definition IsColumn.h:161

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)
Value:
static_assert( ::blaze::IsColumnVector_v<T>, "Non-column vector type detected" )
constexpr bool IsColumnVector_v
Auxiliary variable template for the IsColumnVector type trait.
Definition IsColumnVector.h:126

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)
Value:
static_assert( ::blaze::IsColumns_v<T>, "Non-columns type detected" )
constexpr bool IsColumns_v
Auxiliary variable template for the IsColumns type trait.
Definition IsColumns.h:161

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 )
Value:
static_assert( ::blaze::IsCommutative_v<T1,T2>, "Non-commutative types detected" )
constexpr bool IsCommutative_v
Auxiliary variable template for the IsCommutative type trait.
Definition IsCommutative.h:117

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)
Value:
static_assert( ::blaze::IsComputation_v<T>, "Non-computation type detected" )
constexpr bool IsComputation_v
Auxiliary variable template for the IsComputation type trait.
Definition IsComputation.h:90

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)
Value:
static_assert( ::blaze::IsContiguous_v<T>, "Non-contiguous type detected" )
constexpr bool IsContiguous_v
Auxiliary variable template for the IsContiguous type trait.
Definition IsContiguous.h:144

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)
Value:
static_assert( ::blaze::IsCrossExpr_v<T>, "Non-cross product expression type detected" )
constexpr bool IsCrossExpr_v
Auxiliary variable template for the IsCrossExpr type trait.
Definition IsCrossExpr.h:115

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)
Value:
static_assert( ::blaze::IsCUDAAssignable_v<T>, "Non-CUDA assignable type detected" )
constexpr bool IsCUDAAssignable_v
Auxiliary variable template for the IsCUDAAssignable type trait.
Definition IsCUDAAssignable.h:141

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)
Value:
static_assert( ::blaze::IsCustom_v<T>, "Non-custom type detected" )
constexpr bool IsCustom_v
Auxiliary variable template for the IsCustom type trait.
Definition IsCustom.h:145

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)
Value:
static_assert( ::blaze::IsDeclaration_v<T>, "Non-declaration type detected" )
constexpr bool IsDeclaration_v
Auxiliary variable template for the IsDeclaration type trait.
Definition IsDeclaration.h:114

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)
Value:
static_assert( ::blaze::IsDeclDiagExpr_v<T>, "Non-decldiag expression type detected" )
constexpr bool IsDeclDiagExpr_v
Auxiliary variable template for the IsDeclDiagExpr type trait.
Definition IsDeclDiagExpr.h:114

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)
Value:
static_assert( ::blaze::IsDeclExpr_v<T>, "Non-declaration expression type detected" )
constexpr bool IsDeclExpr_v
Auxiliary variable template for the IsDeclExpr type trait.
Definition IsDeclExpr.h:114

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)
Value:
static_assert( ::blaze::IsDeclHermExpr_v<T>, "Non-declherm expression type detected" )
constexpr bool IsDeclHermExpr_v
Auxiliary variable template for the IsDeclHermExpr type trait.
Definition IsDeclHermExpr.h:114

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)
Value:
static_assert( ::blaze::IsDeclLowExpr_v<T>, "Non-decllow expression type detected" )
constexpr bool IsDeclLowExpr_v
Auxiliary variable template for the IsDeclLowExpr type trait.
Definition IsDeclLowExpr.h:114

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)
Value:
static_assert( ::blaze::IsDeclStrLowExpr_v<T>, "Non-declstrlow expression type detected" )
constexpr bool IsDeclStrLowExpr_v
Auxiliary variable template for the IsDeclStrLowExpr type trait.
Definition IsDeclStrLowExpr.h:114

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)
Value:
static_assert( ::blaze::IsDeclStrUppExpr_v<T>, "Non-declstrupp expression type detected" )
constexpr bool IsDeclStrUppExpr_v
Auxiliary variable template for the IsDeclStrUppExpr type trait.
Definition IsDeclStrUppExpr.h:114

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)
Value:
static_assert( ::blaze::IsDeclSymExpr_v<T>, "Non-declsym expression type detected" )
constexpr bool IsDeclSymExpr_v
Auxiliary variable template for the IsDeclSymExpr type trait.
Definition IsDeclSymExpr.h:114

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)
Value:
static_assert( ::blaze::IsDeclUniLowExpr_v<T>, "Non-declunilow expression type detected" )
constexpr bool IsDeclUniLowExpr_v
Auxiliary variable template for the IsDeclUniLowExpr type trait.
Definition IsDeclUniLowExpr.h:114

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)
Value:
static_assert( ::blaze::IsDeclUniUppExpr_v<T>, "Non-decluniupp expression type detected" )
constexpr bool IsDeclUniUppExpr_v
Auxiliary variable template for the IsDeclUniUppExpr type trait.
Definition IsDeclUniUppExpr.h:114

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)
Value:
static_assert( ::blaze::IsDeclUppExpr_v<T>, "Non-declupp expression type detected" )
constexpr bool IsDeclUppExpr_v
Auxiliary variable template for the IsDeclUppExpr type trait.
Definition IsDeclUppExpr.h:114

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)
Value:
static_assert( ::blaze::IsDenseMatrix_v<T>, "Non-dense matrix type detected" )
constexpr bool IsDenseMatrix_v
Auxiliary variable template for the IsDenseMatrix type trait.
Definition IsDenseMatrix.h:124

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)
Value:
static_assert( ::blaze::IsDenseVector_v<T>, "Non-dense vector type detected" )
constexpr bool IsDenseVector_v
Auxiliary variable template for the IsDenseVector type trait.
Definition IsDenseVector.h:124

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)
Value:
static_assert( ::blaze::IsDiagonal_v<T>, "Non-diagonal matrix type detected" )
constexpr bool IsDiagonal_v
Auxiliary variable template for the IsDiagonal type trait.
Definition IsDiagonal.h:148

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)
Value:
static_assert( ::blaze::IsDivExpr_v<T>, "Non-division expression type detected" )
constexpr bool IsDivExpr_v
Auxiliary variable template for the IsDivExpr type trait.
Definition IsDivExpr.h:116

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)
Value:
static_assert( ::blaze::IsEigenExpr_v<T>, "Non-eigenvalue expression type detected" )
constexpr bool IsEigenExpr_v
Auxiliary variable template for the IsEigenExpr type trait.
Definition IsEigenExpr.h:114

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)
Value:
static_assert( ::blaze::IsElements_v<T>, "Non-elements type detected" )
constexpr bool IsElements_v
Auxiliary variable template for the IsElements type trait.
Definition IsElements.h:159

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)
Value:
static_assert( ::blaze::IsEvalExpr_v<T>, "Non-evaluation expression type detected" )
constexpr bool IsEvalExpr_v
Auxiliary variable template for the IsEvalExpr type trait.
Definition IsEvalExpr.h:114

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)
Value:
static_assert( ::blaze::IsExpandExpr_v<T>, "Non-expansion expression type detected" )
constexpr bool IsExpandExpr_v
Auxiliary variable template for the IsExpandExpr type trait.
Definition IsExpandExpr.h:114

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)
Value:
static_assert( ::blaze::IsExpression_v<T>, "Non-expression type detected" )
constexpr bool IsExpression_v
Auxiliary variable template for the IsExpression type trait.
Definition IsExpression.h:114

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)
Value:
static_assert( ::blaze::IsGeneral_v<T>, "Non-general matrix type detected" )
constexpr bool IsGeneral_v
Auxiliary variable template for the IsGeneral type trait.
Definition IsGeneral.h:147

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)
Value:
static_assert( ::blaze::IsGenExpr_v<T>, "Non-generator expression type detected" )
constexpr bool IsGenExpr_v
Auxiliary variable template for the IsGenExpr type trait.
Definition IsGenExpr.h:114

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)
Value:
static_assert( ::blaze::IsHermitian_v<T>, "Non-Hermitian matrix type detected" )
constexpr bool IsHermitian_v
Auxiliary variable template for the IsHermitian type trait.
Definition IsHermitian.h:172

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)
Value:
static_assert( ::blaze::IsIdentity_v<T>, "Non-identity matrix type detected" )
constexpr bool IsIdentity_v
Auxiliary variable template for the IsIdentity type trait.
Definition IsIdentity.h:137

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)
Value:
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)
Value:
static_assert( ::blaze::IsInvertible_v<T>, "Non-invertible type detected" )
constexpr bool IsInvertible_v
Auxiliary variable template for the IsInvertible type trait.
Definition IsInvertible.h:103

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)
Value:
static_assert( ::blaze::IsKronExpr_v<T>, "Non-Kronecker product expression type detected" )
constexpr bool IsKronExpr_v
Auxiliary variable template for the IsKronExpr type trait.
Definition IsKronExpr.h:115

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)
Value:
static_assert( ::blaze::IsLower_v<T>, "Non-lower triangular matrix type detected" )
constexpr bool IsLower_v
Auxiliary variable template for the IsLower type trait.
Definition IsLower.h:175

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)
Value:
static_assert( ::blaze::IsMatEvalExpr_v<T>, "Non-matrix evaluation expression type detected" )
constexpr bool IsMatEvalExpr_v
Auxiliary variable template for the IsMatEvalExpr type trait.
Definition IsMatEvalExpr.h:115

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)
Value:
static_assert( ::blaze::IsMatExpExpr_v<T>, "Non-matrix exponential expression detected" )
constexpr bool IsMatExpExpr_v
Auxiliary variable template for the IsMatExpExpr type trait.
Definition IsMatExpExpr.h:115

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)
Value:
static_assert( ::blaze::IsMatGenExpr_v<T>, "Non-matrix generator expression type detected" )
constexpr bool IsMatGenExpr_v
Auxiliary variable template for the IsMatGenExpr type trait.
Definition IsMatGenExpr.h:115

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)
Value:
static_assert( ::blaze::IsMatInvExpr_v<T>, "Non-matrix inversion expression detected" )
constexpr bool IsMatInvExpr_v
Auxiliary variable template for the IsMatInvExpr type trait.
Definition IsMatInvExpr.h:115

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)
Value:
static_assert( ::blaze::IsMatMapExpr_v<T>, "Non-unary matrix map expression type detected" )
constexpr bool IsMatMapExpr_v
Auxiliary variable template for the IsMatMapExpr type trait.
Definition IsMatMapExpr.h:115

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)
Value:
static_assert( ::blaze::IsMatMatAddExpr_v<T>, "Non-matrix/matrix addition expression type detected" )
constexpr bool IsMatMatAddExpr_v
Auxiliary variable template for the IsMatMatAddExpr type trait.
Definition IsMatMatAddExpr.h:115

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)
Value:
static_assert( ::blaze::IsMatMatKronExpr_v<T>, "Non-matrix/matrix Kronecker product expression type detected" )
constexpr bool IsMatMatKronExpr_v
Auxiliary variable template for the IsMatMatKronExpr type trait.
Definition IsMatMatKronExpr.h:116

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)
Value:
static_assert( ::blaze::IsMatMatMapExpr_v<T>, "Non-binary matrix map expression type detected" )
constexpr bool IsMatMatMapExpr_v
Auxiliary variable template for the IsMatMatMapExpr type trait.
Definition IsMatMatMapExpr.h:115

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)
Value:
static_assert( ::blaze::IsMatMatMultExpr_v<T>, "Non-matrix/matrix multiplication expression type detected" )
constexpr bool IsMatMatMultExpr_v
Auxiliary variable template for the IsMatMatMultExpr type trait.
Definition IsMatMatMultExpr.h:116

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)
Value:
static_assert( ::blaze::IsMatMatSolveExpr_v<T>, "Non-matrix/matrix solver expression type detected" )
constexpr bool IsMatMatSolveExpr_v
Auxiliary variable template for the IsMatMatSolveExpr type trait.
Definition IsMatMatSolveExpr.h:115

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)
Value:
static_assert( ::blaze::IsMatMatSubExpr_v<T>, "Non-matrix/matrix subtraction expression type detected" )
constexpr bool IsMatMatSubExpr_v
Auxiliary variable template for the IsMatMatSubExpr type trait.
Definition IsMatMatSubExpr.h:115

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)
Value:
static_assert( ::blaze::IsMatNoAliasExpr_v<T>, "Non-matrix no-alias expression type detected" )
constexpr bool IsMatNoAliasExpr_v
Auxiliary variable template for the IsMatNoAliasExpr type trait.
Definition IsMatNoAliasExpr.h:115

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)
Value:
static_assert( ::blaze::IsMatNoSIMDExpr_v<T>, "Non-matrix no-SIMD expression type detected" )
constexpr bool IsMatNoSIMDExpr_v
Auxiliary variable template for the IsMatNoSIMDExpr type trait.
Definition IsMatNoSIMDExpr.h:115

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)
Value:
static_assert( ::blaze::IsMatReduceExpr_v<T>, "Non-matrix reduction expression type detected" )
constexpr bool IsMatReduceExpr_v
Auxiliary variable template for the IsMatReduceExpr type trait.
Definition IsMatReduceExpr.h:115

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)
Value:
static_assert( ::blaze::IsMatRepeatExpr_v<T>, "Non-matrix repeater expression type detected" )
constexpr bool IsMatRepeatExpr_v
Auxiliary variable template for the IsMatRepeatExpr type trait.
Definition IsMatRepeatExpr.h:115

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)
Value:
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)
Value:
static_assert( ::blaze::IsMatScalarDivExpr_v<T>, "Non-matrix/scalar division expression type detected" )
constexpr bool IsMatScalarDivExpr_v
Auxiliary variable template for the IsMatScalarDivExpr type trait.
Definition IsMatScalarDivExpr.h:116

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)
Value:
static_assert( ::blaze::IsMatScalarMultExpr_v<T>, "Non-matrix/scalar multiplication expression type detected" )
constexpr bool IsMatScalarMultExpr_v
Auxiliary variable template for the IsMatScalarMultExpr type trait.
Definition IsMatScalarMultExpr.h:117

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)
Value:
static_assert( ::blaze::IsMatSerialExpr_v<T>, "Non-matrix serial evaluation expression type detected" )
constexpr bool IsMatSerialExpr_v
Auxiliary variable template for the IsMatSerialExpr type trait.
Definition IsMatSerialExpr.h:115

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)
Value:
static_assert( ::blaze::IsMatTransExpr_v<T>, "Non-matrix transposition expression type detected" )
constexpr bool IsMatTransExpr_v
Auxiliary variable template for the IsMatTransExpr type trait.
Definition IsMatTransExpr.h:115

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)
Value:
static_assert( ::blaze::IsMatVecMultExpr_v<T>, "Non-matrix/vector multiplication expression type detected" )
constexpr bool IsMatVecMultExpr_v
Auxiliary variable template for the IsMatVecMultExpr type trait.
Definition IsMatVecMultExpr.h:117

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)
Value:
static_assert( ::blaze::IsMatVecSolveExpr_v<T>, "Non-matrix/vector solver expression type detected" )
constexpr bool IsMatVecSolveExpr_v
Auxiliary variable template for the IsMatVecSolveExpr type trait.
Definition IsMatVecSolveExpr.h:115

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)
Value:
static_assert( ::blaze::IsModification_v<T>, "Non-modification type detected" )
constexpr bool IsModification_v
Auxiliary variable template for the IsModification type trait.
Definition IsModification.h:114

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)
Value:
static_assert( ::blaze::IsMultExpr_v<T>, "Non-multiplication expression detected" )
constexpr bool IsMultExpr_v
Auxiliary variable template for the IsMultExpr type trait.
Definition IsMultExpr.h:116

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)
Value:
static_assert( ::blaze::IsNoAliasExpr_v<T>, "Non-no-alias expression type detected" )
constexpr bool IsNoAliasExpr_v
Auxiliary variable template for the IsNoAliasExpr type trait.
Definition IsNoAliasExpr.h:114

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)
Value:
static_assert( ::blaze::IsNoSIMDExpr_v<T>, "Non-no-SIMD expression type detected" )
constexpr bool IsNoSIMDExpr_v
Auxiliary variable template for the IsNoSIMDExpr type trait.
Definition IsNoSIMDExpr.h:114

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)
Value:
static_assert( ::blaze::IsOperation_v<T>, "Non-operation type detected" )
constexpr bool IsOperation_v
Auxiliary variable template for the IsOperation type trait.
Definition IsOperation.h:89

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)
Value:
static_assert( ::blaze::IsOpposedView_v<T>, "Non-opposed view detected" )
constexpr bool IsOpposedView_v
Auxiliary variable template for the IsOpposedView type trait.
Definition IsOpposedView.h:139

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)
Value:
static_assert( ::blaze::IsPadded_v<T>, "Non-padded type detected" )
constexpr bool IsPadded_v
Auxiliary variable template for the IsPadded type trait.
Definition IsPadded.h:134

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)
Value:
static_assert( ::blaze::IsPaddingEnabled_v<T>, "Non-padding enabled type detected" )
constexpr bool IsPaddingEnabled_v
Auxiliary variable template for the IsPaddingEnabled type trait.
Definition IsPaddingEnabled.h:131

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)
Value:
static_assert( ::blaze::IsProxy_v<T>, "Non-proxy type detected" )
constexpr bool IsProxy_v
Auxiliary variable template for the IsProxy type trait.
Definition IsProxy.h:127

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)
Value:
static_assert( ::blaze::IsReduceExpr_v<T>, "Non-reduce expression type detected" )
constexpr bool IsReduceExpr_v
Auxiliary variable template for the IsReduceExpr type trait.
Definition IsReduceExpr.h:114

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)
Value:
static_assert( ::blaze::IsRepeatExpr_v<T>, "Non-repeater expression type detected" )
constexpr bool IsRepeatExpr_v
Auxiliary variable template for the IsRepeatExpr type trait.
Definition IsRepeatExpr.h:114

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)
Value:
static_assert( ::blaze::IsResizable_v<T>, "Non-resizable type detected" )
constexpr bool IsResizable_v
Auxiliary variable template for the IsResizable type trait.
Definition IsResizable.h:136

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)
Value:
static_assert( ::blaze::IsRestricted_v<T>, "Unrestricted type detected" )
constexpr bool IsRestricted_v
Auxiliary variable template for the IsRestricted type trait.
Definition IsRestricted.h:140

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)
Value:
static_assert( ::blaze::IsRowMajorMatrix_v<T>, "Non-row-major matrix type detected" )
constexpr bool IsRowMajorMatrix_v
Auxiliary variable template for the IsRowMajorMatrix type trait.
Definition IsRowMajorMatrix.h:129

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)
Value:
static_assert( ::blaze::IsRow_v<T>, "Non-row type detected" )
constexpr bool IsRow_v
Auxiliary variable template for the IsRow type trait.
Definition IsRow.h:161

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)
Value:
static_assert( ::blaze::IsRowVector_v<T>, "Non-row vector type detected" )
constexpr bool IsRowVector_v
Auxiliary variable template for the IsRowVector type trait.
Definition IsRowVector.h:126

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)
Value:
static_assert( ::blaze::IsRows_v<T>, "Non-rows type detected" )
constexpr bool IsRows_v
Auxiliary variable template for the IsRows type trait.
Definition IsRows.h:161

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)
Value:
static_assert( ::blaze::IsScalar_v<T>, "Non-scalar type detected" )
constexpr bool IsScalar_v
Auxiliary variable template for the IsScalar type trait.
Definition IsScalar.h:104

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)
Value:
static_assert( ::blaze::IsSchurExpr_v<T>, "Non-Schur product expression type detected" )
constexpr bool IsSchurExpr_v
Auxiliary variable template for the IsSchurExpr type trait.
Definition IsSchurExpr.h:115

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)
Value:
static_assert( ::blaze::IsSerialExpr_v<T>, "Non-serial evaluation expression type detected" )
constexpr bool IsSerialExpr_v
Auxiliary variable template for the IsSerialExpr type trait.
Definition IsSerialExpr.h:115

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)
Value:
static_assert( ::blaze::IsShrinkable_v<T>, "Non-shrinkable type detected" )
constexpr bool IsShrinkable_v
Auxiliary variable template for the IsShrinkable type trait.
Definition IsShrinkable.h:121

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 )
Value:
static_assert( ::blaze::IsSIMDCombinable_v<T1,T2>, "Non-SIMD combinable types detected" )
constexpr bool IsSIMDCombinable_v
Auxiliary variable template for the IsSIMDCombinable type trait.
Definition IsSIMDCombinable.h:137

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)
Value:
static_assert( ::blaze::IsSIMDEnabled_v<T>, "Non-SIMD enabled type detected" )
constexpr bool IsSIMDEnabled_v
Auxiliary variable template for the IsSIMDEnabled type trait.
Definition IsSIMDEnabled.h:129

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)
Value:
static_assert( ::blaze::IsSIMDPack_v<T>, "Non-SIMD pack detected" )
constexpr bool IsSIMDPack_v
Auxiliary variable template for the IsSIMDPack type trait.
Definition IsSIMDPack.h:157

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)
Value:
static_assert( ::blaze::IsSMPAssignable_v<T>, "Non-SMP assignable type detected" )
constexpr bool IsSMPAssignable_v
Auxiliary variable template for the IsSMPAssignable type trait.
Definition IsSMPAssignable.h:132

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)
Value:
static_assert( ::blaze::IsSolveExpr_v<T>, "Non-solver expression type detected" )
constexpr bool IsSolveExpr_v
Auxiliary variable template for the IsSolveExpr type trait.
Definition IsSolveExpr.h:115

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)
Value:
static_assert( ::blaze::IsSparseElement_v<T>, "Non-sparse element type detected" )
constexpr bool IsSparseElement_v
Auxiliary variable template for the IsSparseElement type trait.
Definition IsSparseElement.h:89

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)
Value:
static_assert( ::blaze::IsSparseMatrix_v<T>, "Non-sparse matrix type detected" )
constexpr bool IsSparseMatrix_v
Auxiliary variable template for the IsSparseMatrix type trait.
Definition IsSparseMatrix.h:124

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)
Value:
static_assert( ::blaze::IsSparseVector_v<T>, "Non-sparse vector type detected" )
constexpr bool IsSparseVector_v
Auxiliary variable template for the IsSparseVector type trait.
Definition IsSparseVector.h:124

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)
Value:
static_assert( ::blaze::IsSquare_v<T>, "Non-square matrix type detected" )
constexpr bool IsSquare_v
Auxiliary variable template for the IsSquare type trait.
Definition IsSquare.h:146

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)
Value:
static_assert( ::blaze::IsStatic_v<T>, "Non-static type detected" )
constexpr bool IsStatic_v
Auxiliary variable template for the IsStatic type trait.
Definition IsStatic.h:109

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)
Value:
static_assert( ::blaze::IsStrictlyLower_v<T>, "Non-strictly lower triangular matrix type detected" )
constexpr bool IsStrictlyLower_v
Auxiliary variable template for the IsStrictlyLower type trait.
Definition IsStrictlyLower.h:173

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)
Value:
static_assert( ::blaze::IsStrictlyTriangular_v<T>, "Non-strictly triangular matrix type detected" )
constexpr bool IsStrictlyTriangular_v
Auxiliary variable template for the IsStrictlyTriangular type trait.
Definition IsStrictlyTriangular.h:106

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)
Value:
static_assert( ::blaze::IsStrictlyUpper_v<T>, "Non-strictly upper triangular matrix type detected" )
constexpr bool IsStrictlyUpper_v
Auxiliary variable template for the IsStrictlyUpper type trait.
Definition IsStrictlyUpper.h:173

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)
Value:
static_assert( ::blaze::IsSubExpr_v<T>, "Non-subtraction expression type detected" )
constexpr bool IsSubExpr_v
Auxiliary variable template for the IsSubExpr type trait.
Definition IsSubExpr.h:115

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)
Value:
static_assert( ::blaze::IsSubmatrix_v<T>, "Non-submatrix type detected" )
constexpr bool IsSubmatrix_v
Auxiliary variable template for the IsSubmatrix type trait.
Definition IsSubmatrix.h:161

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)
Value:
static_assert( ::blaze::IsSubvector_v<T>, "Non-subvector type detected" )
constexpr bool IsSubvector_v
Auxiliary variable template for the IsSubvector type trait.
Definition IsSubvector.h:161

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)
Value:
static_assert( ::blaze::IsSVDExpr_v<T>, "Non-singular value expression type detected" )
constexpr bool IsSVDExpr_v
Auxiliary variable template for the IsSVDExpr type trait.
Definition IsSVDExpr.h:114

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)
Value:
static_assert( ::blaze::IsSymmetric_v<T>, "Non-symmetric matrix type detected" )
constexpr bool IsSymmetric_v
Auxiliary variable template for the IsSymmetric type trait.
Definition IsSymmetric.h:172

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)
Value:
static_assert( ::blaze::IsTransExpr_v<T>, "Non-transposition expression type detected" )
constexpr bool IsTransExpr_v
Auxiliary variable template for the IsTransExpr type trait.
Definition IsTransExpr.h:115

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)
Value:
static_assert( ::blaze::IsTransformation_v<T>, "Non-transformation type detected" )
constexpr bool IsTransformation_v
Auxiliary variable template for the IsTransformation type trait.
Definition IsTransformation.h:89

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)
Value:
static_assert( ::blaze::IsTriangular_v<T>, "Non-triangular matrix type detected" )
constexpr bool IsTriangular_v
Auxiliary variable template for the IsTriangular type trait.
Definition IsTriangular.h:106

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)
Value:
static_assert( ::blaze::IsTVecMatMultExpr_v<T>, "Non-vector/matrix multiplication expression type detected" )
constexpr bool IsTVecMatMultExpr_v
Auxiliary variable template for the IsTVecMatMultExpr type trait.
Definition IsTVecMatMultExpr.h:117

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)
Value:
static_assert( ::blaze::IsUnaryMapExpr_v<T>, "Non-unary map expression type detected" )
constexpr bool IsUnaryMapExpr_v
Auxiliary variable template for the IsUnaryMapExpr type trait.
Definition IsUnaryMapExpr.h:114

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)
Value:
static_assert( ::blaze::IsUniform_v<T>, "Non-uniform type detected" )
constexpr bool IsUniform_v
Auxiliary variable template for the IsUniform type trait.
Definition IsUniform.h:164

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)
Value:
static_assert( ::blaze::IsUniLower_v<T>, "Non-lower unitriangular matrix type detected" )
constexpr bool IsUniLower_v
Auxiliary variable template for the IsUniLower type trait.
Definition IsUniLower.h:173

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)
Value:
static_assert( ::blaze::IsUniTriangular_v<T>, "Non-unitriangular matrix type detected" )
constexpr bool IsUniTriangular_v
Auxiliary variable template for the IsUniTriangular type trait.
Definition IsUniTriangular.h:106

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)
Value:
static_assert( ::blaze::IsUniUpper_v<T>, "Non-upper unitriangular matrix type detected" )
constexpr bool IsUniUpper_v
Auxiliary variable template for the IsUniUpper type trait.
Definition IsUniUpper.h:173

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)
Value:
static_assert( ::blaze::IsUpper_v<T>, "Non-upper triangular matrix type detected" )
constexpr bool IsUpper_v
Auxiliary variable template for the IsUpper type trait.
Definition IsUpper.h:175

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)
Value:
static_assert( ::blaze::IsVecEvalExpr_v<T>, "Non-vector evaluation expression type detected" )
constexpr bool IsVecEvalExpr_v
Auxiliary variable template for the IsVecEvalExpr type trait.
Definition IsVecEvalExpr.h:115

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)
Value:
static_assert( ::blaze::IsVecExpandExpr_v<T>, "Non-vector expansion expression type detected" )
constexpr bool IsVecExpandExpr_v
Auxiliary variable template for the IsVecExpandExpr type trait.
Definition IsVecExpandExpr.h:115

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)
Value:
static_assert( ::blaze::IsVecGenExpr_v<T>, "Non-vector generator expression type detected" )
constexpr bool IsVecGenExpr_v
Auxiliary variable template for the IsVecGenExpr type trait.
Definition IsVecGenExpr.h:115

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)
Value:
static_assert( ::blaze::IsVecMapExpr_v<T>, "Non-unary vector map expression type detected" )
constexpr bool IsVecMapExpr_v
Auxiliary variable template for the IsVecMapExpr type trait.
Definition IsVecMapExpr.h:115

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)
Value:
static_assert( ::blaze::IsVecNoAliasExpr_v<T>, "Non-vector no-alias expression type detected" )
constexpr bool IsVecNoAliasExpr_v
Auxiliary variable template for the IsVecNoAliasExpr type trait.
Definition IsVecNoAliasExpr.h:115

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)
Value:
static_assert( ::blaze::IsVecNoSIMDExpr_v<T>, "Non-vector no-SIMD expression type detected" )
constexpr bool IsVecNoSIMDExpr_v
Auxiliary variable template for the IsVecNoSIMDExpr type trait.
Definition IsVecNoSIMDExpr.h:115

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)
Value:
static_assert( ::blaze::IsVecRepeatExpr_v<T>, "Non-vector repeater expression type detected" )
constexpr bool IsVecRepeatExpr_v
Auxiliary variable template for the IsVecRepeatExpr type trait.
Definition IsVecRepeatExpr.h:115

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)
Value:
static_assert( ::blaze::IsVecScalarDivExpr_v<T>, "Non-vector/scalar division expression type detected" )
constexpr bool IsVecScalarDivExpr_v
Auxiliary variable template for the IsVecScalarDivExpr type trait.
Definition IsVecScalarDivExpr.h:116

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)
Value:
static_assert( ::blaze::IsVecScalarMultExpr_v<T>, "Non-vector/scalar multiplication expression type detected" )
constexpr bool IsVecScalarMultExpr_v
Auxiliary variable template for the IsVecScalarMultExpr type trait.
Definition IsVecScalarMultExpr.h:117

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)
Value:
static_assert( ::blaze::IsVecSerialExpr_v<T>, "Non-vector serial evaluation expression type detected" )
constexpr bool IsVecSerialExpr_v
Auxiliary variable template for the IsVecSerialExpr type trait.
Definition IsVecSerialExpr.h:115

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)
Value:
static_assert( ::blaze::IsVector_v<T>, "Non-vector type detected" )
constexpr bool IsVector_v
Auxiliary variable template for the IsVector type trait.
Definition IsVector.h:125

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" )
constexpr bool TransposeFlag_v
Auxiliary variable template for the TransposeFlag type trait.
Definition TransposeFlag.h:93

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)
Value:
static_assert( ::blaze::IsVecTransExpr_v<T>, "Non-vector transposition expression type detected" )
constexpr bool IsVecTransExpr_v
Auxiliary variable template for the IsVecTransExpr type trait.
Definition IsVecTransExpr.h:115

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)
Value:
static_assert( ::blaze::IsVecTVecMapExpr_v<T>, "Non-outer map expression type detected" )
constexpr bool IsVecTVecMapExpr_v
Auxiliary variable template for the IsVecTVecMapExpr type trait.
Definition IsVecTVecMapExpr.h:115

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)
Value:
static_assert( ::blaze::IsVecTVecMultExpr_v<T>, "Non-outer product expression type detected" )
constexpr bool IsVecTVecMultExpr_v
Auxiliary variable template for the IsVecTVecMultExpr type trait.
Definition IsVecTVecMultExpr.h:116

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)
Value:
static_assert( ::blaze::IsVecVecAddExpr_v<T>, "Non-vector/vector addition expression type detected" )
constexpr bool IsVecVecAddExpr_v
Auxiliary variable template for the IsVecVecAddExpr type trait.
Definition IsVecVecAddExpr.h:115

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)
Value:
static_assert( ::blaze::IsVecVecDivExpr_v<T>, "Non-vector/vector division expression type detected" )
constexpr bool IsVecVecDivExpr_v
Auxiliary variable template for the IsVecVecDivExpr type trait.
Definition IsVecVecDivExpr.h:116

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)
Value:
static_assert( ::blaze::IsVecVecKronExpr_v<T>, "Non-vector/vector Kronecker product expression type detected" )
constexpr bool IsVecVecKronExpr_v
Auxiliary variable template for the IsVecVecKronExpr type trait.
Definition IsVecVecKronExpr.h:116

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)
Value:
static_assert( ::blaze::IsVecVecMapExpr_v<T>, "Non-binary vector map expression type detected" )
constexpr bool IsVecVecMapExpr_v
Auxiliary variable template for the IsVecVecMapExpr type trait.
Definition IsVecVecMapExpr.h:115

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)
Value:
static_assert( ::blaze::IsVecVecMultExpr_v<T>, "Non-vector/vector multiplication expression type detected" )
constexpr bool IsVecVecMultExpr_v
Auxiliary variable template for the IsVecVecMultExpr type trait.
Definition IsVecVecMultExpr.h:116

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)
Value:
static_assert( ::blaze::IsVecVecSubExpr_v<T>, "Non-vector/vector subtraction expression type detected" )
constexpr bool IsVecVecSubExpr_v
Auxiliary variable template for the IsVecVecSubExpr type trait.
Definition IsVecVecSubExpr.h:116

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)
Value:
static_assert( ::blaze::IsView_v<T>, "Non-view type detected" )
constexpr bool IsView_v
Auxiliary variable template for the IsView type trait.
Definition IsView.h:134

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)
Value:
static_assert( ::blaze::IsZero_v<T>, "Non-zero type detected" )
constexpr bool IsZero_v
Auxiliary variable template for the IsZero type trait.
Definition IsZero.h:166

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::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
( ( ::blaze::Size_v<T1,1UL> == -1L ) || \
( ::blaze::Size_v<T2,1UL> == -1L ) || \
, "Invalid matrix/matrix addition expression detected" )
constexpr ptrdiff_t Size_v
Auxiliary variable template for the Size type trait.
Definition Size.h:176

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> && \
, "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::Size_v<T1,1UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
, "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:

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::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
( ( ::blaze::Size_v<T1,1UL> == -1L ) || \
( ::blaze::Size_v<T2,1UL> == -1L ) || \
, "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::Size_v<T1,1UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
, "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:

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::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
( ( ::blaze::Size_v<T1,1UL> == -1L ) || \
( ::blaze::Size_v<T2,1UL> == -1L ) || \
, "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::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
, "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> && \
, "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:
( ( ::blaze::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
, "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:
( ( ::blaze::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
, "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> && \
, "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:
( ( ::blaze::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
, "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:
( ( ::blaze::Size_v<T1,0UL> == -1L ) || \
( ::blaze::Size_v<T2,0UL> == -1L ) || \
, "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)
Value:
static_assert( ::blaze::HasCompositeType_v<T>, "Type without composite type detected" )
constexpr bool HasCompositeType_v
Auxiliary variable template for the HasCompositeType type trait.
Definition HasCompositeType.h:92

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)
Value:
static_assert( ::blaze::HasConstDataAccess_v<T>, "Type without const data access detected" )
constexpr bool HasConstDataAccess_v
Auxiliary variable template for the HasConstDataAccess type trait.
Definition HasConstDataAccess.h:133

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)
Value:
static_assert( ::blaze::HasMutableDataAccess_v<T>, "Type without mutable data access detected" )
constexpr bool HasMutableDataAccess_v
Auxiliary variable template for the HasMutableDataAccess type trait.
Definition HasMutableDataAccess.h:133

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)
Value:
static_assert( ::blaze::HasResultType_v<T>, "Type without result type detected" )
constexpr bool HasResultType_v
Auxiliary variable template for the HasResultType type trait.
Definition HasResultType.h:92

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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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 )
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
static_assert( !::blaze::IsInitializer_v<T>, "Initializer type dected" )
constexpr bool IsInitializer_v
Auxiliary variable template for the IsInitializer type trait.
Definition IsInitializer.h:140

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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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 )
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
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)
Value:
static_assert( !::blaze::RequiresEvaluation_v<T>, "Type with evaluation requirement detected" )
constexpr bool RequiresEvaluation_v
Auxiliary variable template for the RequiresEvaluation type trait.
Definition RequiresEvaluation.h:91

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)
Value:
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::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::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.