Classes | Typedefs
Expression traits

Classes

struct  blaze::AddExprTrait< T1, T2 >
 Evaluation of the return type of an addition expression.Via this type trait it is possible to evaluate the return type of an addition expression between scalars, vectors, and matrices. Given the two types T1 and T2, which must either be scalar, vector, or matrix types, the nested type Type corresponds to the resulting return type. In case the types of T1 or T2 don't fit or if the two types cannot be added, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::AddTrait< T1, T2, typename >
 Base template for the AddTrait class. More...
 
struct  blaze::BinaryMapExprTrait< T1, T2, OP >
 Evaluation of the return type of a binary map expression.Via this type trait it is possible to evaluate the return type of a binary map expression. Given the two types T1 and T2, which must either be vector or matrix types, and the custom operation type OP, the nested type Type corresponds to the resulting return type. In case the types of T1 or T2 don't fit or if no binary map operation exists for the types, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::BinaryMapTrait< T1, T2, OP >
 Base template for the BinaryMapTrait class. More...
 
struct  blaze::ColumnExprTrait< MT >
 Evaluation of the expression type type of a column operation.Via this type trait it is possible to evaluate the return type of a column operation. Given the dense or sparse matrix type MT, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::ColumnTrait< MT >
 Base template for the ColumnTrait class. More...
 
struct  blaze::CrossExprTrait< T1, T2 >
 Evaluation of the return type of a cross product expression.Via this type trait it is possible to evaluate the return type of a cross product expression. Given the two types T1 and T2, which must be dense or sparse column vectors, the nested type Type corresponds to the resulting return type. In case the types of T1 or T2 don't fit or if the two types cannot be used in a cross product, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::CrossTrait< T1, T2 >
 Base template for the CrossTrait class. More...
 
struct  blaze::CTransExprTrait< T >
 Evaluation of the return type of a conjugate transpose expression.Via this type trait it is possible to evaluate the return type of a conjugate transpose expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no conjugate transpose operation exists for the type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::DeclDiagExprTrait< T >
 Evaluation of the return type of a diagonal declaration (decldiag) expression.Via this type trait it is possible to evaluate the return type of a diagonal declaration (decldiag) expression. Given the type T, which must be a matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no decldiag operation exists for the type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::DeclDiagTrait< MT >
 Base template for the DeclDiagTrait class. More...
 
struct  blaze::DeclHermExprTrait< T >
 Evaluation of the return type of an Hermitian declaration (declherm) expression.Via this type trait it is possible to evaluate the return type of an Hermitian declaration (declherm) expression. Given the type T, which must be a matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no declherm operation exists for the type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::DeclHermTrait< MT >
 Base template for the DeclHermTrait class. More...
 
struct  blaze::DeclIdExprTrait< T >
 Evaluation of the return type of an identity declaration (declid) expression.Via this type trait it is possible to evaluate the return type of an identity declaration (declid) expression. Given the type T, which must be a matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no declid operation exists for the type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::DeclIdTrait< MT >
 Base template for the DeclIdTrait class. More...
 
struct  blaze::DeclLowExprTrait< T >
 Evaluation of the return type of a lower declaration (decllow) expression.Via this type trait it is possible to evaluate the return type of a lower declaration (decllow) expression. Given the type T, which must be a matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no decllow operation exists for the type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::DeclLowTrait< MT >
 Base template for the DeclLowTrait class. More...
 
struct  blaze::DeclSymExprTrait< T >
 Evaluation of the return type of a symmetry declaration (declsym) expression.Via this type trait it is possible to evaluate the return type of a symmetry declaration (declsym) expression. Given the type T, which must be a matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no declsym operation exists for the type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::DeclSymTrait< MT >
 Base template for the DeclSymTrait class. More...
 
struct  blaze::DeclUppExprTrait< T >
 Evaluation of the return type of a upper declaration (declupp) expression.Via this type trait it is possible to evaluate the return type of a upper declaration (declupp) expression. Given the type T, which must be a matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no declupp operation exists for the type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::DeclUppTrait< MT >
 Base template for the DeclUppTrait class. More...
 
struct  blaze::DerestrictTrait< T >
 Evaluation of the return type of the derestrict function.Via this type trait it is possible to evaluate the resulting return type of the derestrict function. Given the non-const vector or matrix type T, the nested type Type corresponds to the resulting return type. In case T is neither a dense or sparse vector or matrix type, the resulting Type is set to INVALID_TYPE. More...
 
