182 lines
6.5 KiB
C++
182 lines
6.5 KiB
C++
// This file is part of Eigen, a lightweight C++ template library
|
|
// for linear algebra.
|
|
//
|
|
// Mehdi Goli Codeplay Software Ltd.
|
|
// Ralph Potter Codeplay Software Ltd.
|
|
// Luke Iwanski Codeplay Software Ltd.
|
|
// Contact: <eigen@codeplay.com>
|
|
//
|
|
// This Source Code Form is subject to the terms of the Mozilla
|
|
// Public License v. 2.0. If a copy of the MPL was not distributed
|
|
// with this file, You can obtain one at the mozilla.org home page
|
|
|
|
/*****************************************************************
|
|
* TensorSyclPlaceHolderExpr.h
|
|
*
|
|
* \brief:
|
|
* This is the specialisation of the placeholder expression based on the
|
|
* operation type
|
|
*
|
|
*****************************************************************/
|
|
|
|
#ifndef UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSORSYCL_PLACEHOLDER_EXPR_HPP
|
|
#define UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSORSYCL_PLACEHOLDER_EXPR_HPP
|
|
|
|
namespace Eigen {
|
|
namespace TensorSycl {
|
|
namespace internal {
|
|
|
|
/// \struct PlaceHolder
|
|
/// \brief PlaceHolder is used to replace the \ref TensorMap in the expression
|
|
/// tree.
|
|
/// PlaceHolder contains the order of the leaf node in the expression tree.
|
|
template <typename Scalar, size_t N>
|
|
struct PlaceHolder {
|
|
static constexpr size_t I = N;
|
|
typedef Scalar Type;
|
|
};
|
|
|
|
/// \sttruct PlaceHolderExpression
|
|
/// \brief it is used to create the PlaceHolder expression. The PlaceHolder
|
|
/// expression is a copy of expression type in which the TensorMap of the has
|
|
/// been replaced with PlaceHolder.
|
|
template <typename Expr, size_t N>
|
|
struct PlaceHolderExpression;
|
|
|
|
template<size_t N, typename... Args>
|
|
struct CalculateIndex;
|
|
|
|
template<size_t N, typename Arg>
|
|
struct CalculateIndex<N, Arg>{
|
|
typedef typename PlaceHolderExpression<Arg, N>::Type ArgType;
|
|
typedef utility::tuple::Tuple<ArgType> ArgsTuple;
|
|
};
|
|
|
|
template<size_t N, typename Arg1, typename Arg2>
|
|
struct CalculateIndex<N, Arg1, Arg2>{
|
|
static const size_t Arg2LeafCount = LeafCount<Arg2>::Count;
|
|
typedef typename PlaceHolderExpression<Arg1, N - Arg2LeafCount>::Type Arg1Type;
|
|
typedef typename PlaceHolderExpression<Arg2, N>::Type Arg2Type;
|
|
typedef utility::tuple::Tuple<Arg1Type, Arg2Type> ArgsTuple;
|
|
};
|
|
|
|
template<size_t N, typename Arg1, typename Arg2, typename Arg3>
|
|
struct CalculateIndex<N, Arg1, Arg2, Arg3> {
|
|
static const size_t Arg3LeafCount = LeafCount<Arg3>::Count;
|
|
static const size_t Arg2LeafCount = LeafCount<Arg2>::Count;
|
|
typedef typename PlaceHolderExpression<Arg1, N - Arg3LeafCount - Arg2LeafCount>::Type Arg1Type;
|
|
typedef typename PlaceHolderExpression<Arg2, N - Arg3LeafCount>::Type Arg2Type;
|
|
typedef typename PlaceHolderExpression<Arg3, N>::Type Arg3Type;
|
|
typedef utility::tuple::Tuple<Arg1Type, Arg2Type, Arg3Type> ArgsTuple;
|
|
};
|
|
|
|
template<template<class...> class Category , class OP, class TPL>
|
|
struct CategoryHelper;
|
|
|
|
template<template<class...> class Category , class OP, class ...T >
|
|
struct CategoryHelper<Category, OP, utility::tuple::Tuple<T...> > {
|
|
typedef Category<OP, T... > Type;
|
|
};
|
|
|
|
template<template<class...> class Category , class ...T >
|
|
struct CategoryHelper<Category, NoOP, utility::tuple::Tuple<T...> > {
|
|
typedef Category<T... > Type;
|
|
};
|
|
|
|
/// specialisation of the \ref PlaceHolderExpression when the node is
|
|
/// TensorCwiseNullaryOp, TensorCwiseUnaryOp, TensorBroadcastingOp, TensorCwiseBinaryOp, TensorCwiseTernaryOp
|
|
#define OPEXPRCATEGORY(CVQual)\
|
|
template <template <class, class... > class Category, typename OP, typename... SubExpr, size_t N>\
|
|
struct PlaceHolderExpression<CVQual Category<OP, SubExpr...>, N>{\
|
|
typedef CVQual typename CategoryHelper<Category, OP, typename CalculateIndex<N, SubExpr...>::ArgsTuple>::Type Type;\
|
|
};
|
|
|
|
OPEXPRCATEGORY(const)
|
|
OPEXPRCATEGORY()
|
|
#undef OPEXPRCATEGORY
|
|
|
|
/// specialisation of the \ref PlaceHolderExpression when the node is
|
|
/// TensorCwiseSelectOp
|
|
#define SELECTEXPR(CVQual)\
|
|
template <typename IfExpr, typename ThenExpr, typename ElseExpr, size_t N>\
|
|
struct PlaceHolderExpression<CVQual TensorSelectOp<IfExpr, ThenExpr, ElseExpr>, N> {\
|
|
typedef CVQual typename CategoryHelper<TensorSelectOp, NoOP, typename CalculateIndex<N, IfExpr, ThenExpr, ElseExpr>::ArgsTuple>::Type Type;\
|
|
};
|
|
|
|
SELECTEXPR(const)
|
|
SELECTEXPR()
|
|
#undef SELECTEXPR
|
|
|
|
/// specialisation of the \ref PlaceHolderExpression when the node is
|
|
/// TensorAssignOp
|
|
#define ASSIGNEXPR(CVQual)\
|
|
template <typename LHSExpr, typename RHSExpr, size_t N>\
|
|
struct PlaceHolderExpression<CVQual TensorAssignOp<LHSExpr, RHSExpr>, N> {\
|
|
typedef CVQual typename CategoryHelper<TensorAssignOp, NoOP, typename CalculateIndex<N, LHSExpr, RHSExpr>::ArgsTuple>::Type Type;\
|
|
};
|
|
|
|
ASSIGNEXPR(const)
|
|
ASSIGNEXPR()
|
|
#undef ASSIGNEXPR
|
|
|
|
/// specialisation of the \ref PlaceHolderExpression when the node is
|
|
/// TensorMap
|
|
#define TENSORMAPEXPR(CVQual)\
|
|
template <typename Scalar_, int Options_, int Options2_, int NumIndices_, typename IndexType_, template <class> class MakePointer_, size_t N>\
|
|
struct PlaceHolderExpression< CVQual TensorMap< Tensor<Scalar_, NumIndices_, Options_, IndexType_>, Options2_, MakePointer_>, N> {\
|
|
typedef CVQual PlaceHolder<CVQual TensorMap<Tensor<Scalar_, NumIndices_, Options_, IndexType_>, Options2_, MakePointer_>, N> Type;\
|
|
};
|
|
|
|
TENSORMAPEXPR(const)
|
|
TENSORMAPEXPR()
|
|
#undef TENSORMAPEXPR
|
|
|
|
/// specialisation of the \ref PlaceHolderExpression when the node is
|
|
/// TensorForcedEvalOp
|
|
#define FORCEDEVAL(CVQual)\
|
|
template <typename Expr, size_t N>\
|
|
struct PlaceHolderExpression<CVQual TensorForcedEvalOp<Expr>, N> {\
|
|
typedef CVQual PlaceHolder<CVQual TensorForcedEvalOp<Expr>, N> Type;\
|
|
};
|
|
|
|
FORCEDEVAL(const)
|
|
FORCEDEVAL()
|
|
#undef FORCEDEVAL
|
|
|
|
/// specialisation of the \ref PlaceHolderExpression when the node is
|
|
/// TensorEvalToOp
|
|
#define EVALTO(CVQual)\
|
|
template <typename Expr, size_t N>\
|
|
struct PlaceHolderExpression<CVQual TensorEvalToOp<Expr>, N> {\
|
|
typedef CVQual TensorEvalToOp<typename CalculateIndex <N, Expr>::ArgType> Type;\
|
|
};
|
|
|
|
EVALTO(const)
|
|
EVALTO()
|
|
#undef EVALTO
|
|
|
|
|
|
/// specialisation of the \ref PlaceHolderExpression when the node is
|
|
/// TensorReductionOp
|
|
#define SYCLREDUCTION(CVQual)\
|
|
template <typename OP, typename Dims, typename Expr, size_t N>\
|
|
struct PlaceHolderExpression<CVQual TensorReductionOp<OP, Dims, Expr>, N>{\
|
|
typedef CVQual PlaceHolder<CVQual TensorReductionOp<OP, Dims,Expr>, N> Type;\
|
|
};
|
|
SYCLREDUCTION(const)
|
|
SYCLREDUCTION()
|
|
#undef SYCLREDUCTION
|
|
|
|
/// template deduction for \ref PlaceHolderExpression struct
|
|
template <typename Expr>
|
|
struct createPlaceHolderExpression {
|
|
static const size_t TotalLeaves = LeafCount<Expr>::Count;
|
|
typedef typename PlaceHolderExpression<Expr, TotalLeaves - 1>::Type Type;
|
|
};
|
|
|
|
} // internal
|
|
} // TensorSycl
|
|
} // namespace Eigen
|
|
|
|
#endif // UNSUPPORTED_EIGEN_CXX11_SRC_TENSOR_TENSORSYCL_PLACEHOLDER_EXPR_HPP
|