|
#define | BLAZE_CONSTRAINT_MUST_BE_ADAPTOR_TYPE(T) static_assert( ::blaze::IsAdaptor<T>::value, "Non-adaptor type detected" ) |
| Constraint on the data type.In case the given data type T is not an adaptor type (as for instance a LowerMatrix, UpperMatrix, or SymmetricMatrix) a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_ADAPTOR_TYPE(T) static_assert( !::blaze::IsAdaptor<T>::value, "Adaptor type detected" ) |
| Constraint on the data type.In case the given data type T is an adaptor type (as for instance LowerMatrix, UpperMatrix, or SymmetricMatrix) a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_ADDEXPR_TYPE(T) static_assert( ::blaze::IsAddExpr<T>::value, "Non-addition expression type detected" ) |
| Constraint on the data type.In case the given data type T is not an addition expression (i.e. a type derived from the AddExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_ADDEXPR_TYPE(T) static_assert( !::blaze::IsAddExpr<T>::value, "Addition expression type detected" ) |
| Constraint on the data type.In case the given data type T is an addition expression (i.e. a type derived from the AddExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_ALIGNED_TYPE(T) static_assert( ::blaze::IsAligned<T>::value, "Non-aligned type detected" ) |
| Constraint on the data type.In case the given data type T does not provide aligned data values with respect to the requirements of the available instruction set a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_ALIGNED_TYPE(T) static_assert( !::blaze::IsAligned<T>::value, "Aligned type detected" ) |
| Constraint on the data type.In case the given data type T does provide aligned data values with respect to the requirements of the available instruction set a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_BINARYMAPEXPR_TYPE(T) static_assert( ::blaze::IsBinaryMapExpr<T>::value, "Non-binary map expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a binary map expression (i.e. a type derived from the BinaryMapExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_BINARYMAPEXPR_TYPE(T) static_assert( !::blaze::IsBinaryMapExpr<T>::value, "Binary map expression type detected" ) |
| Constraint on the data type.In case the given data type T is a binary map expression (i.e. a type derived from the BinaryMapExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_BLAS_COMPATIBLE_TYPE(T) static_assert( ::blaze::IsBLASCompatible<T>::value, "Non-BLAS compatible type detected" ) |
| Constraint on the data type.In case the given data type T is not a BLAS compatible data type (i.e. float, double, complex<float>, or complex<double>), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_BLAS_COMPATIBLE_TYPE(T) static_assert( !::blaze::IsBLASCompatible<T>::value, "BLAS compatible type detected" ) |
| Constraint on the data type.In case the given data type T is a BLAS compatible type (i.e. float, double, complex<float>, or complex<double>), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_COLUMN_TYPE(T) static_assert( ::blaze::IsColumn<T>::value, "Non-column type detected" ) |
| Constraint on the data type.In case the given data type T is not a column type (i.e. a dense or sparse column), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMN_TYPE(T) static_assert( !::blaze::IsColumn<T>::value, "Column type detected" ) |
| Constraint on the data type.In case the given data type T is a column type (i.e. a dense or sparse column), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T) static_assert( ::blaze::IsColumnMajorMatrix<T>::value, "Non-column-major matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a column-major dense or sparse matrix type (i.e. a matrix type whose storage order is set to true) a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMN_MAJOR_MATRIX_TYPE(T) static_assert( !::blaze::IsColumnMajorMatrix<T>::value, "Column-major matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a column-major dense or sparse matrix type (i.e. a matrix type whose storage order is set to true) a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_HAVE_EQUAL_NUMBER_OF_COLUMNS(T1, T2) |
| Constraint on the data type.In case the number of columns of the two given matrix types T1 and T2 can be evaluated at compile time and in case the number of columns is not equal, a compilation error is created. Note that in case the number of columns of either of the two matrix types cannot be determined no compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_HAVE_EQUAL_NUMBER_OF_COLUMNS(T1, T2) |
| Constraint on the data type.In case the number of columns of the two given matrix types T1 and T2 can be evaluated at compile time and in case the number of columns is equal, a compilation error is created. Note that in case the number of columns of either of the two matrix types cannot be determined no compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_COLUMN_VECTOR_TYPE(T) static_assert( ::blaze::IsColumnVector<T>::value, "Non-column vector type detected" ) |
| Constraint on the data type.In case the given data type T is not a column dense or sparse vector type (i.e. a vector type whose transposition flag is set to blaze::columnVector) a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMN_VECTOR_TYPE(T) static_assert( !::blaze::IsColumnVector<T>::value, "Column vector type detected" ) |
| Constraint on the data type.In case the given data type T is a column dense or sparse vector type (i.e. a vector type whose transposition flag is set to blaze::columnVector) a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_COMPUTATION_TYPE(T) static_assert( ::blaze::IsComputation<T>::value, "Non-computation type detected" ) |
| Constraint on the data type.In case the given data type T is not a computational expression (i.e. a type derived from the Computation base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE(T) static_assert( !::blaze::IsComputation<T>::value, "Computation type detected" ) |
| Constraint on the data type.In case the given data type T is a computational expression (i.e. a type derived from the Computation base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_HAVE_CONST_DATA_ACCESS(T) static_assert( ::blaze::HasConstDataAccess<T>::value, "Type without const data access detected" ) |
| Constraint on the data type.In case the given data type T does not provide low-level data access to constant data, i.e. does not have a const 'data' member function, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_HAVE_CONST_DATA_ACCESS(T) static_assert( !::blaze::HasConstDataAccess<T>::value, "Type with const data access detected" ) |
| Constraint on the data type.In case the given data type T does provide low-level data access to constant data, i.e. does have a const 'data' member function, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_CROSSEXPR_TYPE(T) static_assert( ::blaze::IsCrossExpr<T>::value, "Non-cross product expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a cross product expression (i.e. a type derived from the CrossExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_CROSSEXPR_TYPE(T) static_assert( !::blaze::IsCrossExpr<T>::value, "Cross product expression type detected" ) |
| Constraint on the data type.In case the given data type T is a cross product expression (i.e. a type derived from the CrossExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_CUSTOM_TYPE(T) static_assert( ::blaze::IsCustom<T>::value, "Non-custom type detected" ) |
| Constraint on the data type.In case the given data type T is not a custom data type, i.e. a custom vector or matrix, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_CUSTOM_TYPE(T) static_assert( !::blaze::IsCustom<T>::value, "Custom type dected" ) |
| Constraint on the data type.In case the given data type T is a custom data type, i.e. a custom vector or matrix, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_DECLARATION_TYPE(T) static_assert( ::blaze::IsDeclaration<T>::value, "Non-declaration type detected" ) |
| Constraint on the data type.In case the given data type T is not a declaration expression (i.e. a type derived from the Declaration base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_DECLARATION_TYPE(T) static_assert( !::blaze::IsDeclaration<T>::value, "Declaration type detected" ) |
| Constraint on the data type.In case the given data type T is a declaration expression (i.e. a type derived from the Declaration base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_DECLDIAGEXPR_TYPE(T) static_assert( ::blaze::IsDeclDiagExpr<T>::value, "Non-decldiag expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a decldiag expression (i.e. a type derived from the DeclDiagExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_DECLDIAGEXPR_TYPE(T) static_assert( !::blaze::IsDeclDiagExpr<T>::value, "Decldiag expression type detected" ) |
| Constraint on the data type.In case the given data type T is a decldiag expression (i.e. a type derived from the DeclDiagExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_DECLEXPR_TYPE(T) static_assert( ::blaze::IsDeclExpr<T>::value, "Non-declaration expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a declaration expression (i.e. a type derived from the DeclExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_DECLEXPR_TYPE(T) static_assert( !::blaze::IsDeclExpr<T>::value, "Declaration expression type detected" ) |
| Constraint on the data type.In case the given data type T is a declaration expression (i.e. a type derived from the DeclExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_DECLHERMEXPR_TYPE(T) static_assert( ::blaze::IsDeclHermExpr<T>::value, "Non-declherm expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a declherm expression (i.e. a type derived from the DeclHermExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_DECLHERMEXPR_TYPE(T) static_assert( !::blaze::IsDeclHermExpr<T>::value, "Declherm expression type detected" ) |
| Constraint on the data type.In case the given data type T is a declherm expression (i.e. a type derived from the DeclHermExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_DECLLOWEXPR_TYPE(T) static_assert( ::blaze::IsDeclLowExpr<T>::value, "Non-decllow expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a decllow expression (i.e. a type derived from the DeclLowExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_DECLLOWEXPR_TYPE(T) static_assert( !::blaze::IsDeclLowExpr<T>::value, "Decllow expression type detected" ) |
| Constraint on the data type.In case the given data type T is a decllow expression (i.e. a type derived from the DeclLowExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_DECLSYMEXPR_TYPE(T) static_assert( ::blaze::IsDeclSymExpr<T>::value, "Non-declsym expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a declsym expression (i.e. a type derived from the DeclSymExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_DECLSYMEXPR_TYPE(T) static_assert( !::blaze::IsDeclSymExpr<T>::value, "Declsym expression type detected" ) |
| Constraint on the data type.In case the given data type T is a declsym expression (i.e. a type derived from the DeclSymExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_DECLUPPEXPR_TYPE(T) static_assert( ::blaze::IsDeclUppExpr<T>::value, "Non-declupp expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a declupp expression (i.e. a type derived from the DeclUppExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_DECLUPPEXPR_TYPE(T) static_assert( !::blaze::IsDeclUppExpr<T>::value, "Declupp expression type detected" ) |
| Constraint on the data type.In case the given data type T is a declupp expression (i.e. a type derived from the DeclUppExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T) static_assert( ::blaze::IsDenseMatrix<T>::value, "Non-dense matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_DENSE_MATRIX_TYPE(T) static_assert( !::blaze::IsDenseMatrix<T>::value, "Dense matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a dense, N-dimensional matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_DENSE_VECTOR_TYPE(T) static_assert( ::blaze::IsDenseVector<T>::value, "Non-dense vector type detected" ) |
| Constraint on the data type.In case the given data type T is not a dense, N-dimensional vector type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_DENSE_VECTOR_TYPE(T) static_assert( !::blaze::IsDenseVector<T>::value, "Dense vector type detected" ) |
| Constraint on the data type.In case the given data type T is a dense, N-dimensional vector type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_DIAGONAL_MATRIX_TYPE(T) static_assert( ::blaze::IsDiagonal<T>::value, "Non-diagonal matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a diagonal matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_DIAGONAL_MATRIX_TYPE(T) static_assert( !::blaze::IsDiagonal<T>::value, "Diagonal matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a diagonal matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_DIVEXPR_TYPE(T) static_assert( ::blaze::IsDivExpr<T>::value, "Non-division expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a division expression (i.e. a type derived from the DivExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_DIVEXPR_TYPE(T) static_assert( !::blaze::IsDivExpr<T>::value, "Division expression type detected" ) |
| Constraint on the data type.In case the given data type T is a division expression (i.e. a type derived from the DivExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_EVALEXPR_TYPE(T) static_assert( ::blaze::IsEvalExpr<T>::value, "Non-evaluation expression type detected" ) |
| Constraint on the data type.In case the given data type T is not an evaluation expression (i.e. a type derived from the EvalExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_EVALEXPR_TYPE(T) static_assert( !::blaze::IsEvalExpr<T>::value, "Evaluation expression type detected" ) |
| Constraint on the data type.In case the given data type T is an evaluation expression (i.e. a type derived from the EvalExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_EXPRESSION_TYPE(T) static_assert( ::blaze::IsExpression<T>::value, "Non-expression type detected" ) |
| Constraint on the data type.In case the given data type T is not an expression (i.e. a type derived from the Expression base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_EXPRESSION_TYPE(T) static_assert( !::blaze::IsExpression<T>::value, "Expression type detected" ) |
| Constraint on the data type.In case the given data type T is an expression (i.e. a type derived from the Expression base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_GENERAL_MATRIX_TYPE(T) static_assert( ::blaze::IsGeneral<T>::value, "Non-general matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a general matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_GENERAL_MATRIX_TYPE(T) static_assert( !::blaze::IsGeneral<T>::value, "General matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a general matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_HERMITIAN_MATRIX_TYPE(T) static_assert( ::blaze::IsHermitian<T>::value, "Non-Hermitian matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not an Hermitian matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_HERMITIAN_MATRIX_TYPE(T) static_assert( !::blaze::IsHermitian<T>::value, "Hermitian matrix type detected" ) |
| Constraint on the data type.In case the given data type T is an Hermitian matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_IDENTITY_MATRIX_TYPE(T) static_assert( ::blaze::IsIdentity<T>::value, "Non-identity matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not an identity matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_IDENTITY_MATRIX_TYPE(T) static_assert( !::blaze::IsIdentity<T>::value, "Identity matrix type detected" ) |
| Constraint on the data type.In case the given data type T is an identity matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_INVERTIBLE_TYPE(T) static_assert( ::blaze::IsInvertible<T>::value, "Non-invertible type detected" ) |
| Constraint on the data type.In case the given data type T is not an invertible data type (i.e. a BLAS compatible type, long double , or any matrix with BLAS compatible element type), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_INVERTIBLE_TYPE(T) static_assert( !blaze::IsInvertible<T>::value, "Invertible type detected" ) |
| Constraint on the data type.In case the given data type T is an invertible data type (i.e. a BLAS compatible type, long double , or any matrix with BLAS compatible element type), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE(T) static_assert( ::blaze::IsLower<T>::value, "Non-lower triangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a lower triangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T) static_assert( !::blaze::IsLower<T>::value, "Lower triangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a lower triangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_MATEVALEXPR_TYPE(T) static_assert( ::blaze::IsMatEvalExpr<T>::value, "Non-matrix evaluation expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a matrix evaluation expression (i.e. a type derived from the MatEvalExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_MATEVALEXPR_TYPE(T) static_assert( !::blaze::IsMatEvalExpr<T>::value, "Matrix evaluation expression type detected" ) |
| Constraint on the data type.In case the given data type T is a matrix evaluation expression (i.e. a type derived from the MatEvalExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_MATINVEXPR_TYPE(T) static_assert( ::blaze::IsMatInvExpr<T>::value, "Non-matrix inversion expression detected" ) |
| Constraint on the data type.In case the given data type T is not a matrix inversion expression (i.e. a type derived from the MatInvExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_MATINVEXPR_TYPE(T) static_assert( !::blaze::IsMatInvExpr<T>::value, "Matrix inversion expression detected" ) |
| Constraint on the data type.In case the given data type T is a matrix inversion expression (i.e. a type derived from the MatInvExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_MATMAPEXPR_TYPE(T) static_assert( ::blaze::IsMatMapExpr<T>::value, "Non-unary matrix map expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a unary matrix map expression (i.e. a type derived from the MatMapExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_MATMAPEXPR_TYPE(T) static_assert( !::blaze::IsMatMapExpr<T>::value, "Unary matrix map expression type detected" ) |
| Constraint on the data type.In case the given data type T is a unary matrix map expression (i.e. a type derived from the MatMapExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_MATMATADDEXPR_TYPE(T) static_assert( ::blaze::IsMatMatAddExpr<T>::value, "Non-matrix/matrix addition expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a matrix/matrix addition expression (i.e. a type derived from the MatMatAddExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATADDEXPR_TYPE(T) static_assert( !::blaze::IsMatMatAddExpr<T>::value, "Matrix/matrix addition expression type detected" ) |
| Constraint on the data type.In case the given data type T is a matrix/matrix addition expression (i.e. a type derived from the MatMatAddExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATADDEXPR(T1, T2) |
| Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix addition, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_MATMATMAPEXPR_TYPE(T) static_assert( ::blaze::IsMatMatMapExpr<T>::value, "Non-binary matrix map expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a binary matrix map expression (i.e. a type derived from the MatMatMapExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATMAPEXPR_TYPE(T) static_assert( !::blaze::IsMatMatMapExpr<T>::value, "Binary matrix map expression type detected" ) |
| Constraint on the data type.In case the given data type T is a binary matrix map expression (i.e. a type derived from the MatMatMapExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_MATMATMULTEXPR_TYPE(T) static_assert( ::blaze::IsMatMatMultExpr<T>::value, "Non-matrix/matrix multiplication expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a matrix/matrix multiplication expression (i.e. a type derived from the MatMatMultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATMULTEXPR_TYPE(T) static_assert( !::blaze::IsMatMatMultExpr<T>::value, "Matrix/matrix multiplication expression type detected" ) |
| Constraint on the data type.In case the given data type T is a matrix/matrix multiplication expression (i.e. a type derived from the MatMatMultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATMULTEXPR(T1, T2) |
| Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix multiplication, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_MATMATSUBEXPR_TYPE(T) static_assert( ::blaze::IsMatMatSubExpr<T>::value, "Non-matrix/matrix subtraction expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a matrix/matrix subtraction expression (i.e. a type derived from the MatMatSubExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATSUBEXPR_TYPE(T) static_assert( !::blaze::IsMatMatSubExpr<T>::value, "Matrix/matrix subtraction expression type detected" ) |
| Constraint on the data type.In case the given data type T is a matrix/matrix subtraction expression (i.e. a type derived from the MatMatSubExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATSUBEXPR(T1, T2) |
| Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix subtraction, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_MATRIX_TYPE(T) static_assert( ::blaze::IsMatrix<T>::value, "Non-matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a N-dimensional matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_MATRIX_TYPE(T) static_assert( !::blaze::IsMatrix<T>::value, "Matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a N-dimensional matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_MATSCALARDIVEXPR_TYPE(T) static_assert( ::blaze::IsMatScalarDivExpr<T>::value, "Non-matrix/scalar division expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a matrix/scalar division expression (i.e. a type derived from the MatScalarDivExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_MATSCALARDIVEXPR_TYPE(T) static_assert( !::blaze::IsMatScalarDivExpr<T>::value, "Matrix/scalar division expression type detected" ) |
| Constraint on the data type.In case the given data type T is a matrix/scalar division expression (i.e. a type derived from the MatScalarDivExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_MATSCALARMULTEXPR_TYPE(T) static_assert( ::blaze::IsMatScalarMultExpr<T>::value, "Non-matrix/scalar multiplication expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a matrix/scalar multiplication expression (i.e. a type derived from the MatScalarMultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_MATSCALARMULTEXPR_TYPE(T) static_assert( !::blaze::IsMatScalarMultExpr<T>::value, "Matrix/scalar multiplication expression type detected" ) |
| Constraint on the data type.In case the given data type T is a matrix/scalar multiplication expression (i.e. a type derived from the MatScalarMultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_MATSERIALEXPR_TYPE(T) static_assert( ::blaze::IsMatSerialExpr<T>::value, "Non-matrix serial evaluation expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a matrix serial evaluation expression (i.e. a type derived from the MatSerialExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_MATSERIALEXPR_TYPE(T) static_assert( !::blaze::IsMatSerialExpr<T>::value, "Matrix serial evaluation expression type detected" ) |
| Constraint on the data type.In case the given data type T is a matrix serial evaluation expression (i.e. a type derived from the MatSerialExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_MATTRANSEXPR_TYPE(T) static_assert( ::blaze::IsMatTransExpr<T>::value, "Non-matrix transposition expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a matrix transposition expression (i.e. a type derived from the MatTransExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_MATTRANSEXPR_TYPE(T) static_assert( !::blaze::IsMatTransExpr<T>::value, "Matrix transposition expression type detected" ) |
| Constraint on the data type.In case the given data type T is a matrix transposition expression (i.e. a type derived from the MatTransExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_MATVECMULTEXPR_TYPE(T) static_assert( ::blaze::IsMatVecMultExpr<T>::value, "Non-matrix/vector multiplication expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a matrix/vector multiplication expression (i.e. a type derived from the MatVecMultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_MATVECMULTEXPR_TYPE(T) static_assert( !::blaze::IsMatVecMultExpr<T>::value, "Matrix/vector multiplication expression type detected" ) |
| Constraint on the data type.In case the given data type T is a matrix/vector multiplication expression (i.e. a type derived from the MatVecMultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_FORM_VALID_MATVECMULTEXPR(T1, T2) |
| Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/vector multiplication, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_MULTEXPR_TYPE(T) static_assert( ::blaze::IsMultExpr<T>::value, "Non-multiplication expression detected" ) |
| Constraint on the data type.In case the given data type T is not a multiplication expression (i.e. a type derived from the MultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_MULTEXPR_TYPE(T) static_assert( !::blaze::IsMultExpr<T>::value, "Multiplication expression detected" ) |
| Constraint on the data type.In case the given data type T is a multiplication expression (i.e. a type derived from the MultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_HAVE_MUTABLE_DATA_ACCESS(T) static_assert( ::blaze::HasMutableDataAccess<T>::value, "Type without mutable data access detected" ) |
| Constraint on the data type.In case the given data type T does not provide low-level data access to mutable data, i.e. does not have a non-const 'data' member function, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_HAVE_MUTABLE_DATA_ACCESS(T) static_assert( !::blaze::HasMutableDataAccess<T>::value, "Type with mutable data access detected" ) |
| Constraint on the data type.In case the given data type T does provide low-level data access to mutable data, i.e. does have a non-const 'data' member function, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_NUMERIC_MATRIX_TYPE(T) static_assert( ::blaze::IsNumericMatrix<T>::value, "Non-numeric matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a numeric matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_NUMERIC_MATRIX_TYPE(T) static_assert( !::blaze::IsNumericMatrix_<T>, "Numeric matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a numeric matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_NUMERIC_VECTOR_TYPE(T) static_assert( ::blaze::IsNumericVector<T>::value, "Non-numeric vector type detected" ) |
| Constraint on the data type.In case the given data type T is not a numeric vector type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_NUMERIC_VECTOR_TYPE(T) static_assert( !::blaze::IsNumericVector<T>::value, "Numeric vector type detected" ) |
| Constraint on the data type.In case the given data type T is a numeric vector type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_OPERATION_TYPE(T) static_assert( ::blaze::IsOperation<T>::value, "Non-operation type detected" ) |
| Constraint on the data type.In case the given data type T is not an operational expression (i.e. a type derived from the Operation base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_OPERATION_TYPE(T) static_assert( !::blaze::IsOperation<T>::value, "Operation type detected" ) |
| Constraint on the data type.In case the given data type T is an operational expression (i.e. a type derived from the Operation base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_OPPOSED_VIEW(T) static_assert( ::blaze::IsOpposedView<T>::value, "Non-opposed view detected" ) |
| Constraint on the data type.In case the given data type T is not an opposed view, i.e. is not a view that is opposed to the natural storage order of its underlying type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_OPPOSED_VIEW(T) static_assert( !::blaze::IsOpposedView<T>::value, "Opposed view detected" ) |
| Constraint on the data type.In case the given data type T is an opposed view, i.e. is a view that is opposed to the natural storage order of its underlying type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_PADDED_TYPE(T) static_assert( ::blaze::IsPadded<T>::value, "Non-padded type detected" ) |
| Constraint on the data type.In case the given data type T does not employ or simulate padding (i.e. a special treatment of remainder elements is necessary) a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_PADDED_TYPE(T) static_assert( !::blaze::IsPadded<T>::value, "Padded type detected" ) |
| Constraint on the data type.In case the given data type T does employ or simulate padding (i.e. no special treatment of remainder elements is necessary) a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_PROXY_TYPE(T) static_assert( ::blaze::IsProxy<T>::value, "Non-proxy type detected" ) |
| Constraint on the data type.In case the given data type T is not a proxy type (i.e. a type derived from the Proxy class template), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_PROXY_TYPE(T) static_assert( !::blaze::IsProxy<T>::value, "Proxy type detected" ) |
| Constraint on the data type.In case the given data type T is a proxy type (i.e. a type derived from the Proxy class template), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_REQUIRE_EVALUATION(T) static_assert( ::blaze::RequiresEvaluation<T>::value, "Type without evaluation requirement detected" ) |
| Constraint on the data type.In case the given data type T does not require an intermediate evaluation within composite expressions, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T) static_assert( !::blaze::RequiresEvaluation<T>::value, "Type with evaluation requirement detected" ) |
| Constraint on the data type.In case the given data type T requires an intermediate evaluation within composite expressions, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_RESIZABLE_TYPE(T) static_assert( ::blaze::IsResizable<T>::value, "Non-resizable type detected" ) |
| Constraint on the data type.In case the given data type T is not resizable, i.e. does not have a 'resize' member function that could be used to change the size, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_RESIZABLE_TYPE(T) static_assert( !::blaze::IsResizable<T>::value, "Resizable type detected" ) |
| Constraint on the data type.In case the given data type T is resizable, i.e. has a 'resize' member function that can be used to change the size, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_RESTRICTED(T) static_assert( ::blaze::IsRestricted<T>::value, "Unrestricted type detected" ) |
| Constraint on the data type.In case the given data type T does not have a restricted data access, i.e. does not restrict specific operations on its data, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_RESTRICTED(T) static_assert( !::blaze::IsRestricted<T>::value, "Restricted type detected" ) |
| Constraint on the data type.In case the given data type T does have a restricted data access, i.e. does not restrict any operation on its data, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_ROW_TYPE(T) static_assert( ::blaze::IsRow<T>::value, "Non-row type detected" ) |
| Constraint on the data type.In case the given data type T is not a row type (i.e. a dense or sparse row), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_ROW_TYPE(T) static_assert( !::blaze::IsRow<T>::value, "Row type detected" ) |
| Constraint on the data type.In case the given data type T is a row type (i.e. a dense or sparse row), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T) static_assert( ::blaze::IsRowMajorMatrix<T>::value, "Non-row-major matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix type (i.e. a matrix type whose storage order is set to false) a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_ROW_MAJOR_MATRIX_TYPE(T) static_assert( !::blaze::IsRowMajorMatrix<T>::value, "Row-major matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a row-major dense or sparse matrix type (i.e. a matrix type whose storage order is set to false) a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_HAVE_EQUAL_NUMBER_OF_ROWS(T1, T2) |
| Constraint on the data type.In case the number of rows of the two given matrix types T1 and T2 can be evaluated at compile time and in case the number of rows is not equal, a compilation error is created. Note that in case the number of rows of either of the two matrix types cannot be determined no compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_HAVE_EQUAL_NUMBER_OF_ROWS(T1, T2) |
| Constraint on the data type.In case the number of rows of the two given matrix types T1 and T2 can be evaluated at compile time and in case the number of rows is equal, a compilation error is created. Note that in case the number of rows of either of the two matrix types cannot be determined no compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_ROW_VECTOR_TYPE(T) static_assert( ::blaze::IsRowVector<T>::value, "Non-row vector type detected" ) |
| Constraint on the data type.In case the given data type T is not a row dense or sparse vector type (i.e. a vector type whose transposition flag is set to blaze::rowVector) a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_ROW_VECTOR_TYPE(T) static_assert( !::blaze::IsRowVector<T>::value, "Row vector type detected" ) |
| Constraint on the data type.In case the given data type T is a row dense or sparse vector type (i.e. a vector type whose transposition flag is set to blaze::rowVector) a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_SCHUREXPR_TYPE(T) static_assert( ::blaze::IsSchurExpr<T>::value, "Non-Schur product expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a Schur product expression (i.e. a type derived from the SchurExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SCHUREXPR_TYPE(T) static_assert( !::blaze::IsSchurExpr<T>::value, "Schur product expression type detected" ) |
| Constraint on the data type.In case the given data type T is a Schur product expression (i.e. a type derived from the SchurExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_FORM_VALID_SCHUREXPR(T1, T2) |
| Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix addition, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_SERIALEXPR_TYPE(T) static_assert( ::blaze::IsSerialExpr<T>::value, "Non-serial evaluation expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a serial evaluation expression (i.e. a type derived from the SerialExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SERIALEXPR_TYPE(T) static_assert( !::blaze::IsSerialExpr<T>::value, "Serial evaluation expression type detected" ) |
| Constraint on the data type.In case the given data type T is a serial evaluation expression (i.e. a type derived from the SerialExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_SHRINKABLE_TYPE(T) static_assert( ::blaze::IsShrinkable<T>::value, "Non-shrinkable type detected" ) |
| Constraint on the data type.In case the given data type T is not shrinkable, i.e. does not have a 'shrinkToFit' member function that could be used to reduce the capacity, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SHRINKABLE_TYPE(T) static_assert( !::blaze::IsShrinkable<T>::value, "Shrinkable type detected" ) |
| Constraint on the data type.In case the given data type T is shrinkable, i.e. has a 'shrinkToFit' member function that can be used to reduce the capacity, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_SIMD_COMBINABLE_TYPES(T1, T2) static_assert( ::blaze::IsSIMDCombinable<T1,T2>::value, "Non-SIMD combinable types detected" ) |
| Constraint on the data type.In case the given data types T1 and T2 are not SIMD combinable (i.e. do not have a common SIMD interface), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SIMD_COMBINABLE_TYPES(T1, T2) static_assert( !::blaze::IsSIMDCombinable<T1,T2>::value, "SIMD combinable types detected" ) |
| Constraint on the data type.In case the given data types T1 and T2 are SIMD combinable (i.e. do not have a common SIMD interface), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_SIMD_ENABLED(T) static_assert( ::blaze::IsSIMDEnabled<T>::value, "Non-SIMD enabled type detected" ) |
| Constraint on the data type.In case the given data type T is not SIMD-enabled (i.e. does not provide the according SIMD member functions), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SIMD_ENABLED(T) static_assert( !::blaze::IsSIMDEnabled<T>::value, "SIMD enabled type detected" ) |
| Constraint on the data type.In case the given data type T is SIMD-enabled (i.e. does provide the according SIMD member functions), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_SIMD_PACK(T) static_assert( ::blaze::IsSIMDPack<T>::value, "Non-SIMD pack detected" ) |
| Constraint on the data type.In case the given data type T is not a SIMD pack, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SIMD_PACK(T) static_assert( !::blaze::IsSIMDPack<T>::value, "SIMD pack detected" ) |
| Constraint on the data type.In case the given data type T is a SIMD pack, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_HAVE_EQUAL_SIZE(T1, T2) |
| Constraint on the data type.In case the size of the two given vector types T1 and T2 can be evaluated at compile time and in case these sizes are not equal, a compilation error is created. Note that in case the size of either of the two vector types cannot be determined no compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_HAVE_EQUAL_SIZE(T1, T2) |
| Constraint on the data type.In case the size of the two given vector types T1 and T2 can be evaluated at compile time and in case these sizes are equal, a compilation error is created. Note that in case the size of either of the two vector types cannot be determined no compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_SMP_ASSIGNABLE(T) static_assert( ::blaze::IsSMPAssignable<T>::value, "Non-SMP assignable type detected" ) |
| Constraint on the data type.In case the given data type T is not SMP-assignable (i.e. cannot be assigned by multiple threads), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SMP_ASSIGNABLE(T) static_assert( !::blaze::IsSMPAssignable<T>::value, "SMP assignable type detected" ) |
| Constraint on the data type.In case the given data type T is SMP-assignable (can be assigned by multiple threads), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_SPARSE_ELEMENT_TYPE(T) static_assert( ::blaze::IsSparseElement<T>::value, "Non-sparse element type detected" ) |
| Constraint on the data type.In case the given data type T is not a sparse element type (i.e. a type derived from the SparseElement base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SPARSE_ELEMENT_TYPE(T) static_assert( !::blaze::IsSparseElement<T>::value, "Sparse element type detected" ) |
| Constraint on the data type.In case the given data type T is a sparse element type (i.e. a type derived from the SparseElement base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T) static_assert( ::blaze::IsSparseMatrix<T>::value, "Non-sparse matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a sparse, N-dimensional matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SPARSE_MATRIX_TYPE(T) static_assert( !::blaze::IsSparseMatrix<T>::value, "Sparse matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a sparse, N-dimensional matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_SPARSE_VECTOR_TYPE(T) static_assert( ::blaze::IsSparseVector<T>::value, "Non-sparse vector type detected" ) |
| Constraint on the data type.In case the given data type T is not a sparse, N-dimensional vector type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SPARSE_VECTOR_TYPE(T) static_assert( !::blaze::IsSparseVector<T>::value, "Sparse vector type detected" ) |
| Constraint on the data type.In case the given data type T is a sparse, N-dimensional vector type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_SQUARE_MATRIX_TYPE(T) static_assert( ::blaze::IsSquare<T>::value, "Non-square matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a square matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SQUARE_MATRIX_TYPE(T) static_assert( !::blaze::IsSquare<T>::value, "Square matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a square matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_STATIC_TYPE(T) static_assert( ::blaze::IsStatic<T>::value, "Non-static type detected" ) |
| Constraint on the data type.In case the given data type T is not a static data type, i.e. a vector or matrix with dimensions fixed at compile time, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_STATIC_TYPE(T) static_assert( !::blaze::IsStatic<T>::value, "Static type dected" ) |
| Constraint on the data type.In case the given data type T is a static data type, i.e. a vector or matrix with dimensions fixed at compile time, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO) |
| Constraint on the data type.In case the given data type T is not a dense or sparse matrix type and in case the storage order of the given dense or sparse vector type T is not set to SO, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER(T1, T2) |
| Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type and in case the storage order of both matrix types doesn't match, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_DIFFERENT_STORAGE_ORDER(T1, T2) |
| Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type and in case the storage order of both matrix types does match, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_STRICTLY_LOWER_MATRIX_TYPE(T) static_assert( ::blaze::IsStrictlyLower<T>::value, "Non-strictly lower triangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a strictly lower triangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_LOWER_MATRIX_TYPE(T) static_assert( !::blaze::IsStrictlyLower<T>::value, "Strictly lower triangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a strictly lower triangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_STRICTLY_TRIANGULAR_MATRIX_TYPE(T) static_assert( ::blaze::IsStrictlyTriangular<T>::value, "Non-strictly triangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a strictly lower or upper triangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_TRIANGULAR_MATRIX_TYPE(T) static_assert( !::blaze::IsStrictlyTriangular<T>::value, "Strictly triangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a strictly lower or upper triangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_STRICTLY_UPPER_MATRIX_TYPE(T) static_assert( ::blaze::IsStrictlyUpper<T>::value, "Non-strictly upper triangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a strictly upper triangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_UPPER_MATRIX_TYPE(T) static_assert( !::blaze::IsStrictlyUpper<T>::value, "Strictly upper triangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a strictly upper triangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_SUBEXPR_TYPE(T) static_assert( ::blaze::IsSubExpr<T>::value, "Non-subtraction expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a subtraction expression (i.e. a type derived from the SubExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SUBEXPR_TYPE(T) static_assert( !::blaze::IsSubExpr<T>::value, "Subtraction expression type detected" ) |
| Constraint on the data type.In case the given data type T is a subtraction expression (i.e. a type derived from the SubExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_SUBMATRIX_TYPE(T) static_assert( ::blaze::IsSubmatrix<T>::value, "Non-submatrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a submatrix type (i.e. a dense or sparse submatrix), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SUBMATRIX_TYPE(T) static_assert( !::blaze::IsSubmatrix<T>::value, "Submatrix type detected" ) |
| Constraint on the data type.In case the given data type T is a submatrix type (i.e. a dense or sparse submatrix), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_SUBVECTOR_TYPE(T) static_assert( ::blaze::IsSubvector<T>::value, "Non-subvector type detected" ) |
| Constraint on the data type.In case the given data type T is not a subvector type (i.e. a dense or sparse subvector), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SUBVECTOR_TYPE(T) static_assert( !::blaze::IsSubvector<T>::value, "Subvector type detected" ) |
| Constraint on the data type.In case the given data type T is a subvector type (i.e. a dense or sparse subvector), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_SYMMETRIC_MATRIX_TYPE(T) static_assert( ::blaze::IsSymmetric<T>::value, "Non-symmetric matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a symmetric matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T) static_assert( !::blaze::IsSymmetric<T>::value, "Symmetric matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_TRANSEXPR_TYPE(T) static_assert( ::blaze::IsTransExpr<T>::value, "Non-transposition expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a transposition expression (i.e. a type derived from the TransExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_TRANSEXPR_TYPE(T) static_assert( !::blaze::IsTransExpr<T>::value, "Transposition expression type detected" ) |
| Constraint on the data type.In case the given data type T is a transposition expression (i.e. a type derived from the TransExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_TRANSFORMATION_TYPE(T) static_assert( ::blaze::IsTransformation<T>::value, "Non-transformation type detected" ) |
| Constraint on the data type.In case the given data type T is not a transformation expression (i.e. a type derived from the Transformation base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_TRANSFORMATION_TYPE(T) static_assert( !::blaze::IsTransformation<T>::value, "Transformation type detected" ) |
| Constraint on the data type.In case the given data type T is a transformation expression (i.e. a type derived from the Transformation base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_VECTOR_WITH_TRANSPOSE_FLAG(T, TF) |
| Constraint on the data type.In case the given data type T is not a dense or sparse vector type and in case the transpose flag of the given dense or sparse vector type T is not set to TF, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_VECTORS_MUST_HAVE_SAME_TRANSPOSE_FLAG(T1, T2) |
| Constraint on the data type.In case either of the two given data types T1 or T2 is not a vector type and in case the transpose flags of both vector types don't match, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_VECTORS_MUST_HAVE_DIFFERENT_TRANSPOSE_FLAG(T1, T2) |
| Constraint on the data type.In case either of the two given data types T1 or T2 is not a vector type and in case the transpose flags of both vector types does match, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_TRIANGULAR_MATRIX_TYPE(T) static_assert( ::blaze::IsTriangular<T>::value, "Non-triangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a lower or upper triangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_TRIANGULAR_MATRIX_TYPE(T) static_assert( !::blaze::IsTriangular<T>::value, "Triangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a lower or upper triangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_TVECMATMULTEXPR_TYPE(T) static_assert( ::blaze::IsTVecMatMultExpr<T>::value, "Non-vector/matrix multiplication expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a vector/matrix multiplication expression (i.e. a type derived from the TVecMatMultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_TVECMATMULTEXPR_TYPE(T) static_assert( !::blaze::IsTVecMatMultExpr<T>::value, "Vector/matrix multiplication expression type detected" ) |
| Constraint on the data type.In case the given data type T is a vector/matrix multiplication expression (i.e. a type derived from the TVecMatMultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_FORM_VALID_TVECMATMULTEXPR(T1, T2) |
| Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/matrix multiplication, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_UNARYMAPEXPR_TYPE(T) static_assert( ::blaze::IsUnaryMapExpr<T>::value, "Non-unary map expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a unary map expression (i.e. a type derived from the UnaryMapExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_UNARYMAPEXPR_TYPE(T) static_assert( !::blaze::IsUnaryMapExpr<T>::value, "Unary map expression type detected" ) |
| Constraint on the data type.In case the given data type T is a unary map expression (i.e. a type derived from the UnaryMapExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_UNIFORM_TYPE(T) static_assert( ::blaze::IsUniform<T>::value, "Non-uniform type detected" ) |
| Constraint on the data type.In case the given data type T is not a uniform vector or matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_UNIFORM_TYPE(T) static_assert( !::blaze::IsUniform<T>::value, "Uniform type detected" ) |
| Constraint on the data type.In case the given data type T is a uniform vector or matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_UNILOWER_MATRIX_TYPE(T) static_assert( ::blaze::IsUniLower<T>::value, "Non-lower unitriangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a lower unitriangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_UNILOWER_MATRIX_TYPE(T) static_assert( !::blaze::IsUniLower<T>::value, "Lower unitriangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a lower unitriangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_UNITRIANGULAR_MATRIX_TYPE(T) static_assert( ::blaze::IsUniTriangular<T>::value, "Non-unitriangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a lower or upper unitriangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_UNITRIANGULAR_MATRIX_TYPE(T) static_assert( !::blaze::IsUniTriangular<T>::value, "Unitriangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a lower or upper unitriangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_UNIUPPER_MATRIX_TYPE(T) static_assert( ::blaze::IsUniUpper<T>::value, "Non-upper unitriangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a upper unitriangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_UNIUPPER_MATRIX_TYPE(T) static_assert( !::blaze::IsUniUpper<T>::value, "Upper unitriangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a upper unitriangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_UPPER_MATRIX_TYPE(T) static_assert( ::blaze::IsUpper<T>::value, "Non-upper triangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is not a upper triangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_UPPER_MATRIX_TYPE(T) static_assert( !::blaze::IsUpper<T>::value, "Upper triangular matrix type detected" ) |
| Constraint on the data type.In case the given data type T is a upper triangular matrix type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_VECEVALEXPR_TYPE(T) static_assert( ::blaze::IsVecEvalExpr<T>::value, "Non-vector evaluation expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a vector evaluation expression (i.e. a type derived from the VecEvalExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_VECEVALEXPR_TYPE(T) static_assert( !::blaze::IsVecEvalExpr<T>::value, "Vector evaluation expression type detected" ) |
| Constraint on the data type.In case the given data type T is a vector evaluation expression (i.e. a type derived from the VecEvalExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_VECMAPEXPR_TYPE(T) static_assert( ::blaze::IsVecMapExpr<T>::value, "Non-unary vector map expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a unary vector map expression (i.e. a type derived from the VecMapExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_VECMAPEXPR_TYPE(T) static_assert( !::blaze::IsVecMapExpr<T>::value, "Unary vector map expression type detected" ) |
| Constraint on the data type.In case the given data type T is a unary vector map expression (i.e. a type derived from the VecMapExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_VECSCALARDIVEXPR_TYPE(T) static_assert( ::blaze::IsVecScalarDivExpr<T>::value, "Non-vector/scalar division expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a vector/scalar division expression (i.e. a type derived from the VecScalarDivExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_VECSCALARDIVEXPR_TYPE(T) static_assert( !::blaze::IsVecScalarDivExpr<T>::value, "Vector/scalar division expression type detected" ) |
| Constraint on the data type.In case the given data type T is a vector/scalar division expression (i.e. a type derived from the VecScalarDivExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_VECSCALARMULTEXPR_TYPE(T) static_assert( ::blaze::IsVecScalarMultExpr<T>::value, "Non-vector/scalar multiplication expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a vector/scalar multiplication expression (i.e. a type derived from the VecScalarMultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_VECSCALARMULTEXPR_TYPE(T) static_assert( !::blaze::IsVecScalarMultExpr<T>::value, "Vector/scalar multiplication expression type detected" ) |
| Constraint on the data type.In case the given data type T is a vector/scalar multiplication expression (i.e. a type derived from the VecScalarMultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_VECSERIALEXPR_TYPE(T) static_assert( ::blaze::IsVecSerialExpr<T>::value, "Non-vector serial evaluation expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a vector serial evaluation expression (i.e. a type derived from the VecSerialExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_VECSERIALEXPR_TYPE(T) static_assert( !::blaze::IsVecSerialExpr<T>::value, "Vector serial evaluation expression type detected" ) |
| Constraint on the data type.In case the given data type T is a vector serial evaluation expression (i.e. a type derived from the VecSerialExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_VECTOR_TYPE(T) static_assert( ::blaze::IsVector<T>::value, "Non-vector type detected" ) |
| Constraint on the data type.In case the given data type T is not a N-dimensional vector type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_VECTOR_TYPE(T) static_assert( !::blaze::IsVector<T>::value, "Vector type detected" ) |
| Constraint on the data type.In case the given data type T is a N-dimensional vector type, a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_VECTRANSEXPR_TYPE(T) static_assert( ::blaze::IsVecTransExpr<T>::value, "Non-vector transposition expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a vector transposition expression (i.e. a type derived from the VecTransExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_VECTRANSEXPR_TYPE(T) static_assert( !::blaze::IsVecTransExpr<T>::value, "Vector transposition expression type detected" ) |
| Constraint on the data type.In case the given data type T is a vector transposition expression (i.e. a type derived from the VecTransExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_VECTVECMULTEXPR_TYPE(T) static_assert( ::blaze::IsVecTVecMultExpr<T>::value, "Non-outer product expression type detected" ) |
| Constraint on the data type.In case the given data type T is not an outer product expression (i.e. a type derived from the VecTVecMultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_VECTVECMULTEXPR_TYPE(T) static_assert( !::blaze::IsVecTVecMultExpr<T>::value, "Outer product expression type detected" ) |
| Constraint on the data type.In case the given data type T is an outer product expression (i.e. a type derived from the VecTVecMultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_FORM_VALID_VECTVECMULTEXPR(T1, T2) |
| Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector multiplication, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_VECVECADDEXPR_TYPE(T) static_assert( ::blaze::IsVecVecAddExpr<T>::value, "Non-vector/vector addition expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a vector/vector addition expression (i.e. a type derived from the VecVecAddExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECADDEXPR_TYPE(T) static_assert( !::blaze::IsVecVecAddExpr<T>::value, "Vector/vector addition expression type detected" ) |
| Constraint on the data type.In case the given data type T is a vector/vector addition expression (i.e. a type derived from the VecVecAddExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECADDEXPR(T1, T2) |
| Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector addition, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_VECVECDIVEXPR_TYPE(T) static_assert( ::blaze::IsVecVecDivExpr<T>::value, "Non-vector/vector division expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a vector/vector division expression (i.e. a type derived from the VecVecDivExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECDIVEXPR_TYPE(T) static_assert( !::blaze::IsVecVecDivExpr<T>::value, "Vector/vector division expression type detected" ) |
| Constraint on the data type.In case the given data type T is a vector/vector division expression (i.e. a type derived from the VecVecDivExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECDIVEXPR(T1, T2) |
| Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector division, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_VECVECMAPEXPR_TYPE(T) static_assert( ::blaze::IsVecVecMapExpr<T>::value, "Non-binary vector map expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a binary vector map expression (i.e. a type derived from the VecVecMapExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECMAPEXPR_TYPE(T) static_assert( !::blaze::IsVecVecMapExpr<T>::value, "Binary vector map expression type detected" ) |
| Constraint on the data type.In case the given data type T is a binary vector map expression (i.e. a type derived from the VecVecMapExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_VECVECMULTEXPR_TYPE(T) static_assert( ::blaze::IsVecVecMultExpr<T>::value, "Non-vector/vector multiplication expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a vector/vector multiplication expression (i.e. a type derived from the VecVecMultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECMULTEXPR_TYPE(T) static_assert( !::blaze::IsVecVecMultExpr<T>::value, "Vector/vector multiplication expression type detected" ) |
| Constraint on the data type.In case the given data type T is a vector/vector multiplication expression (i.e. a type derived from the VecVecMultExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECMULTEXPR(T1, T2) |
| Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector multiplication, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_VECVECSUBEXPR_TYPE(T) static_assert( ::blaze::IsVecVecSubExpr<T>::value, "Non-vector/vector subtraction expression type detected" ) |
| Constraint on the data type.In case the given data type T is not a vector/vector subtraction expression (i.e. a type derived from the VecVecSubExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECSUBEXPR_TYPE(T) static_assert( !::blaze::IsVecVecSubExpr<T>::value, "Vector/vector subtraction expression type detected" ) |
| Constraint on the data type.In case the given data type T is a vector/vector subtraction expression (i.e. a type derived from the VecVecSubExpr base class), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECSUBEXPR(T1, T2) |
| Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector subtraction, a compilation error is created. More...
|
|
#define | BLAZE_CONSTRAINT_MUST_BE_VIEW_TYPE(T) static_assert( ::blaze::IsView<T>::value, "Non-view type detected" ) |
| Constraint on the data type.In case the given data type T is not a view type (i.e. a subvector, submatrix, row, column, ...), a compilation error is created.
|
|
#define | BLAZE_CONSTRAINT_MUST_NOT_BE_VIEW_TYPE(T) static_assert( !::blaze::IsView<T>::value, "View type detected" ) |
| Constraint on the data type.In case the given data type T is a view type (i.e. a subvector, submatrix, row, column, ...), a compilation error is created.
|
|