struct  blaze::DivExprTrait< T1, T2 >
 Evaluation of the resulting expression type of a division.Via this type trait it is possible to evaluate the return type of a division expression between scalars, vectors, and matrices. Given the two types T1 and T2, where T1 must either be a scalar, vector, or matrix type and T2 which must be a scalar type, the nested type Type corresponds to the resulting return type. In case T1 or T2 don't fit or if the two types cannot be divided, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::DivTrait< T1, T2, typename >
 Base template for the DivTrait class. More...
 
struct  blaze::EvalExprTrait< T >
 Evaluation of the return type of an evaluation expression.Via this type trait it is possible to evaluate the return type of an evaluation expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no evaluation operation exists for the type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::ImagTrait< T >
 Base template for the ImagTrait class.The ImagTrait class template offers the possibility to select the resulting data type of a generic imag operation on the given type T. Given the type T, which must either be a scalar, vector, or matrix type, the nested type Type corresponds to the resulting data type of the operation. In case the type of T doesn't fit or if no imag operation exists for the type, the resulting data type Type is set to INVALID_TYPE. Note that const and volatile qualifiers and reference modifiers are generally ignored. More...
 
struct  blaze::InvExprTrait< T >
 Evaluation of the return type of an inversion expression.Via this type trait it is possible to evaluate the return type of an inversion expression. Given the type T, which must either a (complex) floating point type or a dense matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no inversion operation exists for the type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::MultExprTrait< T1, T2 >
 Evaluation of the resulting expression type of a multiplication.Via this type trait it is possible to evaluate the return type of a multiplication expression between scalars, vectors, and matrices. Given the two types T1 and T2, which must be either scalar, vector, or matrix types, the nested type Type corresponds to the resulting return type. In case T1 or T2 don't fit or if the two types cannot be multiplied, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::MultTrait< T1, T2, typename >
 Base template for the MultTrait class. More...
 
struct  blaze::RealTrait< T >
 Base template for the RealTrait class.The RealTrait class template offers the possibility to select the resulting data type of a generic real operation on the given type T. Given the type T, which must either be a scalar, vector, or matrix type, the nested type Type corresponds to the resulting data type of the operation. In case the type of T doesn't fit or if no real operation exists for the type, the resulting data type Type is set to INVALID_TYPE. Note that const and volatile qualifiers and reference modifiers are generally ignored. More...
 
struct  blaze::RowExprTrait< MT >
 Evaluation of the expression type type of a row operation.Via this type trait it is possible to evaluate the return type of a row operation. Given the dense or sparse matrix type MT, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::RowTrait< MT >
 Base template for the RowTrait class. More...
 
struct  blaze::SchurExprTrait< T1, T2 >
 Evaluation of the return type of an Schur product expression.Via this type trait it is possible to evaluate the return type of a Schur product expression between matrices. Given the two types T1 and T2, which must be matrix types, the nested type Type corresponds to the resulting return type. In case the types of T1 or T2 don't fit or if the two types cannot be used in a Schur product, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::SchurTrait< T1, T2 >
 Base template for the SchurTrait class. More...
 
struct  blaze::SerialExprTrait< T >
 Evaluation of the return type of a serial evaluation expression.Via this type trait it is possible to evaluate the return type of a serial evaluation expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no serial evaluation operation exists for the type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::SubExprTrait< T1, T2 >
 Evaluation of the return type of a subtraction expression.Via this type trait it is possible to evaluate the return type of a subtraction expression between scalar, vectors, and matrices. Given the two types T1 and T2, which must be either scalar, vector, or matrix types, the nested type Type corresponds to the resulting return type. In case T1 or T2 don't fit or if the two types cannot be subtracted, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::SubmatrixExprTrait< MT, AF >
 Evaluation of the expression type type of a submatrix operation.Via this type trait it is possible to evaluate the return type of a submatrix operation. Given the dense or sparse matrix type MT and the alignment flag AF, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::SubmatrixTrait< MT >
 Base template for the SubmatrixTrait class. More...
 
struct  blaze::SubTrait< T1, T2, typename >
 Base template for the SubTrait class. More...
 
struct  blaze::SubvectorExprTrait< VT, AF >
 Evaluation of the expression type type of a subvector operation.Via this type trait it is possible to evaluate the return type of a subvector operation. Given the dense or sparse vector type VT and the alignment flag AF, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse vector type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::SubvectorTrait< VT >
 Base template for the SubvectorTrait class. More...
 
struct  blaze::TransExprTrait< T >
 Evaluation of the return type of a transpose expression.Via this type trait it is possible to evaluate the return type of a transpose expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no transpose operation exists for the type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::UnaryMapExprTrait< T, OP >
 Evaluation of the return type of a unary map expression.Via this type trait it is possible to evaluate the return type of a unary map expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no unary map operation exists for the type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  blaze::UnaryMapTrait< T, OP >
 Base template for the UnaryMapTrait class. More...
 
