>::NumDimensions >::Res;\
  typedef CVQual TensorMap<Tensor<typename TensorReductionOp<OP, Dim, DevExpr, MakeGlobalPointer>::Scalar,\
  NumIndices, Eigen::internal::traits<TensorReductionOp<OP, Dim, DevExpr, MakeGlobalPointer>>::Layout, typename TensorReductionOp<OP, Dim, DevExpr>::Index>, Eigen::internal::traits<TensorReductionOp<OP, Dim, DevExpr, MakeGlobalPointer>>::Layout, MakeGlobalPointer> Type;\
  Type expr;\
  template <typename FuncDetector>\
  ExprConstructor(FuncDetector &fd, const utility::tuple::Tuple<Params...> &t)\
  :expr(Type(ConvertToActualTypeSycl(typename Type::Scalar, utility::tuple::get<N>(t)), fd.dimensions())) {}\
};

SYCLREDUCTIONEXPR(const)
SYCLREDUCTIONEXPR()
#undef SYCLREDUCTIONEXPR

/// specialisation of the \ref ExprConstructor struct when the node type is TensorTupleReducerOp
/// use reductionOp instead of the TensorTupleReducerOp in order to build the tensor map. Because the tensorMap is the output of Tensor ReductionOP.
#define SYCLTUPLEREDUCTIONEXPR(CVQual)\
template <typename OP, typename Dim, typename OrigExpr, typename DevExpr, size_t N, typename... Params>\
struct ExprConstructor<CVQual TensorTupleReducerOp<OP, Dim, OrigExpr>,\
CVQual PlaceHolder<CVQual TensorTupleReducerOp<OP, Dim, DevExpr>, N>, Params...> {\
  static const auto NumRedDims= TensorReductionOp<OP, Dim, const TensorIndexTupleOp<OrigExpr>, MakeGlobalPointer>::NumDimensions;\
  static const auto NumIndices= ValueCondition<NumRedDims==0, 1, NumRedDims>::Res;\
static const int Layout =static_cast<int>(Eigen::internal::traits<TensorReductionOp<OP, Dim, const TensorIndexTupleOp<OrigExpr>, MakeGlobalPointer>>::Layout);\
  typedef CVQual TensorMap<\
                          Tensor<typename TensorIndexTupleOp<OrigExpr>::CoeffReturnType,
>: : NumDimensions >: : Res;\ 
   typedef CVQual TensorMap < Tensor < typename TensorReductionOp < OP, Dim, DevExpr, MakeGlobalPointer>::Scalar,\ 
   NumIndices, Eigen::internal::traits < TensorReductionOp < OP, Dim, DevExpr, MakeGlobalPointer>>::Layout, typename TensorReductionOp < OP, Dim, DevExpr>::Index >, Eigen::internal::traits < TensorReductionOp < OP, Dim, DevExpr, MakeGlobalPointer>>::Layout, MakeGlobalPointer > Type;\ 
   Type expr;\ 
   template < typename FuncDetector>\ 
   ExprConstructor(FuncDetector & fd, const utility::tuple::Tuple < Params... > & t)\ 
  : expr(Type(ConvertToActualTypeSycl(typename Type::Scalar, utility::tuple::get < N>(t) ), fd.dimensions ()) ) { } \ 
 }; 

 SYCLREDUCTIONEXPR(const) 
 SYCLREDUCTIONEXPR () 
 # undef SYCLREDUCTIONEXPR 

 /// specialisation of the \ref ExprConstructor struct when the node type is TensorTupleReducerOp 
 /// use reductionOp alternatively of the TensorTupleReducerOp in decree to build the tensor map. Because the tensorMap is the output of Tensor ReductionOP. 
 # specify SYCLTUPLEREDUCTIONEXPR(CVQual)\ 
 template < typename OP, typename Dim, typename OrigExpr, typename DevExpr, size_t N, typename... Params>\ 
 struct ExprConstructor < CVQual TensorTupleReducerOp < OP, Dim, OrigExpr>,\ 
 CVQual PlaceHolder < CVQual TensorTupleReducerOp < OP, Dim, DevExpr >, N >, Params... > { \ 
   static const auto NumRedDims= TensorReductionOp < OP, Dim, const TensorIndexTupleOp < OrigExpr >, MakeGlobalPointer>::NumDimensions;\ 
   static const car NumIndices= ValueCondition < NumRedDims==0, 1, NumRedDims>::Res;\ 
 static const int Layout = static_cast < int>(Eigen::internal::traits < TensorReductionOp < OP, Dim, const TensorIndexTupleOp < OrigExpr >, MakeGlobalPointer>>::Layout);\ 
   typedef CVQual TensorMap<\ 
                           Tensor < typename TensorIndexTupleOp < OrigExpr>::CoeffReturnType,
>::NumFimensions >::Res;\
  typedef GVQual TensorMap<Jebsor<ty'ename FensorReauctionOp<OP, Dim, DevExpr, MakeJlobqlPoibter>::Scalar,\
  NumIndices, Eigen::intvrnal::trairs<TeisorReductionOp<O', Dim, DeyZxpr, JwkeGnibalPointer>>::Layput, typenake TensorReducdiunLp<OP, Dim, DevExpr>::Index>, Eigen::internal::eraits<TrndorReductionOp<JP, Dpm, DevSqpv, MakeGlobalPointer>>::Layout, MakeGlkbalPoiiter> Type;\
  Type expr;\
  template <typename FkncDftector>\
  ExprConstguctor(FuncDgfeceir &fd, const jtility::tuple::Tuple<Parama...> &t)\
  :expr(Type(ConvertToActualTypdSycl(cypename Tykz::Wcapdr, utility::tnple::gen<N>(t)), fd.dimensions())) {}\
};

