Classes | Namespaces | Macros | Functions
TensorSyclExprConstructor.h File Reference

Go to the source code of this file.

Classes

struct  Eigen::TensorSycl::internal::EvalToLHSConstructor< PtrType, N, Params >
 
struct  Eigen::TensorSycl::internal::ExprConstructor< OrigExpr, IndexExpr, Params >
 
struct  Eigen::TensorSycl::internal::ValueCondition< Conds, X, Y >
 
struct  Eigen::TensorSycl::internal::ValueCondition< false, X, Y >
 

Namespaces

 Eigen
 
 Eigen::TensorSycl
 
 Eigen::TensorSycl::internal
 

Macros

#define ASSIGN(CVQual)
 
#define BINARYCATEGORY(CVQual)
 
#define EVALTO(CVQual)
 
#define FORCEDEVAL(CVQual)
 
#define SELECTOP(CVQual)
 
#define SYCLREDUCTIONEXPR(CVQual)
 specialisation of the ExprConstructor struct when the node type is TensorReductionOp More...
 
#define TENSORMAP(CVQual)
 
#define TERNARYCATEGORY(CVQual)
 
#define UNARYCATEGORY(CVQual)
 

Functions

template<typename OrigExpr , typename IndexExpr , typename FuncD , typename... Params>
auto Eigen::TensorSycl::internal::createDeviceExpression (FuncD &funcD, const utility::tuple::Tuple< Params... > &t) -> decltype(ExprConstructor< OrigExpr, IndexExpr, Params... >(funcD, t))
 template deduction for ExprConstructor struct More...
 

Macro Definition Documentation

◆ ASSIGN

#define ASSIGN (   CVQual)
Value:
template <typename OrigLHSExpr, typename OrigRHSExpr, typename LHSExpr, typename RHSExpr, typename... Params>\
struct ExprConstructor<CVQual TensorAssignOp<OrigLHSExpr, OrigRHSExpr>, CVQual TensorAssignOp<LHSExpr, RHSExpr>, Params...> {\
typedef ExprConstructor<OrigLHSExpr, LHSExpr, Params...> my_left_type;\
typedef ExprConstructor<OrigRHSExpr, RHSExpr, Params...> my_right_type;\
typedef CVQual TensorAssignOp<typename my_left_type::Type, typename my_right_type::Type> Type;\
my_left_type lhsExpr;\
my_right_type rhsExpr;\
Type expr;\
template <typename FuncDetector>\
ExprConstructor(FuncDetector &funcD, const utility::tuple::Tuple<Params...> &t)\
: lhsExpr(funcD.lhsExpr, t), rhsExpr(funcD.rhsExpr, t), expr(lhsExpr.expr, rhsExpr.expr) {}\
};
utility::tuple::Tuple
is a fixed-size collection of heterogeneous values
Definition: TensorSyclTuple.h:40

specialisation of the ExprConstructor struct when the node type is const TensorAssignOp

Definition at line 147 of file TensorSyclExprConstructor.h.

◆ BINARYCATEGORY

#define BINARYCATEGORY (   CVQual)
Value:
template <template<class, class, class> class BinaryCategory, typename OP, typename OrigLHSExpr, typename OrigRHSExpr, typename LHSExpr,\
typename RHSExpr, typename... Params>\
struct ExprConstructor<CVQual BinaryCategory<OP, OrigLHSExpr, OrigRHSExpr>, CVQual BinaryCategory<OP, LHSExpr, RHSExpr>, Params...> {\
typedef ExprConstructor<OrigLHSExpr, LHSExpr, Params...> my_left_type;\
typedef ExprConstructor<OrigRHSExpr, RHSExpr, Params...> my_right_type;\
typedef CVQual BinaryCategory<OP, typename my_left_type::Type, typename my_right_type::Type> Type;\
my_left_type lhsExpr;\
my_right_type rhsExpr;\
Type expr;\
template <typename FuncDetector>\
ExprConstructor(FuncDetector &funcD, const utility::tuple::Tuple<Params...> &t)\
: lhsExpr(funcD.lhsExpr, t),rhsExpr(funcD.rhsExpr, t), expr(lhsExpr.expr, rhsExpr.expr, funcD.func) {}\
};
OP
#define OP(X)
Definition: common.h:39
utility::tuple::Tuple
is a fixed-size collection of heterogeneous values
Definition: TensorSyclTuple.h:40

specialisation of the ExprConstructor struct when the node type is TensorBinaryOp

Definition at line 81 of file TensorSyclExprConstructor.h.

◆ EVALTO