struct  blaze::HighType< T1, T2 >
 Base template for the HighType type trait. More...
 
struct  blaze::LowType< T1, T2 >
 Base template for the LowType type trait. More...
 

Typedefs

template<typename T1 , typename T2 >
using blaze::AddExprTrait_ = typename AddExprTrait< T1, T2 >::Type
 Auxiliary alias declaration for the AddExprTrait class template.The AddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the AddExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using blaze::AddTrait_ = typename AddTrait< T1, T2 >::Type
 Auxiliary alias declaration for the AddTrait class template.The AddTrait_ alias declaration provides a convenient shortcut to access the nested Type of the AddTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T1 , typename T2 , typename OP >
using blaze::BinaryMapExprTrait_ = typename BinaryMapExprTrait< T1, T2, OP >::Type
 Auxiliary alias declaration for the BinaryMapExprTrait class template.The BinaryMapExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the BinaryMapExprTrait class template. For instance, given the data types T1 and and T2 and the custom operation type OP the following two type definitions are identical: More...
 
template<typename T1 , typename T2 , typename OP >
using blaze::BinaryMapTrait_ = typename BinaryMapTrait< T1, T2, OP >::Type
 Auxiliary alias declaration for the BinaryMapTrait class template.The BinaryMapTrait_ alias declaration provides a convenient shortcut to access the nested Type of the BinaryMapTrait class template. For instance, given the types T1 and T2 and the custom operation type OP the following two type definitions are identical: More...
 
template<typename MT >
using blaze::ColumnExprTrait_ = typename ColumnExprTrait< MT >::Type
 Auxiliary alias declaration for the ColumnExprTrait type trait.The ColumnExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the ColumnExprTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More...
 
template<typename MT >
using blaze::ColumnTrait_ = typename ColumnTrait< MT >::Type
 Auxiliary alias declaration for the ColumnTrait type trait.The ColumnTrait_ alias declaration provides a convenient shortcut to access the nested Type of the ColumnTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using blaze::CrossExprTrait_ = typename CrossExprTrait< T1, T2 >::Type
 Auxiliary alias declaration for the CrossExprTrait class template.The CrossExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the CrossExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using blaze::CrossTrait_ = typename CrossTrait< T1, T2 >::Type
 Auxiliary alias declaration for the CrossTrait class template.The CrossTrait_ alias declaration provides a convenient shortcut to access the nested Type of the CrossTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T >
using blaze::CTransExprTrait_ = typename CTransExprTrait< T >::Type
 Auxiliary alias declaration for the CTransExprTrait class template.The CTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the CTransExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::DeclDiagExprTrait_ = typename DeclDiagExprTrait< T >::Type
 Auxiliary alias declaration for the DeclDiagExprTrait class template.The DeclDiagExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclDiagExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename MT >
using blaze::DeclDiagTrait_ = typename DeclDiagTrait< MT >::Type
 Auxiliary alias declaration for the DeclDiagTrait type trait.The DeclDiagTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclDiagTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More...
 
template<typename T >
using blaze::DeclHermExprTrait_ = typename DeclHermExprTrait< T >::Type
 Auxiliary alias declaration for the DeclHermExprTrait class template.The DeclHermExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclHermExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename MT >
using blaze::DeclHermTrait_ = typename DeclHermTrait< MT >::Type
 Auxiliary alias declaration for the DeclHermTrait type trait.The DeclHermTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclHermTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More...
 
template<typename T >
using blaze::DeclIdExprTrait_ = typename DeclIdExprTrait< T >::Type
 Auxiliary alias declaration for the DeclIdExprTrait class template.The DeclIdExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclIdExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename MT >
using blaze::DeclIdTrait_ = typename DeclIdTrait< MT >::Type
 Auxiliary alias declaration for the DeclIdTrait type trait.The DeclIdTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclIdTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More...
 
template<typename T >
using blaze::DeclLowExprTrait_ = typename DeclLowExprTrait< T >::Type
 Auxiliary alias declaration for the DeclLowExprTrait class template.The DeclLowExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclLowExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename MT >
using blaze::DeclLowTrait_ = typename DeclLowTrait< MT >::Type
 Auxiliary alias declaration for the DeclLowTrait type trait.The DeclLowTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclLowTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More...
 
template<typename T >
using blaze::DeclSymExprTrait_ = typename DeclSymExprTrait< T >::Type
 Auxiliary alias declaration for the DeclSymExprTrait class template.The DeclSymExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclSymExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename MT >
using blaze::DeclSymTrait_ = typename DeclSymTrait< MT >::Type
 Auxiliary alias declaration for the DeclSymTrait type trait.The DeclSymTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclSymTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More...
 