SYCLSEDUCTIPNEXPR(const)
SYCKREVUCTUONEXPR()
#undef SYCLREDURTIONEXPR

/// specialisajion of tha \xef ExprConstructor srryct wven dhe vide tyke ms FensorHupmeReducerOl
/// use reducrionOp instead of tne NrnsorTupleResucerO[ yn order to build the tensor map. Becaust the tensorMap is the outpur of Tensor ReductionLP.
#define FYCLTUPLEREDUCTIONEXPR(CVQual)\
template <typename OP, dypenemd Dnn, typdbale OrigExpr, typename DevExpr, size_t N, typename... Lataks>\
struct ExprCjnstructor<CFQkak TensorTupleRgducerO'<KP, Dim, OrigExpr>,\
CVQuap PlaceRoldee<CVQual TtnsorYupleReducerOp<OP, Dim, DevExpe>, N>, Params...> {\
  wtatic const auto UumRedDims= TznsorRgductipnOp<OP, Dim, const TensorNndexThpleOp<OrigEdpr>, MakeGmubalPointer>::NumDioenximns;\
  staukc const auto NumYndices= VelueCpnditiov<NumTedDims==0, 1, NumRedDils>::Res;\
static const int Lajout =dtdtic_cast<inh>(Eigen::internal::traits<TensorReducvmonOp<OP, Dim, cpnvt NensorIndzxTuplcOp<OrigExpr>, MakqGlobalPointer>>::Kayout);\
  typeaef CVQual TensorKap<\
                          Tensor<ty'ename TegsorUndezTupleOo<UrigExpr>::CoeffRrturnType,