#define EVALTO (   CVQual)
Value:
template <typename OrigExpr, typename Expr, typename... Params>\
struct ExprConstructor<CVQual TensorEvalToOp<OrigExpr, MakeGlobalPointer>, CVQual TensorEvalToOp<Expr>, Params...> {\
typedef ExprConstructor<OrigExpr, Expr, Params...> my_expr_type;\
typedef typename TensorEvalToOp<OrigExpr, MakeGlobalPointer>::PointerType my_buffer_type;\
typedef CVQual TensorEvalToOp<typename my_expr_type::Type, MakeGlobalPointer> Type;\
my_expr_type nestedExpression;\
EvalToLHSConstructor<my_buffer_type, 0, Params...> buffer;\
Type expr;\
template <typename FuncDetector>\
ExprConstructor(FuncDetector &funcD, const utility::tuple::Tuple<Params...> &t)\
: nestedExpression(funcD.rhsExpr, t), buffer(t), expr(buffer.expr, nestedExpression.expr) {}\
};
utility::tuple::Tuple
is a fixed-size collection of heterogeneous values
Definition: TensorSyclTuple.h:40

specialisation of the ExprConstructor struct when the node type is TensorEvalToOp

Definition at line 166 of file TensorSyclExprConstructor.h.

◆ FORCEDEVAL

#define FORCEDEVAL (   CVQual)
Value:
template <typename OrigExpr, typename DevExpr, size_t N, typename... Params>\
struct ExprConstructor<CVQual TensorForcedEvalOp<OrigExpr, MakeGlobalPointer>,\
CVQual PlaceHolder<CVQual TensorForcedEvalOp<DevExpr>, N>, Params...> {\
typedef CVQual TensorMap<Tensor<typename TensorForcedEvalOp<DevExpr, MakeGlobalPointer>::Scalar,\
TensorForcedEvalOp<DevExpr, MakeGlobalPointer>::NumDimensions, 0, typename TensorForcedEvalOp<DevExpr>::Index>, 0, MakeGlobalPointer> Type;\
Type expr;\
template <typename FuncDetector>\
ExprConstructor(FuncDetector &fd, const utility::tuple::Tuple<Params...> &t)\
: expr(Type((&(*(utility::tuple::get<N>(t).get_pointer()))), fd.dimensions())) {}\
};
utility::tuple::Tuple
is a fixed-size collection of heterogeneous values
Definition: TensorSyclTuple.h:40
Eigen::Index
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
Scalar
SCALAR Scalar
Definition: common.h:84
N
static const int N
Definition: TensorIntDiv.h:84

specialisation of the ExprConstructor struct when the node type is TensorForcedEvalOp

Definition at line 186 of file TensorSyclExprConstructor.h.

◆ SELECTOP

#define SELECTOP (   CVQual)
Value:
template <typename OrigIfExpr, typename OrigThenExpr, typename OrigElseExpr, typename IfExpr, typename ThenExpr, typename ElseExpr, typename... Params>\
struct ExprConstructor< CVQual TensorSelectOp<OrigIfExpr, OrigThenExpr, OrigElseExpr>, CVQual TensorSelectOp<IfExpr, ThenExpr, ElseExpr>, Params...> {\
typedef ExprConstructor<OrigIfExpr, IfExpr, Params...> my_if_type;\
typedef ExprConstructor<OrigThenExpr, ThenExpr, Params...> my_then_type;\
typedef ExprConstructor<OrigElseExpr, ElseExpr, Params...> my_else_type;\
typedef CVQual TensorSelectOp<typename my_if_type::Type, typename my_then_type::Type, typename my_else_type::Type> Type;\
my_if_type ifExpr;\
my_then_type thenExpr;\
my_else_type elseExpr;\
Type expr;\
template <typename FuncDetector>\
ExprConstructor(FuncDetector &funcD, const utility::tuple::Tuple<Params...> &t)\
: ifExpr(funcD.ifExpr, t), thenExpr(funcD.thenExpr, t), elseExpr(funcD.elseExpr, t), expr(ifExpr.expr, thenExpr.expr, elseExpr.expr) {}\
};
utility::tuple::Tuple
is a fixed-size collection of heterogeneous values
Definition: TensorSyclTuple.h:40

specialisation of the ExprConstructor struct when the node type is TensorCwiseSelectOp

Definition at line 125 of file TensorSyclExprConstructor.h.

◆ SYCLREDUCTIONEXPR

#define SYCLREDUCTIONEXPR (   CVQual)
Value:
template <typename OP, typename Dim, typename OrigExpr, typename DevExpr, size_t N, typename... Params>\
struct ExprConstructor<CVQual TensorReductionOp<OP, Dim, OrigExpr, MakeGlobalPointer>,\
CVQual PlaceHolder<CVQual TensorReductionOp<OP, Dim, DevExpr>, N>, Params...> {\
static const size_t NumIndices= ValueCondition< TensorReductionOp<OP, Dim, DevExpr, MakeGlobalPointer>::NumDimensions==0, 1, TensorReductionOp<OP, Dim, DevExpr, MakeGlobalPointer>::NumDimensions >::Res;\
typedef CVQual TensorMap<Tensor<typename TensorReductionOp<OP, Dim, DevExpr, MakeGlobalPointer>::Scalar,\
NumIndices, 0, typename TensorReductionOp<OP, Dim, DevExpr>::Index>, 0, MakeGlobalPointer> Type;\
Type expr;\
template <typename FuncDetector>\
ExprConstructor(FuncDetector &fd, const utility::tuple::Tuple<Params...> &t)\
: expr(Type((&(*(utility::tuple::get<N>(t).get_pointer()))), fd.dimensions())) {}\
};
OP
#define OP(X)
Definition: common.h:39
utility::tuple::Tuple
is a fixed-size collection of heterogeneous values
Definition: TensorSyclTuple.h:40
Eigen::Index
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:33
Scalar
SCALAR Scalar
Definition: common.h:84
N
static const int N
Definition: TensorIntDiv.h:84