template<typename T >
using blaze::DeclUppExprTrait_ = typename DeclUppExprTrait< T >::Type
 Auxiliary alias declaration for the DeclUppExprTrait class template.The DeclUppExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclUppExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename MT >
using blaze::DeclUppTrait_ = typename DeclUppTrait< MT >::Type
 Auxiliary alias declaration for the DeclUppTrait type trait.The DeclUppTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclUppTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More...
 
template<typename T >
using blaze::DerestrictTrait_ = typename DerestrictTrait< T >::Type
 Auxiliary alias declaration for the DerestrictTrait type trait.The DerestrictTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DerestrictTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using blaze::DivExprTrait_ = typename DivExprTrait< T1, T2 >::Type
 Auxiliary alias declaration for the DivExprTrait class template.The DivExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DivExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using blaze::DivTrait_ = typename DivTrait< T1, T2 >::Type
 Auxiliary alias declaration for the DivTrait class template.The DivTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DivTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T >
using blaze::EvalExprTrait_ = typename EvalExprTrait< T >::Type
 Auxiliary alias declaration for the EvalExprTrait class template.The EvalExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the EvalExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::ImagTrait_ = typename ImagTrait< T >::Type
 Auxiliary alias declaration for the ImagTrait class template.The ImagTrait_ alias declaration provides a convenient shortcut to access the nested Type of the ImagTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::InvExprTrait_ = typename InvExprTrait< T >::Type
 Auxiliary alias declaration for the InvExprTrait class template.The InvExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the InvExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using blaze::MultExprTrait_ = typename MultExprTrait< T1, T2 >::Type
 Auxiliary alias declaration for the MultExprTrait class template.The MultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the MultExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using blaze::MultTrait_ = typename MultTrait< T1, T2 >::Type
 Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provides a convenient shortcut to access the nested Type of the MultTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T >
using blaze::RealTrait_ = typename RealTrait< T >::Type
 Auxiliary alias declaration for the RealTrait class template.The RealTrait_ alias declaration provides a convenient shortcut to access the nested Type of the RealTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename MT >
using blaze::RowExprTrait_ = typename RowExprTrait< MT >::Type
 Auxiliary alias declaration for the RowExprTrait type trait.The RowExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the RowExprTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More...
 
template<typename MT >
using blaze::RowTrait_ = typename RowTrait< MT >::Type
 Auxiliary alias declaration for the RowTrait type trait.The RowTrait_ alias declaration provides a convenient shortcut to access the nested Type of the RowTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using blaze::SchurExprTrait_ = typename SchurExprTrait< T1, T2 >::Type
 Auxiliary alias declaration for the SchurExprTrait class template.The SchurExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SchurExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using blaze::SchurTrait_ = typename SchurTrait< T1, T2 >::Type
 Auxiliary alias declaration for the SchurTrait class template.The SchurTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SchurTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T >
using blaze::SerialExprTrait_ = typename SerialExprTrait< T >::Type
 Auxiliary alias declaration for the SerialExprTrait class template.The SerialExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SerialExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using blaze::SubExprTrait_ = typename SubExprTrait< T1, T2 >::Type
 Auxiliary alias declaration for the SubExprTrait class template.The SubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SubExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename MT , bool AF>
using blaze::SubmatrixExprTrait_ = typename SubmatrixExprTrait< MT, AF >::Type
 Auxiliary alias declaration for the SubmatrixExprTrait type trait.The SubmatrixExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SubmatrixExprTrait class template. For instance, given the matrix type MT and the alignment flag AF the following two type definitions are identical: More...
 
template<typename MT >
using blaze::SubmatrixTrait_ = typename SubmatrixTrait< MT >::Type
 Auxiliary alias declaration for the SubmatrixTrait type trait.The SubmatrixTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SubmatrixTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using blaze::SubTrait_ = typename SubTrait< T1, T2 >::Type
 Auxiliary alias declaration for the SubTrait class template.The SubTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SubTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename VT , bool AF>
using blaze::SubvectorExprTrait_ = typename SubvectorExprTrait< VT, AF >::Type
 Auxiliary alias declaration for the SubvectorExprTrait type trait.The SubvectorExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SubvectorExprTrait class template. For instance, given the vector type VT the following two type definitions are identical: More...
 
template<typename VT >
using blaze::SubvectorTrait_ = typename SubvectorTrait< VT >::Type
 Auxiliary alias declaration for the SubvectorTrait type trait.The SubvectorTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SubvectorTrait class template. For instance, given the vector type VT the following two type definitions are identical: More...
 
template<typename T >
using blaze::TransExprTrait_ = typename TransExprTrait< T >::Type
 Auxiliary alias declaration for the TransExprTrait class template.The TransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TransExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T , typename OP >