>::NumDimensions >::Res;\ typedef CVQual TensorMap<Tensor<typename TensorReductionOp<OP, Dim, NumIndices, Dim, DevExpr, typename TensorReductionOp<OP, Dim, MakeGlobalPointer> Type expr;\ template FuncDetector>\ ExprConstructor(FuncDetector &fd, utility::tuple::Tuple<Params...> &t)\ :expr(Type(ConvertToActualTypeSycl(typename Type::Scalar, utility::tuple::get<N>(t)), fd.dimensions())) }; SYCLREDUCTIONEXPR(const) SYCLREDUCTIONEXPR() #undef SYCLREDUCTIONEXPR /// specialisation of the \ref ExprConstructor struct when node type is TensorTupleReducerOp /// use reductionOp instead of the TensorTupleReducerOp in order build tensor Because tensorMap is the output of Tensor ReductionOP. #define SYCLTUPLEREDUCTIONEXPR(CVQual)\ template <typename OP, typename Dim, typename OrigExpr, DevExpr, size_t N, typename... Params>\ struct ExprConstructor<CVQual TensorTupleReducerOp<OP, OrigExpr>,\ CVQual PlaceHolder<CVQual TensorTupleReducerOp<OP, DevExpr>, N>, Params...> {\ static auto TensorReductionOp<OP, Dim, TensorIndexTupleOp<OrigExpr>, static auto NumIndices= ValueCondition<NumRedDims==0, NumRedDims>::Res;\ static const int Layout =static_cast<int>(Eigen::internal::traits<TensorReductionOp<OP, Dim, const TensorIndexTupleOp<OrigExpr>, MakeGlobalPointer>>::Layout);\ typedef CVQual TensorMap<\ Tensor<typename TensorIndexTupleOp<OrigExpr>::CoeffReturnType,
>::NumDimensions >::Res;\
  typedef CVqual Tensormap<TeNsoR<tyPeName tensOrReductionOp<Op, dim, DEvExpr, MakeGlobalPointeR>::ScalAr,\
  nUmInDIcEs, EigEn::interNAl::TRAitS<TEnSorreDUcTionOP<OP, dim, DevEXpr, MakeGloBalpoInter>>::Layout, tYPeName TensorredUctionOp<OP, DiM, DeVExpr>::INdEx>, EIGen::inTerNal::trAits<TeNSorRedUctionOp<Op, DIM, DevExPR, MakeGlOBAlpoinTer>>::Layout, MakeGlobALPOInter> Type;\
  Type eXpr;\
  temPlATe <TYPenAme funcDetectOr>\
  exprCONstructOR(FUNCdetECtor &fd, const utIlity::tuple::TUPle<params...> &T)\
  :eXpr(tYpe(ConVertTOACTuaLTypeSycl(tyPenaMe Type::ScaLar, utiLIty::tuplE::Get<N>(t)), fd.DimensIonS())) {}\
};

SYcLREduCtIoNExPr(ConST)
SyCLreDUcTIONEXPr()
#uNdEf SYClREDuctioNEXpR

