@smake/eigen 1.1.0 → 1.1.1

package/eigen/Eigen/src/Core/arch/SVE/TypeCasting.h

@@ -10,6 +10,9 @@
 #ifndef EIGEN_TYPE_CASTING_SVE_H
 #define EIGEN_TYPE_CASTING_SVE_H
 
+// IWYU pragma: private
+#include "../../InternalHeaderCheck.h"
+
 namespace Eigen {
 namespace internal {
 
@@ -25,12 +28,12 @@ struct type_casting_traits<numext::int32_t, float> {
 
 template <>
 EIGEN_STRONG_INLINE PacketXf pcast<PacketXi, PacketXf>(const PacketXi& a) {
-  return svcvt_f32_s32_z(svptrue_b32(), a);
+  return svcvt_f32_s32_x(svptrue_b32(), a);
 }
 
 template <>
 EIGEN_STRONG_INLINE PacketXi pcast<PacketXf, PacketXi>(const PacketXf& a) {
-  return svcvt_s32_f32_z(svptrue_b32(), a);
+  return svcvt_s32_f32_x(svptrue_b32(), a);
 }
 
 template <>
@@ -46,4 +49,4 @@ EIGEN_STRONG_INLINE PacketXi preinterpret<PacketXi, PacketXf>(const PacketXf& a)
 }  // namespace internal
 }  // namespace Eigen
 
-#endif // EIGEN_TYPE_CASTING_SVE_H
+#endif  // EIGEN_TYPE_CASTING_SVE_H

package/eigen/Eigen/src/Core/arch/SYCL/InteropHeaders.h

@@ -21,6 +21,9 @@
 #ifndef EIGEN_INTEROP_HEADERS_SYCL_H
 #define EIGEN_INTEROP_HEADERS_SYCL_H
 
+// IWYU pragma: private
+#include "../../InternalHeaderCheck.h"
+
 namespace Eigen {
 
 #if !defined(EIGEN_DONT_VECTORIZE_SYCL)
@@ -33,7 +36,6 @@ struct sycl_packet_traits : default_packet_traits {
     Vectorizable = 1,
     AlignedOnScalar = 1,
     size = lengths,
-    HasHalfPacket = 0,
     HasDiv = 1,
     HasLog = 1,
     HasExp = 1,
@@ -76,14 +78,15 @@ struct sycl_packet_traits : default_packet_traits {
 };
 
 #ifdef SYCL_DEVICE_ONLY
-#define SYCL_PACKET_TRAITS(packet_type, has_blend, unpacket_type, lengths) \
-  template <>                                                              \
-  struct packet_traits<unpacket_type>                                      \
-      : sycl_packet_traits<has_blend, lengths> {                           \
-    typedef packet_type type;                                              \
-    typedef packet_type half;                                              \
+#define SYCL_PACKET_TRAITS(packet_type, has_blend, unpacket_type, lengths)       \
+  template <>                                                                    \
+  struct packet_traits<unpacket_type> : sycl_packet_traits<has_blend, lengths> { \
+    typedef packet_type type;                                                    \
+    typedef packet_type half;                                                    \
   };
 
+SYCL_PACKET_TRAITS(cl::sycl::cl_half8, 1, Eigen::half, 8)
+SYCL_PACKET_TRAITS(cl::sycl::cl_half8, 1, const Eigen::half, 8)
 SYCL_PACKET_TRAITS(cl::sycl::cl_float4, 1, float, 4)
 SYCL_PACKET_TRAITS(cl::sycl::cl_float4, 1, const float, 4)
 SYCL_PACKET_TRAITS(cl::sycl::cl_double2, 0, double, 2)
@@ -98,6 +101,7 @@ SYCL_PACKET_TRAITS(cl::sycl::cl_double2, 0, const double, 2)
   struct is_arithmetic<packet_type> { \
     enum { value = true };            \
   };
+SYCL_ARITHMETIC(cl::sycl::cl_half8)
 SYCL_ARITHMETIC(cl::sycl::cl_float4)
 SYCL_ARITHMETIC(cl::sycl::cl_double2)
 #undef SYCL_ARITHMETIC
@@ -109,6 +113,7 @@ SYCL_ARITHMETIC(cl::sycl::cl_double2)
     enum { size = lengths, vectorizable = true, alignment = Aligned16 }; \
     typedef packet_type half;                                            \
   };
+SYCL_UNPACKET_TRAITS(cl::sycl::cl_half8, Eigen::half, 8)
 SYCL_UNPACKET_TRAITS(cl::sycl::cl_float4, float, 4)
 SYCL_UNPACKET_TRAITS(cl::sycl::cl_double2, double, 2)
 
@@ -128,15 +133,13 @@ struct PacketWrapper;
 #ifndef SYCL_DEVICE_ONLY
 template <typename PacketReturnType, int PacketSize>
 struct PacketWrapper {
-  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
-      Scalar;
+  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type Scalar;
   template <typename Index>
   EIGEN_DEVICE_FUNC static Scalar scalarize(Index, PacketReturnType &) {
     eigen_assert(false && "THERE IS NO PACKETIZE VERSION FOR  THE CHOSEN TYPE");
     abort();
   }
-  EIGEN_DEVICE_FUNC static PacketReturnType convert_to_packet_type(Scalar in,
-                                                                   Scalar) {
+  EIGEN_DEVICE_FUNC static PacketReturnType convert_to_packet_type(Scalar in, Scalar) {
     return ::Eigen::internal::template plset<PacketReturnType>(in);
   }
   EIGEN_DEVICE_FUNC static void set_packet(PacketReturnType, Scalar *) {
@@ -148,8 +151,7 @@ struct PacketWrapper {
 #elif defined(SYCL_DEVICE_ONLY)
 template <typename PacketReturnType>
 struct PacketWrapper<PacketReturnType, 4> {
-  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
-      Scalar;
+  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type Scalar;
   template <typename Index>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index index, PacketReturnType &in) {
     switch (index) {
@@ -162,15 +164,14 @@ struct PacketWrapper<PacketReturnType, 4> {
       case 3:
         return in.w();
       default:
-      //INDEX MUST BE BETWEEN 0 and 3.There is no abort function in SYCL kernel. so we cannot use abort here. 
-      // The code will never reach here
-      __builtin_unreachable();
+        // INDEX MUST BE BETWEEN 0 and 3.There is no abort function in SYCL kernel. so we cannot use abort here.
+        //  The code will never reach here
+        __builtin_unreachable();
     }
     __builtin_unreachable();
   }
 
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(
-      Scalar in, Scalar other) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(Scalar in, Scalar other) {
     return PacketReturnType(in, other, other, other);
   }
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void set_packet(PacketReturnType &lhs, Scalar *rhs) {
@@ -180,25 +181,20 @@ struct PacketWrapper<PacketReturnType, 4> {
 
 template <typename PacketReturnType>
 struct PacketWrapper<PacketReturnType, 1> {
-  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
-      Scalar;
+  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type Scalar;
   template <typename Index>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index, PacketReturnType &in) {
     return in;
   }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(Scalar in,
-                                                                   Scalar) {
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(Scalar in, Scalar) {
     return PacketReturnType(in);
   }
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void set_packet(PacketReturnType &lhs, Scalar *rhs) {
-    lhs = rhs[0];
-  }
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void set_packet(PacketReturnType &lhs, Scalar *rhs) { lhs = rhs[0]; }
 };
 
 template <typename PacketReturnType>
 struct PacketWrapper<PacketReturnType, 2> {
-  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type
-      Scalar;
+  typedef typename ::Eigen::internal::unpacket_traits<PacketReturnType>::type Scalar;
   template <typename Index>
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static Scalar scalarize(Index index, PacketReturnType &in) {
     switch (index) {
@@ -207,15 +203,14 @@ struct PacketWrapper<PacketReturnType, 2> {
       case 1:
         return in.y();
       default:
-        //INDEX MUST BE BETWEEN 0 and 1.There is no abort function in SYCL kernel. so we cannot use abort here. 
-      // The code will never reach here
+        // INDEX MUST BE BETWEEN 0 and 1.There is no abort function in SYCL kernel. so we cannot use abort here.
+        // The code will never reach here
         __builtin_unreachable();
     }
     __builtin_unreachable();
   }
-  
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(
-      Scalar in, Scalar other) {
+
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static PacketReturnType convert_to_packet_type(Scalar in, Scalar other) {
     return PacketReturnType(in, other);
   }
   EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE static void set_packet(PacketReturnType &lhs, Scalar *rhs) {

package/eigen/Eigen/src/Core/arch/SYCL/MathFunctions.h

@@ -20,6 +20,9 @@
 
 #ifndef EIGEN_MATH_FUNCTIONS_SYCL_H
 #define EIGEN_MATH_FUNCTIONS_SYCL_H
+// IWYU pragma: private
+#include "../../InternalHeaderCheck.h"
+
 namespace Eigen {
 
 namespace internal {
@@ -28,267 +31,266 @@ namespace internal {
 // introduce conflicts between these packet_traits definitions and the ones
 // we'll use on the host side (SSE, AVX, ...)
 #if defined(SYCL_DEVICE_ONLY)
-#define SYCL_PLOG(packet_type)                                         \
-  template <>                                                          \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog<packet_type>( \
-      const packet_type& a) {                                          \
-    return cl::sycl::log(a);                                           \
+#define SYCL_PLOG(packet_type)                                                                \
+  template <>                                                                                 \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog<packet_type>(const packet_type& a) { \
+    return cl::sycl::log(a);                                                                  \
   }
 
+SYCL_PLOG(cl::sycl::cl_half8)
 SYCL_PLOG(cl::sycl::cl_float4)
 SYCL_PLOG(cl::sycl::cl_double2)
 #undef SYCL_PLOG
 
-#define SYCL_PLOG1P(packet_type)                                         \
-  template <>                                                            \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog1p<packet_type>( \
-      const packet_type& a) {                                            \
-    return cl::sycl::log1p(a);                                           \
+#define SYCL_PLOG1P(packet_type)                                                                \
+  template <>                                                                                   \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog1p<packet_type>(const packet_type& a) { \
+    return cl::sycl::log1p(a);                                                                  \
   }
 
+SYCL_PLOG1P(cl::sycl::cl_half8)
 SYCL_PLOG1P(cl::sycl::cl_float4)
 SYCL_PLOG1P(cl::sycl::cl_double2)
 #undef SYCL_PLOG1P
 
-#define SYCL_PLOG10(packet_type)                                         \
-  template <>                                                            \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog10<packet_type>( \
-      const packet_type& a) {                                            \
-    return cl::sycl::log10(a);                                           \
+#define SYCL_PLOG10(packet_type)                                                                \
+  template <>                                                                                   \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type plog10<packet_type>(const packet_type& a) { \
+    return cl::sycl::log10(a);                                                                  \
   }
 
+SYCL_PLOG10(cl::sycl::cl_half8)
 SYCL_PLOG10(cl::sycl::cl_float4)
 SYCL_PLOG10(cl::sycl::cl_double2)
 #undef SYCL_PLOG10
 
-#define SYCL_PEXP(packet_type)                                         \
-  template <>                                                          \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pexp<packet_type>( \
-      const packet_type& a) {                                          \
-    return cl::sycl::exp(a);                                           \
+#define SYCL_PEXP(packet_type)                                                                \
+  template <>                                                                                 \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pexp<packet_type>(const packet_type& a) { \
+    return cl::sycl::exp(a);                                                                  \
   }
 
+SYCL_PEXP(cl::sycl::cl_half8)
+SYCL_PEXP(cl::sycl::cl_half)
 SYCL_PEXP(cl::sycl::cl_float4)
 SYCL_PEXP(cl::sycl::cl_float)
 SYCL_PEXP(cl::sycl::cl_double2)
 #undef SYCL_PEXP
 
-#define SYCL_PEXPM1(packet_type)                                         \
-  template <>                                                            \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pexpm1<packet_type>( \
-      const packet_type& a) {                                            \
-    return cl::sycl::expm1(a);                                           \
+#define SYCL_PEXPM1(packet_type)                                                                \
+  template <>                                                                                   \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pexpm1<packet_type>(const packet_type& a) { \
+    return cl::sycl::expm1(a);                                                                  \
   }
 
+SYCL_PEXPM1(cl::sycl::cl_half8)
 SYCL_PEXPM1(cl::sycl::cl_float4)
 SYCL_PEXPM1(cl::sycl::cl_double2)
 #undef SYCL_PEXPM1
 
-#define SYCL_PSQRT(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psqrt<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::sqrt(a);                                           \
+#define SYCL_PSQRT(packet_type)                                                                \
+  template <>                                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psqrt<packet_type>(const packet_type& a) { \
+    return cl::sycl::sqrt(a);                                                                  \
   }
 
+SYCL_PSQRT(cl::sycl::cl_half8)
 SYCL_PSQRT(cl::sycl::cl_float4)
 SYCL_PSQRT(cl::sycl::cl_double2)
 #undef SYCL_PSQRT
 
-#define SYCL_PRSQRT(packet_type)                                         \
-  template <>                                                            \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type prsqrt<packet_type>( \
-      const packet_type& a) {                                            \
-    return cl::sycl::rsqrt(a);                                           \
+#define SYCL_PRSQRT(packet_type)                                                                \
+  template <>                                                                                   \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type prsqrt<packet_type>(const packet_type& a) { \
+    return cl::sycl::rsqrt(a);                                                                  \
   }
 
+SYCL_PRSQRT(cl::sycl::cl_half8)
 SYCL_PRSQRT(cl::sycl::cl_float4)
 SYCL_PRSQRT(cl::sycl::cl_double2)
 #undef SYCL_PRSQRT
 
 /** \internal \returns the hyperbolic sine of \a a (coeff-wise) */
-#define SYCL_PSIN(packet_type)                                         \
-  template <>                                                          \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psin<packet_type>( \
-      const packet_type& a) {                                          \
-    return cl::sycl::sin(a);                                           \
+#define SYCL_PSIN(packet_type)                                                                \
+  template <>                                                                                 \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psin<packet_type>(const packet_type& a) { \
+    return cl::sycl::sin(a);                                                                  \
   }
 
+SYCL_PSIN(cl::sycl::cl_half8)
 SYCL_PSIN(cl::sycl::cl_float4)
 SYCL_PSIN(cl::sycl::cl_double2)
 #undef SYCL_PSIN
 
 /** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */
-#define SYCL_PCOS(packet_type)                                         \
-  template <>                                                          \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pcos<packet_type>( \
-      const packet_type& a) {                                          \
-    return cl::sycl::cos(a);                                           \
+#define SYCL_PCOS(packet_type)                                                                \
+  template <>                                                                                 \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pcos<packet_type>(const packet_type& a) { \
+    return cl::sycl::cos(a);                                                                  \
   }
 
+SYCL_PCOS(cl::sycl::cl_half8)
 SYCL_PCOS(cl::sycl::cl_float4)
 SYCL_PCOS(cl::sycl::cl_double2)
 #undef SYCL_PCOS
 
 /** \internal \returns the hyperbolic tan of \a a (coeff-wise) */
-#define SYCL_PTAN(packet_type)                                         \
-  template <>                                                          \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ptan<packet_type>( \
-      const packet_type& a) {                                          \
-    return cl::sycl::tan(a);                                           \
+#define SYCL_PTAN(packet_type)                                                                \
+  template <>                                                                                 \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ptan<packet_type>(const packet_type& a) { \
+    return cl::sycl::tan(a);                                                                  \
   }
 
+SYCL_PTAN(cl::sycl::cl_half8)
 SYCL_PTAN(cl::sycl::cl_float4)
 SYCL_PTAN(cl::sycl::cl_double2)
 #undef SYCL_PTAN
 
 /** \internal \returns the hyperbolic sine of \a a (coeff-wise) */
-#define SYCL_PASIN(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pasin<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::asin(a);                                           \
+#define SYCL_PASIN(packet_type)                                                                \
+  template <>                                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pasin<packet_type>(const packet_type& a) { \
+    return cl::sycl::asin(a);                                                                  \
   }
 
+SYCL_PASIN(cl::sycl::cl_half8)
 SYCL_PASIN(cl::sycl::cl_float4)
 SYCL_PASIN(cl::sycl::cl_double2)
 #undef SYCL_PASIN
 
 /** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */
-#define SYCL_PACOS(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pacos<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::acos(a);                                           \
+#define SYCL_PACOS(packet_type)                                                                \
+  template <>                                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pacos<packet_type>(const packet_type& a) { \
+    return cl::sycl::acos(a);                                                                  \
   }
 
+SYCL_PACOS(cl::sycl::cl_half8)
 SYCL_PACOS(cl::sycl::cl_float4)
 SYCL_PACOS(cl::sycl::cl_double2)
 #undef SYCL_PACOS
 
 /** \internal \returns the hyperbolic tan of \a a (coeff-wise) */
-#define SYCL_PATAN(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type patan<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::atan(a);                                           \
+#define SYCL_PATAN(packet_type)                                                                \
+  template <>                                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type patan<packet_type>(const packet_type& a) { \
+    return cl::sycl::atan(a);                                                                  \
   }
 
+SYCL_PATAN(cl::sycl::cl_half8)
 SYCL_PATAN(cl::sycl::cl_float4)
 SYCL_PATAN(cl::sycl::cl_double2)
 #undef SYCL_PATAN
 
 /** \internal \returns the hyperbolic sine of \a a (coeff-wise) */
-#define SYCL_PSINH(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psinh<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::sinh(a);                                           \
+#define SYCL_PSINH(packet_type)                                                                \
+  template <>                                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type psinh<packet_type>(const packet_type& a) { \
+    return cl::sycl::sinh(a);                                                                  \
   }
 
+SYCL_PSINH(cl::sycl::cl_half8)
 SYCL_PSINH(cl::sycl::cl_float4)
 SYCL_PSINH(cl::sycl::cl_double2)
 #undef SYCL_PSINH
 
 /** \internal \returns the hyperbolic cosine of \a a (coeff-wise) */
-#define SYCL_PCOSH(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pcosh<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::cosh(a);                                           \
+#define SYCL_PCOSH(packet_type)                                                                \
+  template <>                                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pcosh<packet_type>(const packet_type& a) { \
+    return cl::sycl::cosh(a);                                                                  \
   }
 
+SYCL_PCOSH(cl::sycl::cl_half8)
 SYCL_PCOSH(cl::sycl::cl_float4)
 SYCL_PCOSH(cl::sycl::cl_double2)
 #undef SYCL_PCOSH
 
 /** \internal \returns the hyperbolic tan of \a a (coeff-wise) */
-#define SYCL_PTANH(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ptanh<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::tanh(a);                                           \
+#define SYCL_PTANH(packet_type)                                                                \
+  template <>                                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type ptanh<packet_type>(const packet_type& a) { \
+    return cl::sycl::tanh(a);                                                                  \
   }
 
+SYCL_PTANH(cl::sycl::cl_half8)
 SYCL_PTANH(cl::sycl::cl_float4)
 SYCL_PTANH(cl::sycl::cl_double2)
 #undef SYCL_PTANH
 
-#define SYCL_PCEIL(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pceil<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::ceil(a);                                           \
+#define SYCL_PCEIL(packet_type)                                                                \
+  template <>                                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pceil<packet_type>(const packet_type& a) { \
+    return cl::sycl::ceil(a);                                                                  \
   }
 
+SYCL_PCEIL(cl::sycl::cl_half)
 SYCL_PCEIL(cl::sycl::cl_float4)
 SYCL_PCEIL(cl::sycl::cl_double2)
 #undef SYCL_PCEIL
 
-#define SYCL_PROUND(packet_type)                                         \
-  template <>                                                            \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pround<packet_type>( \
-      const packet_type& a) {                                            \
-    return cl::sycl::round(a);                                           \
+#define SYCL_PROUND(packet_type)                                                                \
+  template <>                                                                                   \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pround<packet_type>(const packet_type& a) { \
+    return cl::sycl::round(a);                                                                  \
   }
 
+SYCL_PROUND(cl::sycl::cl_half8)
 SYCL_PROUND(cl::sycl::cl_float4)
 SYCL_PROUND(cl::sycl::cl_double2)
 #undef SYCL_PROUND
 
-#define SYCL_PRINT(packet_type)                                         \
-  template <>                                                           \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type print<packet_type>( \
-      const packet_type& a) {                                           \
-    return cl::sycl::rint(a);                                           \
+#define SYCL_PRINT(packet_type)                                                                \
+  template <>                                                                                  \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type print<packet_type>(const packet_type& a) { \
+    return cl::sycl::rint(a);                                                                  \
   }
 
+SYCL_PRINT(cl::sycl::cl_half8)
 SYCL_PRINT(cl::sycl::cl_float4)
 SYCL_PRINT(cl::sycl::cl_double2)
 #undef SYCL_PRINT
 
-#define SYCL_FLOOR(packet_type)                                          \
-  template <>                                                            \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pfloor<packet_type>( \
-      const packet_type& a) {                                            \
-    return cl::sycl::floor(a);                                           \
+#define SYCL_FLOOR(packet_type)                                                                 \
+  template <>                                                                                   \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pfloor<packet_type>(const packet_type& a) { \
+    return cl::sycl::floor(a);                                                                  \
   }
 
+SYCL_FLOOR(cl::sycl::cl_half8)
 SYCL_FLOOR(cl::sycl::cl_float4)
 SYCL_FLOOR(cl::sycl::cl_double2)
 #undef SYCL_FLOOR
 
-#define SYCL_PMIN(packet_type, expr)                                   \
-  template <>                                                          \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pmin<packet_type>( \
-      const packet_type& a, const packet_type& b) {                    \
-    return expr;                                                       \
+#define SYCL_PMIN(packet_type, expr)                                                                                \
+  template <>                                                                                                       \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pmin<packet_type>(const packet_type& a, const packet_type& b) { \
+    return expr;                                                                                                    \
   }
 
+SYCL_PMIN(cl::sycl::cl_half8, cl::sycl::fmin(a, b))
 SYCL_PMIN(cl::sycl::cl_float4, cl::sycl::fmin(a, b))
 SYCL_PMIN(cl::sycl::cl_double2, cl::sycl::fmin(a, b))
 #undef SYCL_PMIN
 
-#define SYCL_PMAX(packet_type, expr)                                   \
-  template <>                                                          \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pmax<packet_type>( \
-      const packet_type& a, const packet_type& b) {                    \
-    return expr;                                                       \
+#define SYCL_PMAX(packet_type, expr)                                                                                \
+  template <>                                                                                                       \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pmax<packet_type>(const packet_type& a, const packet_type& b) { \
+    return expr;                                                                                                    \
   }
 
+SYCL_PMAX(cl::sycl::cl_half8, cl::sycl::fmax(a, b))
 SYCL_PMAX(cl::sycl::cl_float4, cl::sycl::fmax(a, b))
 SYCL_PMAX(cl::sycl::cl_double2, cl::sycl::fmax(a, b))
 #undef SYCL_PMAX
 
-#define SYCL_PLDEXP(packet_type)                                             \
-  template <>                                                                \
-  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pldexp(                  \
-      const packet_type& a, const packet_type& exponent) {                   \
-    return cl::sycl::ldexp(                                                  \
-        a, exponent.template convert<cl::sycl::cl_int,                       \
-                                     cl::sycl::rounding_mode::automatic>()); \
+#define SYCL_PLDEXP(packet_type)                                                                                  \
+  template <>                                                                                                     \
+  EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE packet_type pldexp(const packet_type& a, const packet_type& exponent) {   \
+    return cl::sycl::ldexp(a, exponent.template convert<cl::sycl::cl_int, cl::sycl::rounding_mode::automatic>()); \
   }
 
+SYCL_PLDEXP(cl::sycl::cl_half8)
 SYCL_PLDEXP(cl::sycl::cl_float4)
 SYCL_PLDEXP(cl::sycl::cl_double2)
 #undef SYCL_PLDEXP