using blaze::UnaryMapExprTrait_ = typename UnaryMapExprTrait< T, OP >::Type
 Auxiliary alias declaration for the UnaryMapExprTrait class template.The UnaryMapExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the UnaryMapExprTrait class template. For instance, given the data type T and custom operation type OP the following two type definitions are identical: More...
 
template<typename T , typename OP >
using blaze::UnaryMapTrait_ = typename UnaryMapTrait< T, OP >::Type
 Auxiliary alias declaration for the UnaryMapTrait class template.The UnaryMapTrait_ alias declaration provides a convenient shortcut to access the nested Type of the UnaryMapTrait class template. For instance, given the type T and the custom operation type OP the following two type definitions are identical: More...
 

Detailed Description

Typedef Documentation

◆ AddExprTrait_

template<typename T1 , typename T2 >
using blaze::AddExprTrait_ = typedef typename AddExprTrait<T1,T2>::Type

Auxiliary alias declaration for the AddExprTrait class template.The AddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the AddExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename AddExprTrait<T1,T2>::Type;
using Type2 = AddExprTrait_<T1,T2>;

◆ AddTrait_

template<typename T1 , typename T2 >
using blaze::AddTrait_ = typedef typename AddTrait<T1,T2>::Type

Auxiliary alias declaration for the AddTrait class template.The AddTrait_ alias declaration provides a convenient shortcut to access the nested Type of the AddTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename AddTrait<T1,T2>::Type;
using Type2 = AddTrait_<T1,T2>;

◆ BinaryMapExprTrait_

template<typename T1 , typename T2 , typename OP >
using blaze::BinaryMapExprTrait_ = typedef typename BinaryMapExprTrait<T1,T2,OP>::Type

Auxiliary alias declaration for the BinaryMapExprTrait class template.The BinaryMapExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the BinaryMapExprTrait class template. For instance, given the data types T1 and and T2 and the custom operation type OP the following two type definitions are identical:

using Type1 = typename BinaryMapExprTrait<T1,T2,OP>::Type;
using Type2 = BinaryMapExprTrait_<T1,T2,OP>;

◆ BinaryMapTrait_

template<typename T1 , typename T2 , typename OP >
using blaze::BinaryMapTrait_ = typedef typename BinaryMapTrait<T1,T2,OP>::Type

Auxiliary alias declaration for the BinaryMapTrait class template.The BinaryMapTrait_ alias declaration provides a convenient shortcut to access the nested Type of the BinaryMapTrait class template. For instance, given the types T1 and T2 and the custom operation type OP the following two type definitions are identical:

using Type1 = typename BinaryMapTrait<T1,T2,OP>::Type;
using Type2 = BinaryMapTrait_<T1,T2,OP>;

◆ ColumnExprTrait_

template<typename MT >
using blaze::ColumnExprTrait_ = typedef typename ColumnExprTrait<MT>::Type

Auxiliary alias declaration for the ColumnExprTrait type trait.The ColumnExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the ColumnExprTrait class template. For instance, given the matrix type MT the following two type definitions are identical:

using Type1 = typename ColumnExprTrait<MT>::Type;
using Type2 = ColumnExprTrait_<MT>;

◆ ColumnTrait_

template<typename MT >
using blaze::ColumnTrait_ = typedef typename ColumnTrait<MT>::Type

Auxiliary alias declaration for the ColumnTrait type trait.The ColumnTrait_ alias declaration provides a convenient shortcut to access the nested Type of the ColumnTrait class template. For instance, given the matrix type MT the following two type definitions are identical:

using Type1 = typename ColumnTrait<MT>::Type;
using Type2 = ColumnTrait_<MT>;

◆ CrossExprTrait_

template<typename T1 , typename T2 >
using blaze::CrossExprTrait_ = typedef typename CrossExprTrait<T1,T2>::Type

Auxiliary alias declaration for the CrossExprTrait class template.The CrossExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the CrossExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename CrossExprTrait<T1,T2>::Type;
using Type2 = CrossExprTrait_<T1,T2>;

◆ CrossTrait_

template<typename T1 , typename T2 >
using blaze::CrossTrait_ = typedef typename CrossTrait<T1,T2>::Type

Auxiliary alias declaration for the CrossTrait class template.The CrossTrait_ alias declaration provides a convenient shortcut to access the nested Type of the CrossTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename CrossTrait<T1,T2>::Type;
using Type2 = CrossTrait_<T1,T2>;

◆ CTransExprTrait_

template<typename T >
using blaze::CTransExprTrait_ = typedef typename CTransExprTrait<T>::Type