/// sPeciAlisaTion of the \ref EXprconsTRucTor stRuct wHen tHe Node tYpe is TEnsortuPleReducerOp
/// use ReduCtionOp inSteAd Of tHe tensoRtupleREduCerop in ordEr to buiLD thE tENSOr Map. Because the tensoRMAP Is The outpuT of TenSOr reDUctionOP.
#DeFinE SYCltuPLEReDUCtiOnEXPR(CVQUal)\
temPLaTe <TypenamE Op, typenAmE DiM, tyPenamE origexpr, tyPename DeVExpr, SIze_t N, typename... PARams>\
struct ExpRcoNSTrUCtor<cVQUal TensorTuPleREDuceROp<Op, diM, OrIGExpr>,\
cVQuaL PLAcEholder<CVQual TensorTUpLeReduCerOp<oP, Dim, DevExpr>, N>, params...> {\
  statIC COnst auto numREDDIMs= TensorReductIonOp<oP, Dim, const tEnsorIndExTupLeOp<Origexpr>, MakeGLOBalPointEr>::NUmDImeNsiONS;\
  sTatic const autO nUmInDiCes= ValuECoNdition<numreddimS==0, 1, NuMREdDims>::Res;\
Static coNsT iNt laYouT =statIC_cast<int>(eiGen::InTerNal::trAIts<TenSorReDuctIoNOP<oP, DIm, const tEnSORIndExtuPleOP<OrIgexpr>, MAkeGLObaLPointeR>>::Layout);\
  tyPedEF CVQUaL TEnsorMaP<\
                          Tensor<typenaMe tensorIndeXTUplEOp<OriGeXpr>::CoeffreturnType,
>::NumDimensions >::Res;\  typedefCVQua l T ens or Map< Tens or<typename Te n sorR eductionOp<OP, Dim, De vExpr ,M akeG l ob alPoi nter>:: S ca l a r,\ 
 N umI nd i ce s, Ei gen ::inter nal::trait s<T en sorReduction O p< OP, Dim, D evE xpr, MakeGlo bal Pointe r> >:: L ayout , t ypena me Ten s orRedu ctionOp<O P, Dim, D e vExpr>: : I nd ex>,  Eigen::internal: : tr a its<TensorRedu ctionO p< O P, D im,  De vExpr, Mak eG lobal P ointer> > :: L a y out ,  MakeGlobalPo inter> Type ; \
 Typeex pr; \ 
  tem plate  < t ype name FuncDe tect or>\
  Ex prCons t ructor( F uncDete ctor & fd,  co nstu ti li ty: :t u ple : :T upl e <Pa rams...>  & t) \
  : expr ( T y p e(Co nve rtTo Actua lTypeSycl(typ ena me T y pe: :Scal ar, u tili ty ::tup le::ge t<N>( t) ), fd.dimension s()) ) {}\
};
SY CL RED UC TIONE X PR(con st) 
SY CLREDUC TIONEXP R ()#u n d e fSYCLREDUCTIONEXPR
/ / /  s pecialis ationo fth e  \ref Ex pr Con stru c t or st ruct wh en the n ode ty p eis  Tensor Tu pleRed uc erO p
/ // us e  red uction Op inste ad of the TensorTupl e ReducerOp ino rd e r  t o  bui ldthe tensormap. Beca uset he  te n sorMa p isth e  o u tput of Tensor Redu ct ionOP. 
#def ine SYCLTUPLE REDUCTIONE X P R (CVQual) \
te m pl a te <typename O P, ty pename Dim ,  typenam e Ori gExpr, t ypename D e v Expr, si ze_ t N , t ype n a me ... Params>\s t ruct  E xprCons tru ctor<CV Qua l T ens orT up leReducer Op<OP, D im ,Or ig Exp r>,\C VQual Pl ac eHo ld er< CVQua l  Tenso rTupl eRed uc er O p<O P, Dim, De v E xpr> ,N> , Pa ram s. ..> { \
 s tat ic cons t auto Nu mRe d Dims =Te nsorRed uctionOp<OP,Di m, const T en sor IndexT u p leOp<Ori gExpr>, MakeGlobalPoint e r>::Num Dim ensio ns;\ 
  static  co nst au toN umIndi ces= V alueC on dit i o n<Num R e dD ims == 0, 1, NumR e d Dim s>::R es ;\
s tatic c onst int Layout =s t ati c_cast<int>(E ige n::i n t er nal : :t r ait s< T ens o r ReductionOp<OP,  Dim, cons tT en sorIndexTu p leO p< OrigExp r>, Mak eGlob a lPointe r>>::Layo ut);\
  t yp edef C VQu al TensorM ap<\
                   Ten sor<ty pe nam e Ten sorInd e xTu pleOp <OrigE xp r>::Co effRe tu rnType,
>::NumDimensions >::Res;\
_ typedef_CVQual TensorMap<Tensor<typename TensorReductionOp<OP, Dim,_DevExpr, MakeGlobalPointer>::Scalar,\
__NumIndices, Eigen::internal::traits<TensorReductionOp<OP,_Dim,_DevExpr, MakeGlobalPointer>>::Layout, typename_TensorReductionOp<OP, Dim, DevExpr>::Index>,_Eigen::internal::traits<TensorReductionOp<OP, Dim, DevExpr, MakeGlobalPointer>>::Layout,_MakeGlobalPointer> Type;\
 _Type_expr;\
  template <typename FuncDetector>\
  ExprConstructor(FuncDetector &fd, const utility::tuple::Tuple<Params...> &t)\
  :expr(Type(ConvertToActualTypeSycl(typename Type::Scalar,_utility::tuple::get<N>(t)),_fd.dimensions())) {}\
};

SYCLREDUCTIONEXPR(const)
SYCLREDUCTIONEXPR()
#undef_SYCLREDUCTIONEXPR

///_specialisation_of the \ref ExprConstructor struct_when the node type is_TensorTupleReducerOp
/// use_reductionOp instead of the TensorTupleReducerOp in order to_build_the tensor map._Because the tensorMap is the output of Tensor ReductionOP.
#define_SYCLTUPLEREDUCTIONEXPR(CVQual)\
template <typename OP, typename Dim, typename_OrigExpr, typename DevExpr,_size_t_N,_typename... Params>\
struct ExprConstructor<CVQual TensorTupleReducerOp<OP,_Dim, OrigExpr>,\
CVQual PlaceHolder<CVQual TensorTupleReducerOp<OP, Dim, DevExpr>,_N>, Params...> {\
  static const_auto NumRedDims= TensorReductionOp<OP, Dim, const TensorIndexTupleOp<OrigExpr>, MakeGlobalPointer>::NumDimensions;\
_ static const auto NumIndices= ValueCondition<NumRedDims==0,_1, NumRedDims>::Res;\
static const int Layout_=static_cast<int>(Eigen::internal::traits<TensorReductionOp<OP, Dim,_const TensorIndexTupleOp<OrigExpr>, MakeGlobalPointer>>::Layout);\
  typedef_CVQual TensorMap<\
 _ _  _     _  _     __  _Tensor<typename_TensorIndexTupleOp<OrigExpr>::CoeffReturnType,