#include "main.h"
#include <unsupported/Eigen/CXX11/Tensor>

Include dependency graph for cxx11_tensor_builtins_sycl.cpp:

Classes
struct	EqualAssignement

struct	PlusEqualAssignement

Namespaces
	cl

	cl::sycl

Macros
#define	DECLARE_BINARY_STRUCT(FUNC)

#define	DECLARE_BINARY_STRUCT_OP(NAME, OPERATOR)

#define	DECLARE_UNARY_STRUCT(FUNC)

#define	EIGEN_DEFAULT_DENSE_INDEX_TYPE int64_t

#define	EIGEN_TEST_NO_COMPLEX

#define	EIGEN_TEST_NO_LONGDOUBLE

#define	EIGEN_USE_SYCL

#define	RUN_UNARY_TEST(FUNC)

Functions
template<typename T >
T	cl::sycl::abs (T x)

template<typename T >
T	cl::sycl::cube (T x)

template<typename T >
T	cl::sycl::cwiseMax (T x, T y)

template<typename T >
T	cl::sycl::cwiseMin (T x, T y)

	EIGEN_DECLARE_TEST (cxx11_tensor_builtins_sycl)

template<typename T >
T	cl::sycl::inverse (T x)

template<typename T >
T	cl::sycl::square (T x)

template<typename DataType , int DataLayout>
void	test_binary_builtins (const Eigen::SyclDevice &sycl_device, const array< int64_t, 3 > &tensor_range)

template<typename DataType , int DataLayout, typename Operator >
void	test_binary_builtins_fixed_arg2 (const Eigen::SyclDevice &sycl_device, const array< int64_t, 3 > &tensor_range)

template<typename DataType , int DataLayout, typename Operator >
void	test_binary_builtins_func (const Eigen::SyclDevice &sycl_device, const array< int64_t, 3 > &tensor_range)

template<typename DataType >
static void	test_builtin_unary_sycl (const Eigen::SyclDevice &sycl_device)

template<typename DataType >
static void	test_floating_builtin_binary_sycl (const Eigen::SyclDevice &sycl_device)

template<typename DataType >
static void	test_integer_builtin_binary_sycl (const Eigen::SyclDevice &sycl_device)

template<typename DataType , int DataLayout>
void	test_unary_builtins (const Eigen::SyclDevice &sycl_device, const array< int64_t, 3 > &tensor_range)

template<typename DataType , int DataLayout, typename Assignement >
void	test_unary_builtins_for_assignement (const Eigen::SyclDevice &sycl_device, const array< int64_t, 3 > &tensor_range)

template<typename DataType , int DataLayout, typename Assignement , typename Operator >
void	test_unary_builtins_for_scalar (const Eigen::SyclDevice &sycl_device, const array< int64_t, 3 > &tensor_range)

template<typename DataType , int DataLayout, typename Operator >
void	test_unary_builtins_return_bool (const Eigen::SyclDevice &sycl_device, const array< int64_t, 3 > &tensor_range)

Macro Definition Documentation

◆ DECLARE_BINARY_STRUCT

#define DECLARE_BINARY_STRUCT ( FUNC )

Value:

struct op_##FUNC {                                                                         \
    template <typename T1, typename T2>                                                      \
    auto operator()(const T1& x, const T2& y) -> decltype(cl::sycl::FUNC(x, y)) {            \
      return cl::sycl::FUNC(x, y);                                                           \
    }                                                                                        \
    template <typename T1, typename T2>                                                      \
    auto operator()(const TensorMap<T1>& x, const TensorMap<T2>& y) -> decltype(x.FUNC(y)) { \
      return x.FUNC(y);                                                                      \
    }                                                                                        \
  };

Definition at line 278 of file cxx11_tensor_builtins_sycl.cpp.

◆ DECLARE_BINARY_STRUCT_OP

#define DECLARE_BINARY_STRUCT_OP	(	NAME,
		OPERATOR
	)

Value:

struct op_##NAME {                                                      \
    template <typename T1, typename T2>                                   \
    auto operator()(const T1& x, const T2& y) -> decltype(x OPERATOR y) { \
      return x OPERATOR y;                                                \
    }                                                                     \
  };

Definition at line 293 of file cxx11_tensor_builtins_sycl.cpp.

◆ DECLARE_UNARY_STRUCT

#define DECLARE_UNARY_STRUCT ( FUNC )

Value:

struct op_##FUNC {                                               \
    template <typename T>                                          \
    auto operator()(const T& x) -> decltype(cl::sycl::FUNC(x)) {   \
      return cl::sycl::FUNC(x);                                    \
    }                                                              \
    template <typename T>                                          \
    auto operator()(const TensorMap<T>& x) -> decltype(x.FUNC()) { \
      return x.FUNC();                                             \
    }                                                              \
  };