Auxiliary alias declaration for the CTransExprTrait class template.The CTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the CTransExprTrait class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename CTransExprTrait<T>::Type;
using Type2 = CTransExprTrait_<T>;

◆ DeclDiagExprTrait_

template<typename T >
using blaze::DeclDiagExprTrait_ = typedef typename DeclDiagExprTrait<T>::Type

Auxiliary alias declaration for the DeclDiagExprTrait class template.The DeclDiagExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclDiagExprTrait class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename DeclDiagExprTrait<T>::Type;
using Type2 = DeclDiagExprTrait_<T>;

◆ DeclDiagTrait_

template<typename MT >
using blaze::DeclDiagTrait_ = typedef typename DeclDiagTrait<MT>::Type

Auxiliary alias declaration for the DeclDiagTrait type trait.The DeclDiagTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclDiagTrait class template. For instance, given the matrix type MT the following two type definitions are identical:

using Type1 = typename DeclDiagTrait<MT>::Type;
using Type2 = DeclDiagTrait_<MT>;

◆ DeclHermExprTrait_

template<typename T >
using blaze::DeclHermExprTrait_ = typedef typename DeclHermExprTrait<T>::Type

Auxiliary alias declaration for the DeclHermExprTrait class template.The DeclHermExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclHermExprTrait class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename DeclHermExprTrait<T>::Type;
using Type2 = DeclHermExprTrait_<T>;

◆ DeclHermTrait_

template<typename MT >
using blaze::DeclHermTrait_ = typedef typename DeclHermTrait<MT>::Type

Auxiliary alias declaration for the DeclHermTrait type trait.The DeclHermTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclHermTrait class template. For instance, given the matrix type MT the following two type definitions are identical:

using Type1 = typename DeclHermTrait<MT>::Type;
using Type2 = DeclHermTrait_<MT>;

◆ DeclIdExprTrait_

template<typename T >
using blaze::DeclIdExprTrait_ = typedef typename DeclIdExprTrait<T>::Type

Auxiliary alias declaration for the DeclIdExprTrait class template.The DeclIdExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclIdExprTrait class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename DeclIdExprTrait<T>::Type;
using Type2 = DeclIdExprTrait_<T>;

◆ DeclIdTrait_

template<typename MT >
using blaze::DeclIdTrait_ = typedef typename DeclIdTrait<MT>::Type

Auxiliary alias declaration for the DeclIdTrait type trait.The DeclIdTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclIdTrait class template. For instance, given the matrix type MT the following two type definitions are identical:

using Type1 = typename DeclIdTrait<MT>::Type;
using Type2 = DeclIdTrait_<MT>;

◆ DeclLowExprTrait_

template<typename T >
using blaze::DeclLowExprTrait_ = typedef typename DeclLowExprTrait<T>::Type

Auxiliary alias declaration for the DeclLowExprTrait class template.The DeclLowExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclLowExprTrait class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename DeclLowExprTrait<T>::Type;
using Type2 = DeclLowExprTrait_<T>;

◆ DeclLowTrait_

template<typename MT >
using blaze::DeclLowTrait_ = typedef typename DeclLowTrait<MT>::Type

Auxiliary alias declaration for the DeclLowTrait type trait.The DeclLowTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclLowTrait class template. For instance, given the matrix type MT the following two type definitions are identical:

using Type1 = typename DeclLowTrait<MT>::Type;
using Type2 = DeclLowTrait_<MT>;

◆ DeclSymExprTrait_

template<typename T >
using blaze::DeclSymExprTrait_ = typedef typename DeclSymExprTrait<T>::Type

Auxiliary alias declaration for the DeclSymExprTrait class template.The DeclSymExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclSymExprTrait class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename DeclSymExprTrait<T>::Type;
using Type2 = DeclSymExprTrait_<T>;

◆ DeclSymTrait_

template<typename MT >
using blaze::DeclSymTrait_ = typedef typename DeclSymTrait<MT>::Type

Auxiliary alias declaration for the DeclSymTrait type trait.The DeclSymTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclSymTrait class template. For instance, given the matrix type MT the following two type definitions are identical:

using Type1 = typename DeclSymTrait<MT>::Type;
using Type2 = DeclSymTrait_<MT>;

◆ DeclUppExprTrait_

template<typename T >
using blaze::DeclUppExprTrait_ = typedef typename DeclUppExprTrait<T>::Type

Auxiliary alias declaration for the DeclUppExprTrait class template.The DeclUppExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclUppExprTrait class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename DeclUppExprTrait<T>::Type;
using Type2 = DeclUppExprTrait_<T>;

◆ DeclUppTrait_

template<typename MT >
using blaze::DeclUppTrait_ = typedef typename DeclUppTrait<MT>::Type