specialisation of the ExprConstructor struct when the node type is TensorReductionOp

Definition at line 210 of file TensorSyclExprConstructor.h.

◆ TENSORMAP

#define TENSORMAP (   CVQual)
Value:
template <typename Scalar_, int Options_, int Options2_, int Options3_, int NumIndices_, typename IndexType_,\
template <class> class MakePointer_, size_t N, typename... Params>\
struct ExprConstructor< CVQual TensorMap<Tensor<Scalar_, NumIndices_, Options_, IndexType_>, Options2_, MakeGlobalPointer>,\
CVQual PlaceHolder<CVQual TensorMap<Tensor<Scalar_, NumIndices_, Options_, IndexType_>, Options3_, MakePointer_>, N>, Params...>{\
typedef CVQual TensorMap<Tensor<Scalar_, NumIndices_, Options_, IndexType_>, Options2_, MakeGlobalPointer> Type;\
Type expr;\
template <typename FuncDetector>\
ExprConstructor(FuncDetector &fd, const utility::tuple::Tuple<Params...> &t)\
: expr(Type((&(*(utility::tuple::get<N>(t).get_pointer()))), fd.dimensions())) {}\
};
utility::tuple::Tuple
is a fixed-size collection of heterogeneous values
Definition: TensorSyclTuple.h:40
N
static const int N
Definition: TensorIntDiv.h:84

specialisation of the ExprConstructor struct when the node type is TensorMap

Definition at line 47 of file TensorSyclExprConstructor.h.

◆ TERNARYCATEGORY

#define TERNARYCATEGORY (   CVQual)
Value:
template <template <class, class, class, class> class TernaryCategory, typename OP, typename OrigArg1Expr, typename OrigArg2Expr,typename OrigArg3Expr,\
typename Arg1Expr, typename Arg2Expr, typename Arg3Expr, typename... Params>\
struct ExprConstructor<CVQual TernaryCategory<OP, OrigArg1Expr, OrigArg2Expr, OrigArg3Expr>, CVQual TernaryCategory<OP, Arg1Expr, Arg2Expr, Arg3Expr>, Params...> {\
typedef ExprConstructor<OrigArg1Expr, Arg1Expr, Params...> my_arg1_type;\
typedef ExprConstructor<OrigArg2Expr, Arg2Expr, Params...> my_arg2_type;\
typedef ExprConstructor<OrigArg3Expr, Arg3Expr, Params...> my_arg3_type;\
typedef CVQual TernaryCategory<OP, typename my_arg1_type::Type, typename my_arg2_type::Type, typename my_arg3_type::Type> Type;\
my_arg1_type arg1Expr;\
my_arg2_type arg2Expr;\
my_arg3_type arg3Expr;\
Type expr;\
template <typename FuncDetector>\
ExprConstructor(FuncDetector &funcD,const utility::tuple::Tuple<Params...> &t)\
: arg1Expr(funcD.arg1Expr, t), arg2Expr(funcD.arg2Expr, t), arg3Expr(funcD.arg3Expr, t), expr(arg1Expr.expr, arg2Expr.expr, arg3Expr.expr, funcD.func) {}\
};
OP
#define OP(X)
Definition: common.h:39
utility::tuple::Tuple
is a fixed-size collection of heterogeneous values
Definition: TensorSyclTuple.h:40

specialisation of the ExprConstructor struct when the node type is TensorCwiseTernaryOp

Definition at line 102 of file TensorSyclExprConstructor.h.

◆ UNARYCATEGORY

#define UNARYCATEGORY (   CVQual)
Value:
template <template<class, class> class UnaryCategory, typename OP, typename OrigRHSExpr, typename RHSExpr, typename... Params>\
struct ExprConstructor<CVQual UnaryCategory<OP, OrigRHSExpr>, CVQual UnaryCategory<OP, RHSExpr>, Params...> {\
typedef ExprConstructor<OrigRHSExpr, RHSExpr, Params...> my_type;\
my_type rhsExpr;\
typedef CVQual UnaryCategory<OP, typename my_type::Type> Type;\
Type expr;\
template <typename FuncDetector>\
ExprConstructor(FuncDetector &funcD, const utility::tuple::Tuple<Params...> &t)\
: rhsExpr(funcD.rhsExpr, t), expr(rhsExpr.expr, funcD.func) {}\
};
OP
#define OP(X)
Definition: common.h:39
utility::tuple::Tuple
is a fixed-size collection of heterogeneous values
Definition: TensorSyclTuple.h:40

Definition at line 63 of file TensorSyclExprConstructor.h.


control_box_rst
Author(s): Christoph Rösmann
autogenerated on Mon Feb 28 2022 22:08:01