Auxiliary alias declaration for the DeclUppTrait type trait.The DeclUppTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DeclUppTrait class template. For instance, given the matrix type MT the following two type definitions are identical:

using Type1 = typename DeclUppTrait<MT>::Type;
using Type2 = DeclUppTrait_<MT>;

◆ DerestrictTrait_

template<typename T >
using blaze::DerestrictTrait_ = typedef typename DerestrictTrait<T>::Type

Auxiliary alias declaration for the DerestrictTrait type trait.The DerestrictTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DerestrictTrait class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename DerestrictTrait<T>::Type;
using Type2 = DerestrictTrait_<T>;

◆ DivExprTrait_

template<typename T1 , typename T2 >
using blaze::DivExprTrait_ = typedef typename DivExprTrait<T1,T2>::Type

Auxiliary alias declaration for the DivExprTrait class template.The DivExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DivExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename DivExprTrait<T1,T2>::Type;
using Type2 = DivExprTrait_<T1,T2>;

◆ DivTrait_

template<typename T1 , typename T2 >
using blaze::DivTrait_ = typedef typename DivTrait<T1,T2>::Type

Auxiliary alias declaration for the DivTrait class template.The DivTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DivTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename DivTrait<T1,T2>::Type;
using Type2 = DivTrait_<T1,T2>;

◆ EvalExprTrait_

template<typename T >
using blaze::EvalExprTrait_ = typedef typename EvalExprTrait<T>::Type

Auxiliary alias declaration for the EvalExprTrait class template.The EvalExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the EvalExprTrait class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename EvalExprTrait<T>::Type;
using Type2 = EvalExprTrait_<T>;

◆ ImagTrait_

template<typename T >
using blaze::ImagTrait_ = typedef typename ImagTrait<T>::Type

Auxiliary alias declaration for the ImagTrait class template.The ImagTrait_ alias declaration provides a convenient shortcut to access the nested Type of the ImagTrait class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename ImagTrait<T>::Type;
using Type2 = ImagTrait_<T>;

◆ InvExprTrait_

template<typename T >
using blaze::InvExprTrait_ = typedef typename InvExprTrait<T>::Type

Auxiliary alias declaration for the InvExprTrait class template.The InvExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the InvExprTrait class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename InvExprTrait<T>::Type;
using Type2 = InvExprTrait_<T>;

◆ MultExprTrait_

template<typename T1 , typename T2 >
using blaze::MultExprTrait_ = typedef typename MultExprTrait<T1,T2>::Type

Auxiliary alias declaration for the MultExprTrait class template.The MultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the MultExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename MultExprTrait<T1,T2>::Type;
using Type2 = MultExprTrait_<T1,T2>;

◆ MultTrait_

template<typename T1 , typename T2 >
using blaze::MultTrait_ = typedef typename MultTrait<T1,T2>::Type

Auxiliary alias declaration for the MultTrait class template.The MultTrait_ alias declaration provides a convenient shortcut to access the nested Type of the MultTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename MultTrait<T1,T2>::Type;
using Type2 = MultTrait_<T1,T2>;

◆ RealTrait_

template<typename T >
using blaze::RealTrait_ = typedef typename RealTrait<T>::Type

Auxiliary alias declaration for the RealTrait class template.The RealTrait_ alias declaration provides a convenient shortcut to access the nested Type of the RealTrait class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename RealTrait<T>::Type;
using Type2 = RealTrait_<T>;

◆ RowExprTrait_

template<typename MT >
using blaze::RowExprTrait_ = typedef typename RowExprTrait<MT>::Type

Auxiliary alias declaration for the RowExprTrait type trait.The RowExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the RowExprTrait class template. For instance, given the matrix type MT the following two type definitions are identical:

using Type1 = typename RowExprTrait<MT>::Type;
using Type2 = RowExprTrait_<MT>;

◆ RowTrait_

template<typename MT >
using blaze::RowTrait_ = typedef typename RowTrait<MT>::Type

Auxiliary alias declaration for the RowTrait type trait.The RowTrait_ alias declaration provides a convenient shortcut to access the nested Type of the RowTrait class template. For instance, given the matrix type MT the following two type definitions are identical:

using Type1 = typename RowTrait<MT>::Type;
using Type2 = RowTrait_<MT>;

◆ SchurExprTrait_

template<typename T1 , typename T2 >
using blaze::SchurExprTrait_ = typedef typename SchurExprTrait<T1,T2>::Type

Auxiliary alias declaration for the SchurExprTrait class template.The SchurExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SchurExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename SchurExprTrait<T1,T2>::Type;
using Type2 = SchurExprTrait_<T1,T2>;

◆ SchurTrait_

template<typename T1 , typename T2 >
using blaze::SchurTrait_ = typedef typename SchurTrait<T1,T2>::Type

Auxiliary alias declaration for the SchurTrait class template.The SchurTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SchurTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename SchurTrait<T1,T2>::Type;
using Type2 = SchurTrait_<T1,T2>;

◆ SerialExprTrait_

template<typename T >
using blaze::SerialExprTrait_ = typedef typename SerialExprTrait<T>::Type

Auxiliary alias declaration for the SerialExprTrait class template.The SerialExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SerialExprTrait class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename SerialExprTrait<T>::Type;
using Type2 = SerialExprTrait_<T>;

◆ SubExprTrait_

template<typename T1 , typename T2 >
using blaze::SubExprTrait_ = typedef typename SubExprTrait<T1,T2>::Type

Auxiliary alias declaration for the SubExprTrait class template.The SubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SubExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename SubExprTrait<T1,T2>::Type;
using Type2 = SubExprTrait_<T1,T2>;

◆ SubmatrixExprTrait_

template<typename MT , bool AF>
using blaze::SubmatrixExprTrait_ = typedef typename SubmatrixExprTrait<MT,AF>::Type

Auxiliary alias declaration for the SubmatrixExprTrait type trait.The SubmatrixExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SubmatrixExprTrait class template. For instance, given the matrix type MT and the alignment flag AF the following two type definitions are identical:

using Type1 = typename SubmatrixExprTrait<MT,AF>::Type;
using Type2 = SubmatrixExprTrait_<MT,AF>;

◆ SubmatrixTrait_

template<typename MT >
using blaze::SubmatrixTrait_ = typedef typename SubmatrixTrait<MT>::Type

Auxiliary alias declaration for the SubmatrixTrait type trait.The SubmatrixTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SubmatrixTrait class template. For instance, given the matrix type MT the following two type definitions are identical:

using Type1 = typename SubmatrixTrait<MT>::Type;
using Type2 = SubmatrixTrait_<MT>;

◆ SubTrait_

template<typename T1 , typename T2 >
using blaze::SubTrait_ = typedef typename SubTrait<T1,T2>::Type

Auxiliary alias declaration for the SubTrait class template.The SubTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SubTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename SubTrait<T1,T2>::Type;
using Type2 = SubTrait_<T1,T2>;

◆ SubvectorExprTrait_

template<typename VT , bool AF>
using blaze::SubvectorExprTrait_ = typedef typename SubvectorExprTrait<VT,AF>::Type

Auxiliary alias declaration for the SubvectorExprTrait type trait.The SubvectorExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SubvectorExprTrait class template. For instance, given the vector type VT the following two type definitions are identical:

using Type1 = typename SubvectorExprTrait<VT,AF>::Type;
using Type2 = SubvectorExprTrait_<VT,AF>;

◆ SubvectorTrait_

template<typename VT >
using blaze::SubvectorTrait_ = typedef typename SubvectorTrait<VT>::Type

Auxiliary alias declaration for the SubvectorTrait type trait.The SubvectorTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SubvectorTrait class template. For instance, given the vector type VT the following two type definitions are identical:

using Type1 = typename SubvectorTrait<VT>::Type;
using Type2 = SubvectorTrait_<VT>;

◆ TransExprTrait_

template<typename T >
using blaze::TransExprTrait_ = typedef typename TransExprTrait<T>::Type

Auxiliary alias declaration for the TransExprTrait class template.The TransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TransExprTrait class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename TransExprTrait<T>::Type;
using Type2 = TransExprTrait_<T>;

◆ UnaryMapExprTrait_

template<typename T , typename OP >
using blaze::UnaryMapExprTrait_ = typedef typename UnaryMapExprTrait<T,OP>::Type

Auxiliary alias declaration for the UnaryMapExprTrait class template.The UnaryMapExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the UnaryMapExprTrait class template. For instance, given the data type T and custom operation type OP the following two type definitions are identical:

using Type1 = typename UnaryMapExprTrait<T,OP>::Type;
using Type2 = UnaryMapExprTrait_<T,OP>;

◆ UnaryMapTrait_

template<typename T , typename OP >
using blaze::UnaryMapTrait_ = typedef typename UnaryMapTrait<T,OP>::Type

Auxiliary alias declaration for the UnaryMapTrait class template.The UnaryMapTrait_ alias declaration provides a convenient shortcut to access the nested Type of the UnaryMapTrait class template. For instance, given the type T and the custom operation type OP the following two type definitions are identical:

using Type1 = typename UnaryMapTrait<T,OP>::Type;
using Type2 = UnaryMapTrait_<T,OP>;