From 9eca5bcc6e2f4d1373e45c449eccb5ad6b7aff48 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Tue, 14 Mar 2023 15:14:47 +0100
Subject: [PATCH 01/39] [SYCL][MARRAY] introduce sycl complex marray
 specialization

---
 .../ext/oneapi/experimental/sycl_complex.hpp  | 424 +++++++++++++++++-
 1 file changed, 421 insertions(+), 3 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
index 0f8223286b852..a6c509b6d2d83 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
@@ -61,9 +61,7 @@ template <class _Tp> struct __numeric_type {
   static const bool value = _IsNotSame<type, void>::value;
 };
 
-template <> struct __numeric_type<void> {
-  static const bool value = true;
-};
+template <> struct __numeric_type<void> { static const bool value = true; };
 
 template <class _A1, class _A2 = void, class _A3 = void,
           bool = __numeric_type<_A1>::value &&__numeric_type<_A2>::value
@@ -983,6 +981,426 @@ tan(const complex<_Tp> &__x) {
 } // namespace oneapi
 } // namespace ext
 
+template <typename T, std::size_t NumElements>
+class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
+private:
+  using ComplexDataT = sycl::ext::oneapi::experimental::complex<T>;
+
+public:
+  using value_type = ComplexDataT;
+  using reference = ComplexDataT &;
+  using const_reference = const ComplexDataT &;
+  using iterator = ComplexDataT *;
+  using const_iterator = const ComplexDataT *;
+
+private:
+  value_type MData[NumElements];
+
+public:
+  constexpr marray() : MData{} {};
+
+  explicit constexpr marray(const ComplexDataT &arg) {
+    for (size_t i = 0; i < NumElements; ++i) {
+      MData[i] = arg;
+    }
+  }
+
+  template <typename... ArgTN>
+  constexpr marray(const ArgTN &... args) : MData{args...} {};
+
+  constexpr marray(const marray<ComplexDataT, NumElements> &rhs) = default;
+  constexpr marray(marray<ComplexDataT, NumElements> &&rhs) = default;
+
+  // Available only when: NumElements == 1
+  template <typename = typename std::enable_if<NumElements == 1>>
+  operator ComplexDataT() const {
+    return MData[0];
+  }
+
+  static constexpr std::size_t size() noexcept { return NumElements; }
+
+  marray<T, NumElements> real() const {
+    sycl::marray<T, NumElements> rtn;
+    for (std::size_t i = 0; i < NumElements; ++i) {
+      rtn[i] = MData[i].real();
+    }
+    return rtn;
+  }
+
+  marray<T, NumElements> imag() const {
+    sycl::marray<T, NumElements> rtn;
+    for (std::size_t i = 0; i < NumElements; ++i) {
+      rtn[i] = MData[i].imag();
+    }
+    return rtn;
+  }
+
+  // subscript operator
+  reference operator[](std::size_t i) { return MData[i]; }
+  const_reference operator[](std::size_t i) const { return MData[i]; }
+
+  marray &operator=(const marray<ComplexDataT, NumElements> &rhs) = default;
+  marray &operator=(const ComplexDataT &rhs) {
+    for (std::size_t i = 0; i < NumElements; ++i) {
+      MData[i] = rhs;
+    }
+    return *this;
+  }
+
+  // iterator functions
+  iterator begin() { return MData; }
+  const_iterator begin() const { return MData; }
+
+  iterator end() { return MData + NumElements; }
+  const_iterator end() const { return MData + NumElements; }
+
+  // OP is: +, -, *, /
+#define OP(op)                                                                 \
+  friend marray operator op(const marray &lhs, const marray &rhs) {            \
+    marray rtn;                                                                \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = lhs[i] op rhs[i];                                               \
+    }                                                                          \
+    return rtn;                                                                \
+  }                                                                            \
+                                                                               \
+  friend marray operator op(const marray &lhs, const ComplexDataT &rhs) {      \
+    marray rtn;                                                                \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = lhs[i] op rhs;                                                  \
+    }                                                                          \
+    return rtn;                                                                \
+  }                                                                            \
+                                                                               \
+  friend marray operator op(const ComplexDataT &lhs, const marray &rhs) {      \
+    marray rtn;                                                                \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = lhs op rhs[i];                                                  \
+    }                                                                          \
+    return rtn;                                                                \
+  }
+
+  OP(+)
+  OP(-)
+  OP(*)
+  OP(/)
+
+#undef OP
+
+  // OP is: %
+  friend marray operator%(const marray &lhs, const marray &rhs) = delete;
+  friend marray operator%(const marray &lhs, const ComplexDataT &rhs) = delete;
+  friend marray operator%(const ComplexDataT &lhs, const marray &rhs) = delete;
+
+  // OP is: +=, -=, *=, /=
+#define OP(op)                                                                 \
+  friend marray &operator op(marray &lhs, const marray &rhs) {                 \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      lhs[i] op rhs[i];                                                        \
+    }                                                                          \
+    return lhs;                                                                \
+  }                                                                            \
+                                                                               \
+  friend marray &operator op(marray &lhs, const ComplexDataT &rhs) {           \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      lhs[i] op rhs;                                                           \
+    }                                                                          \
+    return lhs;                                                                \
+  }                                                                            \
+  friend marray &operator op(ComplexDataT &lhs, const marray &rhs) {           \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      lhs[i] op rhs;                                                           \
+    }                                                                          \
+    return lhs;                                                                \
+  }
+
+  OP(+=)
+  OP(-=)
+  OP(*=)
+  OP(/=)
+
+#undef OP
+
+  // OP is: %=
+  friend marray &operator%=(marray &lhs, const marray &rhs) = delete;
+  friend marray &operator%=(marray &lhs, const ComplexDataT &rhs) = delete;
+  friend marray &operator%=(ComplexDataT &lhs, const marray &rhs) = delete;
+
+// OP is: ++, --
+#define OP(op)                                                                 \
+  friend marray operator op(marray &lhs, int) = delete;                        \
+  friend marray &operator op(marray &rhs) = delete;
+
+  OP(++)
+  OP(--)
+
+#undef OP
+
+// OP is: unary +, unary -
+#define OP(op)                                                                 \
+  friend marray<ComplexDataT, NumElements> operator op(                        \
+      const marray<ComplexDataT, NumElements> &rhs) {                          \
+    marray<ComplexDataT, NumElements> rtn;                                     \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = op rhs[i];                                                      \
+    }                                                                          \
+    return rtn;                                                                \
+  }
+
+  OP(+)
+  OP(-)
+
+#undef OP
+
+// OP is: &, |, ^
+#define OP(op)                                                                 \
+  friend marray operator op(const marray &lhs, const marray &rhs) = delete;    \
+  friend marray operator op(const marray &lhs, const ComplexDataT &rhs) =      \
+      delete;
+
+  OP(&)
+  OP(|)
+  OP(^)
+
+#undef OP
+
+// OP is: &=, |=, ^=
+#define OP(op)                                                                 \
+  friend marray &operator op(marray &lhs, const marray &rhs) = delete;         \
+  friend marray &operator op(marray &lhs, const ComplexDataT &rhs) = delete;   \
+  friend marray &operator op(ComplexDataT &lhs, const marray &rhs) = delete;
+
+  OP(&=)
+  OP(|=)
+  OP(^=)
+
+#undef OP
+
+// OP is: &&, ||
+#define OP(op)                                                                 \
+  friend marray<bool, NumElements> operator op(const marray &lhs,              \
+                                               const marray &rhs) = delete;    \
+  friend marray<bool, NumElements> operator op(                                \
+      const marray &lhs, const ComplexDataT &rhs) = delete;                    \
+  friend marray<bool, NumElements> operator op(const ComplexDataT &lhs,        \
+                                               const marray &rhs) = delete;
+
+  OP(&&)
+  OP(||)
+
+#undef OP
+
+// OP is: <<, >>
+#define OP(op)                                                                 \
+  friend marray operator op(const marray &lhs, const marray &rhs) = delete;    \
+  friend marray operator op(const marray &lhs, const ComplexDataT &rhs) =      \
+      delete;                                                                  \
+  friend marray operator op(const ComplexDataT &lhs, const marray &rhs) =      \
+      delete;
+
+  OP(<<)
+  OP(>>)
+
+#undef OP
+
+// OP is: <<=, >>=
+#define OP(op)                                                                 \
+  friend marray &operator op(marray &lhs, const marray &rhs) = delete;         \
+  friend marray &operator op(marray &lhs, const ComplexDataT &rhs) = delete;
+
+  OP(<<=)
+  OP(>>=)
+
+#undef OP
+
+  // OP is: ==, !=
+#define OP(op)                                                                 \
+  friend marray<bool, NumElements> operator op(const marray &lhs,              \
+                                               const marray &rhs) {            \
+    marray<bool, NumElements> rtn;                                             \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = lhs[i] op rhs[i];                                               \
+    }                                                                          \
+    return rtn;                                                                \
+  }                                                                            \
+                                                                               \
+  friend marray<bool, NumElements> operator op(const marray &lhs,              \
+                                               const ComplexDataT &rhs) {      \
+    marray<bool, NumElements> rtn;                                             \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = lhs[i] op rhs;                                                  \
+    }                                                                          \
+    return rtn;                                                                \
+  }                                                                            \
+                                                                               \
+  friend marray<bool, NumElements> operator op(const ComplexDataT &lhs,        \
+                                               const marray &rhs) {            \
+    marray<bool, NumElements> rtn;                                             \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = lhs op rhs[i];                                                  \
+    }                                                                          \
+    return rtn;                                                                \
+  }
+
+  OP(==)
+  OP(!=)
+
+#undef OP
+
+  // OP is: <, >, <=, >=
+#define OP(op)                                                                 \
+  friend marray<bool, NumElements> operator op(const marray &lhs,              \
+                                               const marray &rhs) = delete;    \
+  friend marray<bool, NumElements> operator op(                                \
+      const marray &lhs, const ComplexDataT &rhs) = delete;                    \
+  friend marray<bool, NumElements> operator op(const ComplexDataT &lhs,        \
+                                               const marray &rhs) = delete;
+
+  OP(<);
+  OP(>);
+  OP(<=);
+  OP(>=);
+
+#undef OP
+
+  friend marray operator~(const marray &v) = delete;
+
+  friend marray<bool, NumElements> operator!(const marray &v) = delete;
+};
+
+namespace ext {
+namespace oneapi {
+namespace experimental {
+
+// Math marray overloads
+
+#define MATH_OP_ONE_PARAM(math_func, rtn_type, arg_type)                       \
+  template <typename T, std::size_t NumElements,                               \
+            typename = std::enable_if<is_genfloat<T>::value ||                 \
+                                      is_gencomplex<T>::value>>                \
+  _SYCL_EXT_CPLX_INLINE_VISIBILITY sycl::marray<rtn_type, NumElements>         \
+  math_func(const sycl::marray<arg_type, NumElements> &x) {                    \
+    sycl::marray<rtn_type, NumElements> rtn;                                   \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = sycl::ext::oneapi::experimental::math_func(x[i]);               \
+    }                                                                          \
+    return rtn;                                                                \
+  }
+
+MATH_OP_ONE_PARAM(abs, T, complex<T>);
+MATH_OP_ONE_PARAM(acos, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(asin, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(atan, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(acosh, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(asinh, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(atanh, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(arg, T, complex<T>);
+MATH_OP_ONE_PARAM(conj, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(cos, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(cosh, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(exp, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(log, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(log10, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(norm, T, complex<T>);
+MATH_OP_ONE_PARAM(proj, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(proj, complex<T>, T);
+MATH_OP_ONE_PARAM(sin, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(sinh, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(sqrt, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(tan, complex<T>, complex<T>);
+MATH_OP_ONE_PARAM(tanh, complex<T>, complex<T>);
+
+#undef MATH_OP_ONE_PARAM
+
+#define MATH_OP_TWO_PARAM(math_func, rtn_type, arg_type1, arg_type2)           \
+  template <typename T, std::size_t NumElements,                               \
+            typename = std::enable_if<is_genfloat<T>::value ||                 \
+                                      is_gencomplex<T>::value>>                \
+  _SYCL_EXT_CPLX_INLINE_VISIBILITY sycl::marray<rtn_type, NumElements>         \
+  math_func(const sycl::marray<arg_type1, NumElements> &x,                     \
+            const sycl::marray<arg_type2, NumElements> &y) {                   \
+    sycl::marray<rtn_type, NumElements> rtn;                                   \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = sycl::ext::oneapi::experimental::math_func(x[i], y[i]);         \
+    }                                                                          \
+    return rtn;                                                                \
+  }                                                                            \
+                                                                               \
+  template <typename T, std::size_t NumElements,                               \
+            typename = std::enable_if<is_genfloat<T>::value ||                 \
+                                      is_gencomplex<T>::value>>                \
+  _SYCL_EXT_CPLX_INLINE_VISIBILITY sycl::marray<rtn_type, NumElements>         \
+  math_func(const sycl::marray<arg_type1, NumElements> &x,                     \
+            const arg_type2 &y) {                                              \
+    sycl::marray<rtn_type, NumElements> rtn;                                   \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = sycl::ext::oneapi::experimental::math_func(x[i], y);            \
+    }                                                                          \
+    return rtn;                                                                \
+  }                                                                            \
+                                                                               \
+  template <typename T, std::size_t NumElements,                               \
+            typename = std::enable_if<is_genfloat<T>::value ||                 \
+                                      is_gencomplex<T>::value>>                \
+  _SYCL_EXT_CPLX_INLINE_VISIBILITY sycl::marray<rtn_type, NumElements>         \
+  math_func(const arg_type1 &x,                                                \
+            const sycl::marray<arg_type2, NumElements> &y) {                   \
+    sycl::marray<rtn_type, NumElements> rtn;                                   \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = math_func(x, y[i]);                                             \
+    }                                                                          \
+    return rtn;                                                                \
+  }
+
+MATH_OP_TWO_PARAM(pow, complex<T>, complex<T>, T);
+MATH_OP_TWO_PARAM(pow, complex<T>, complex<T>, complex<T>);
+MATH_OP_TWO_PARAM(pow, complex<T>, T, complex<T>);
+
+#undef MATH_OP_TWO_PARAM
+
+// Special definition as polar requires default argument
+
+template <typename T, std::size_t NumElements,
+          typename = std::enable_if<is_genfloat<T>::value>>
+_SYCL_EXT_CPLX_INLINE_VISIBILITY
+    sycl::marray<sycl::ext::oneapi::experimental::complex<T>, NumElements>
+    polar(const sycl::marray<T, NumElements> &rho,
+          const sycl::marray<T, NumElements> &theta) {
+  sycl::marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> rtn;
+  for (std::size_t i = 0; i < NumElements; ++i) {
+    rtn[i] = sycl::ext::oneapi::experimental::polar(rho[i], theta[i]);
+  }
+  return rtn;
+}
+
+template <typename T, std::size_t NumElements,
+          typename = std::enable_if<is_genfloat<T>::value>>
+_SYCL_EXT_CPLX_INLINE_VISIBILITY
+    sycl::marray<sycl::ext::oneapi::experimental::complex<T>, NumElements>
+    polar(const sycl::marray<T, NumElements> &rho, const T &theta = 0) {
+  sycl::marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> rtn;
+  for (std::size_t i = 0; i < NumElements; ++i) {
+    rtn[i] = sycl::ext::oneapi::experimental::polar(rho[i], theta);
+  }
+  return rtn;
+}
+
+template <typename T, std::size_t NumElements,
+          typename = std::enable_if<is_genfloat<T>::value>>
+_SYCL_EXT_CPLX_INLINE_VISIBILITY
+    sycl::marray<sycl::ext::oneapi::experimental::complex<T>, NumElements>
+    polar(const T &rho, const sycl::marray<T, NumElements> &theta) {
+  sycl::marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> rtn;
+  for (std::size_t i = 0; i < NumElements; ++i) {
+    rtn[i] = sycl::ext::oneapi::experimental::polar(rho, theta[i]);
+  }
+  return rtn;
+}
+
+} // namespace experimental
+} // namespace oneapi
+} // namespace ext
+
 } // __SYCL_INLINE_VER_NAMESPACE(_V1)
 } // namespace sycl
 

From c5ba5af6447f1019dda1e5223840ebf2a2080493 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Tue, 14 Mar 2023 15:15:21 +0100
Subject: [PATCH 02/39] [SYCL][MARRAY] add marray specialization's tests

---
 sycl/test/extensions/test_marray_complex.cpp | 253 +++++++++++++++++++
 1 file changed, 253 insertions(+)
 create mode 100644 sycl/test/extensions/test_marray_complex.cpp

diff --git a/sycl/test/extensions/test_marray_complex.cpp b/sycl/test/extensions/test_marray_complex.cpp
new file mode 100644
index 0000000000000..0a4118bdd56f2
--- /dev/null
+++ b/sycl/test/extensions/test_marray_complex.cpp
@@ -0,0 +1,253 @@
+// RUN: %clangxx -fsycl -fsyntax-only %s
+
+#define SYCL_EXT_ONEAPI_COMPLEX
+
+#include <sycl/ext/oneapi/experimental/sycl_complex.hpp>
+#include <sycl/sycl.hpp>
+
+using namespace sycl::ext::oneapi::experimental;
+
+// Helper to test each complex specilization
+template <template <typename, std::size_t> typename action>
+void test_valid_types() {
+  action<double, 42> testd;
+  testd();
+
+  action<float, 42> testf;
+  testf();
+
+  action<sycl::half, 42> testh;
+  testh();
+}
+
+// Define math function tests - marray<complex<T>> -> marray<T>
+#define TEST_MATH_FUNC_TYPE(name)                                              \
+  template <typename T, std::size_t NumElements>                               \
+  struct test##_##name##_##types {                                             \
+    bool operator()() {                                                        \
+      sycl::queue Q;                                                           \
+                                                                               \
+      static_assert(std::is_same_v<                                            \
+                    sycl::marray<T, NumElements>,                              \
+                    decltype(name(sycl::marray<complex<T>, NumElements>()))>); \
+                                                                               \
+      return true;                                                             \
+    }                                                                          \
+  };
+
+TEST_MATH_FUNC_TYPE(abs)
+#undef TEST_MATH_FUNC_TYPE
+
+// Define math function tests - marray<complex<T>> -> marray<complex<T>>
+#define TEST_MATH_FUNC_TYPE(name)                                              \
+  template <typename T, std::size_t NumElements>                               \
+  struct test##_##name##_##types {                                             \
+    bool operator()() {                                                        \
+      sycl::queue Q;                                                           \
+                                                                               \
+      static_assert(std::is_same_v<                                            \
+                    sycl::marray<complex<T>, NumElements>,                     \
+                    decltype(name(sycl::marray<complex<T>, NumElements>()))>); \
+                                                                               \
+      return true;                                                             \
+    }                                                                          \
+  };
+
+TEST_MATH_FUNC_TYPE(acos)
+TEST_MATH_FUNC_TYPE(asin)
+TEST_MATH_FUNC_TYPE(atan)
+TEST_MATH_FUNC_TYPE(acosh)
+TEST_MATH_FUNC_TYPE(asinh)
+TEST_MATH_FUNC_TYPE(atanh)
+TEST_MATH_FUNC_TYPE(conj)
+TEST_MATH_FUNC_TYPE(cos)
+TEST_MATH_FUNC_TYPE(cosh)
+TEST_MATH_FUNC_TYPE(exp)
+TEST_MATH_FUNC_TYPE(log)
+TEST_MATH_FUNC_TYPE(log10)
+TEST_MATH_FUNC_TYPE(proj)
+TEST_MATH_FUNC_TYPE(sin)
+TEST_MATH_FUNC_TYPE(sinh)
+TEST_MATH_FUNC_TYPE(sqrt)
+TEST_MATH_FUNC_TYPE(tan)
+TEST_MATH_FUNC_TYPE(tanh)
+#undef TEST_MATH_FUNC_TYPE
+
+// Define math operator tests
+#define TEST_MATH_OP_TYPE(name, op)                                            \
+  template <typename T, std::size_t NumElements>                               \
+  struct test##_##name##_##types {                                             \
+    bool operator()() {                                                        \
+      sycl::queue Q;                                                           \
+                                                                               \
+      static_assert(                                                           \
+          std::is_same_v<                                                      \
+              sycl::marray<complex<T>, NumElements>,                           \
+              decltype(std::declval<sycl::marray<complex<T>, NumElements>>()   \
+                           op std::declval<                                    \
+                               sycl::marray<complex<T>, NumElements>>())>);    \
+                                                                               \
+      static_assert(                                                           \
+          std::is_same_v<                                                      \
+              sycl::marray<complex<T>, NumElements>,                           \
+              decltype(std::declval<sycl::marray<complex<T>, NumElements>>()   \
+                           op std::declval<sycl::marray<T, NumElements>>())>); \
+                                                                               \
+      static_assert(                                                           \
+          std::is_same_v<sycl::marray<complex<T>, NumElements>,                \
+                         decltype(std::declval<sycl::marray<T, NumElements>>() \
+                                      op std::declval<sycl::marray<            \
+                                          complex<T>, NumElements>>())>);      \
+                                                                               \
+      return true;                                                             \
+    }                                                                          \
+  };
+
+TEST_MATH_OP_TYPE(add, +)
+TEST_MATH_OP_TYPE(sub, -)
+TEST_MATH_OP_TYPE(mul, *)
+TEST_MATH_OP_TYPE(div, /)
+#undef TEST_MATH_OP_TYPE
+
+// Define logic operator tests
+#define TEST_LOGIC_OP_TYPE(name, op)                                           \
+  template <typename T, std::size_t NumElements>                               \
+  struct test##_##name##_##types {                                             \
+    bool operator()() {                                                        \
+      sycl::queue Q;                                                           \
+                                                                               \
+      static_assert(                                                           \
+          std::is_same_v<                                                      \
+              sycl::marray<bool, NumElements>,                                 \
+              decltype(std::declval<sycl::marray<complex<T>, NumElements>>()   \
+                           op std::declval<                                    \
+                               sycl::marray<complex<T>, NumElements>>())>);    \
+                                                                               \
+      static_assert(                                                           \
+          std::is_same_v<                                                      \
+              sycl::marray<bool, NumElements>,                                 \
+              decltype(std::declval<sycl::marray<complex<T>, NumElements>>()   \
+                           op std::declval<sycl::marray<T, NumElements>>())>); \
+                                                                               \
+      static_assert(                                                           \
+          std::is_same_v<sycl::marray<bool, NumElements>,                      \
+                         decltype(std::declval<sycl::marray<T, NumElements>>() \
+                                      op std::declval<sycl::marray<            \
+                                          complex<T>, NumElements>>())>);      \
+                                                                               \
+      return true;                                                             \
+    }                                                                          \
+  };
+
+TEST_LOGIC_OP_TYPE(equal, ==)
+TEST_LOGIC_OP_TYPE(not_equal, !=)
+#undef TEST_LOGIC_OP_TYPE
+
+// Define polar function tests
+template <typename T, std::size_t NumElements> struct test_polar_types {
+  bool operator()() {
+    sycl::queue Q;
+
+    static_assert(
+        std::is_same_v<sycl::marray<complex<T>, NumElements>,
+                       decltype(polar(sycl::marray<T, NumElements>()))>);
+    static_assert(
+        std::is_same_v<sycl::marray<complex<T>, NumElements>,
+                       decltype(polar(sycl::marray<T, NumElements>(),
+                                      sycl::marray<T, NumElements>()))>);
+    static_assert(
+        std::is_same_v<sycl::marray<complex<T>, NumElements>,
+                       decltype(polar(sycl::marray<T, NumElements>(), T()))>);
+    static_assert(
+        std::is_same_v<sycl::marray<complex<T>, NumElements>,
+                       decltype(polar(T(), sycl::marray<T, NumElements>()))>);
+
+    return true;
+  }
+};
+
+// Define pow function tests
+template <typename T, std::size_t NumElements> struct test_pow_types {
+  bool operator()() {
+    sycl::queue Q;
+
+    // complex-deci
+    static_assert(
+        std::is_same_v<sycl::marray<complex<T>, NumElements>,
+                       decltype(pow(sycl::marray<complex<T>, NumElements>(),
+                                    sycl::marray<T, NumElements>()))>);
+    static_assert(std::is_same_v<
+                  sycl::marray<complex<T>, NumElements>,
+                  decltype(pow(sycl::marray<complex<T>, NumElements>(), T()))>);
+    static_assert(std::is_same_v<
+                  sycl::marray<complex<T>, NumElements>,
+                  decltype(pow(complex<T>(), sycl::marray<T, NumElements>()))>);
+
+    // complex-complex
+    static_assert(
+        std::is_same_v<sycl::marray<complex<T>, NumElements>,
+                       decltype(pow(sycl::marray<complex<T>, NumElements>(),
+                                    sycl::marray<complex<T>, NumElements>()))>);
+    static_assert(
+        std::is_same_v<sycl::marray<complex<T>, NumElements>,
+                       decltype(pow(sycl::marray<complex<T>, NumElements>(),
+                                    complex<T>()))>);
+    static_assert(
+        std::is_same_v<sycl::marray<complex<T>, NumElements>,
+                       decltype(pow(complex<T>(),
+                                    sycl::marray<complex<T>, NumElements>()))>);
+
+    // deci-complx
+    static_assert(
+        std::is_same_v<sycl::marray<complex<T>, NumElements>,
+                       decltype(pow(sycl::marray<T, NumElements>(),
+                                    sycl::marray<complex<T>, NumElements>()))>);
+    static_assert(std::is_same_v<sycl::marray<complex<T>, NumElements>,
+                                 decltype(pow(sycl::marray<T, NumElements>(),
+                                              complex<T>()))>);
+    static_assert(std::is_same_v<
+                  sycl::marray<complex<T>, NumElements>,
+                  decltype(pow(T(), sycl::marray<complex<T>, NumElements>()))>);
+
+    return true;
+  }
+};
+
+int main() {
+  // Check math function types
+  test_valid_types<test_abs_types>();
+  test_valid_types<test_acos_types>();
+  test_valid_types<test_asin_types>();
+  test_valid_types<test_atan_types>();
+  test_valid_types<test_acosh_types>();
+  test_valid_types<test_asinh_types>();
+  test_valid_types<test_atanh_types>();
+  test_valid_types<test_conj_types>();
+  test_valid_types<test_cos_types>();
+  test_valid_types<test_cosh_types>();
+  test_valid_types<test_exp_types>();
+  test_valid_types<test_log_types>();
+  test_valid_types<test_log10_types>();
+  test_valid_types<test_proj_types>();
+  test_valid_types<test_sin_types>();
+  test_valid_types<test_sinh_types>();
+  test_valid_types<test_sqrt_types>();
+  test_valid_types<test_tan_types>();
+  test_valid_types<test_tanh_types>();
+
+  // Check math function types
+  test_valid_types<test_add_types>();
+  test_valid_types<test_sub_types>();
+  test_valid_types<test_mul_types>();
+  test_valid_types<test_div_types>();
+
+  // Check logic operator types
+  test_valid_types<test_equal_types>();
+  test_valid_types<test_not_equal_types>();
+
+  // Check special function types
+  test_valid_types<test_polar_types>();
+  test_valid_types<test_pow_types>();
+
+  return 0;
+}

From 98eb062bb127f1f770393dbebaf5d404c05c6c90 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Tue, 14 Mar 2023 15:16:22 +0100
Subject: [PATCH 03/39] [SYCL][Complex] fix typo in complex's tests

---
 sycl/test/extensions/test_complex.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/sycl/test/extensions/test_complex.cpp b/sycl/test/extensions/test_complex.cpp
index 60b466901e0d8..28e0c3e89fef6 100644
--- a/sycl/test/extensions/test_complex.cpp
+++ b/sycl/test/extensions/test_complex.cpp
@@ -34,7 +34,7 @@ TEST_MATH_OP_TYPE(add, +)
 TEST_MATH_OP_TYPE(sub, -)
 TEST_MATH_OP_TYPE(mul, *)
 TEST_MATH_OP_TYPE(div, /)
-#undef TEST_MATH_FUNC_TYPE
+#undef TEST_MATH_OP_TYPE
 
 // Check operations return correct types
 void check_math_operator_types() {
@@ -100,7 +100,6 @@ template <typename T> struct test_pow_types {
 
 // Check functions return correct types
 void check_math_function_types() {
-
   test_valid_types<test_abs_types>();
   test_valid_types<test_acos_types>();
   test_valid_types<test_asin_types>();

From 56a9dddb15a635c1d1d30c83a2823a6234e15ca0 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Tue, 28 Mar 2023 15:12:29 +0200
Subject: [PATCH 04/39] Add helper functions for marray complex testing

---
 sycl/test-e2e/Complex/sycl_complex_helper.hpp | 36 +++++++++++++++++--
 1 file changed, 34 insertions(+), 2 deletions(-)

diff --git a/sycl/test-e2e/Complex/sycl_complex_helper.hpp b/sycl/test-e2e/Complex/sycl_complex_helper.hpp
index de4cc1813abf4..4b018fcd0dbbd 100644
--- a/sycl/test-e2e/Complex/sycl_complex_helper.hpp
+++ b/sycl/test-e2e/Complex/sycl_complex_helper.hpp
@@ -33,7 +33,8 @@ template <> const char *get_typename<double>() { return "double"; }
 template <> const char *get_typename<float>() { return "float"; }
 template <> const char *get_typename<sycl::half>() { return "sycl::half"; }
 
-// Helper to test each complex specilization
+/// Helper to test each complex specilization
+
 // Overload for cplx_test_cases
 template <template <typename> typename action, typename... argsT>
 bool test_valid_types(sycl::queue &Q, argsT... args) {
@@ -195,8 +196,17 @@ template <> auto constexpr init_deci(sycl::half re) {
   return static_cast<float>(re);
 }
 
-// Helper for comparing SyclCPLX and standard c++ results
+template <typename Tout, typename Tin, std::size_t NumElements>
+auto constexpr convert_marray(sycl::marray<std::complex<Tin>, NumElements> c) {
+  sycl::marray<std::complex<Tout>, NumElements> rtn;
+  for (std::size_t i = 0; i < NumElements; ++i)
+    rtn[i] = c[i];
+  return rtn;
+}
+
+/// Helper for comparing SyclCPLX and standard c++ results
 
+// Complex overloads
 template <typename T>
 bool check_results(experimental::complex<T> output, std::complex<T> reference,
                    bool is_device) {
@@ -210,7 +220,19 @@ bool check_results(experimental::complex<T> output, std::complex<T> reference,
   }
   return true;
 }
+template <typename T, std::size_t NumElements>
+bool check_results(sycl::marray<experimental::complex<T>, NumElements> output,
+                   sycl::marray<std::complex<T>, NumElements> reference,
+                   bool is_device) {
+  for (std::size_t i = 0; i < NumElements; ++i) {
+    if (!check_results(output[i], reference[i], is_device)) {
+      return false;
+    }
+  }
+  return true;
+}
 
+// Scalar overloads
 template <typename T>
 bool check_results(T output, T reference, bool is_device) {
   if (!almost_equal_scalar(output, reference, SYCL_CPLX_TOL_ULP)) {
@@ -223,3 +245,13 @@ bool check_results(T output, T reference, bool is_device) {
   }
   return true;
 }
+template <typename T, std::size_t NumElements>
+bool check_results(sycl::marray<T, NumElements> output,
+                   sycl::marray<T, NumElements> reference, bool is_device) {
+  for (std::size_t i = 0; i < NumElements; ++i) {
+    if (!check_results(output[i], reference[i], is_device)) {
+      return false;
+    }
+  }
+  return true;
+}

From ab1d88737b00b7e36936eaffaab4c90cc84146af Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Tue, 28 Mar 2023 15:12:59 +0200
Subject: [PATCH 05/39] Fix warning messages

---
 sycl/test-e2e/Complex/sycl_complex_math_test_cases.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sycl/test-e2e/Complex/sycl_complex_math_test_cases.hpp b/sycl/test-e2e/Complex/sycl_complex_math_test_cases.hpp
index 4cfd29a2e9e8c..2318f51950c61 100644
--- a/sycl/test-e2e/Complex/sycl_complex_math_test_cases.hpp
+++ b/sycl/test-e2e/Complex/sycl_complex_math_test_cases.hpp
@@ -58,8 +58,8 @@ template <template <typename> typename test_struct> struct cplx_test_cases {
     }
 
     for (auto &test_tuple : comp_test_values) {
-      test_passes &= test_valid_types<test_struct>(Q, get<0>(test_tuple),
-                                                   get<1>(test_tuple),
+      test_passes &= test_valid_types<test_struct>(Q, std::get<0>(test_tuple),
+                                                   std::get<1>(test_tuple),
                                                    /*use_ref*/ true);
     }
 

From cbec286482f8bcae5f9220aff29eb4c6d3b273da Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Tue, 28 Mar 2023 15:13:30 +0200
Subject: [PATCH 06/39] Add test cases for marray complex

---
 .../sycl_complex_marray_test_cases.hpp        | 321 ++++++++++++++++++
 1 file changed, 321 insertions(+)
 create mode 100644 sycl/test-e2e/Complex/sycl_complex_marray_test_cases.hpp

diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_test_cases.hpp b/sycl/test-e2e/Complex/sycl_complex_marray_test_cases.hpp
new file mode 100644
index 0000000000000..43436d024bc70
--- /dev/null
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_test_cases.hpp
@@ -0,0 +1,321 @@
+#include <iostream>
+#include <tuple>
+#include <vector>
+
+#include "sycl_complex_helper.hpp"
+
+#define DEFAULT_TEST_CASE_SIZE 47
+#define POLAR_TEST_CASE_SIZE 9
+#define GETTERS_TEST_CASE_SIZE 8
+
+////////////////////////////////////////////////////////////////////////////////
+/// FORWARD DECLARATION OF TESTS
+////////////////////////////////////////////////////////////////////////////////
+
+// Maths
+template <typename T> struct test_abs;
+template <typename T> struct test_arg;
+template <typename T> struct test_norm;
+
+template <typename T> struct test_acos;
+template <typename T> struct test_asin;
+template <typename T> struct test_atan;
+template <typename T> struct test_acosh;
+template <typename T> struct test_asinh;
+template <typename T> struct test_atanh;
+template <typename T> struct test_conj;
+template <typename T> struct test_cos;
+template <typename T> struct test_cosh;
+template <typename T> struct test_exp;
+template <typename T> struct test_log;
+template <typename T> struct test_log10;
+template <typename T> struct test_proj;
+template <typename T> struct test_sin;
+template <typename T> struct test_sinh;
+template <typename T> struct test_sqrt;
+template <typename T> struct test_tan;
+template <typename T> struct test_tanh;
+
+template <typename T> struct test_polar;
+
+template <typename T> struct test_pow_cplx_cplx;
+template <typename T> struct test_pow_cplx_deci;
+template <typename T> struct test_pow_deci_cplx;
+
+// Operators
+template <typename T> struct test_add;
+template <typename T> struct test_sub;
+template <typename T> struct test_mul;
+template <typename T> struct test_div;
+
+template <typename T> struct test_assign_add;
+template <typename T> struct test_assign_sub;
+template <typename T> struct test_assign_mul;
+template <typename T> struct test_assign_div;
+
+template <typename T> struct test_unary_add;
+template <typename T> struct test_unary_sub;
+
+// Getters
+template <typename T> struct test_real;
+template <typename T> struct test_imag;
+
+////////////////////////////////////////////////////////////////////////////////
+/// TEST CASES COMPLEX
+////////////////////////////////////////////////////////////////////////////////
+
+// Driver
+template <template <typename> typename test_struct>
+struct marray_cplx_test_cases {
+  static std::vector<cmplx<double>> std_test_values;
+  static std::tuple<std::vector<cmplx<double>>, std::vector<cmplx<double>>>
+      comp_test_values;
+
+  static const char *test_name;
+
+  bool operator()(sycl::queue &Q) {
+    bool test_passes = true;
+
+    if (!std_test_values.empty()) {
+      test_passes &= test_valid_types<test_struct>(Q, std_test_values);
+    }
+
+    const std::vector<cmplx<double>> init = std::get<0>(comp_test_values);
+    const std::vector<cmplx<double>> ref = std::get<1>(comp_test_values);
+
+    if (!init.empty() && !ref.empty()) {
+      test_passes &=
+          test_valid_types<test_struct>(Q, init, ref, /*use_ref*/ true);
+    }
+
+    if (!test_passes)
+      std::cerr << test_name << " failed\n";
+
+    return test_passes;
+  }
+};
+
+// Default values
+template <template <typename> typename test_struct>
+std::vector<cmplx<double>>
+    marray_cplx_test_cases<test_struct>::std_test_values = {
+        cmplx<double>(0, 1),           cmplx<double>(0, -1),
+        cmplx<double>(0, 0.5),         cmplx<double>(0, -0.5),
+        cmplx<double>(0, 0),           cmplx<double>(0, INFINITYd),
+        cmplx<double>(0, NANd),
+
+        cmplx<double>(1, 1),           cmplx<double>(1, -1),
+        cmplx<double>(1, 0.5),         cmplx<double>(1, -0.5),
+        cmplx<double>(1, 0),           cmplx<double>(1, INFINITYd),
+        cmplx<double>(1, NANd),
+
+        cmplx<double>(-1, 1),          cmplx<double>(-1, -1),
+        cmplx<double>(-1, 0.5),        cmplx<double>(-1, -0.5),
+        cmplx<double>(-1, 0),          cmplx<double>(-1, INFINITYd),
+        cmplx<double>(-1, NANd),
+
+        cmplx<double>(0.5, 1),         cmplx<double>(0.5, -1),
+        cmplx<double>(0.5, 0.5),       cmplx<double>(0.5, -0.5),
+        cmplx<double>(0.5, 0),         cmplx<double>(0.5, INFINITYd),
+        cmplx<double>(0.5, NANd),
+
+        cmplx<double>(-0.5, 1),        cmplx<double>(-0.5, -1),
+        cmplx<double>(-0.5, 0.5),      cmplx<double>(-0.5, -0.5),
+        cmplx<double>(-0.5, 0),        cmplx<double>(-0.5, INFINITYd),
+        cmplx<double>(-0.5, NANd),
+
+        cmplx<double>(INFINITYd, 1),   cmplx<double>(INFINITYd, -1),
+        cmplx<double>(INFINITYd, 0.5), cmplx<double>(INFINITYd, -0.5),
+        cmplx<double>(INFINITYd, 0),   cmplx<double>(INFINITYd, INFINITYd),
+
+        cmplx<double>(NANd, 1),        cmplx<double>(NANd, -1),
+        cmplx<double>(NANd, 0.5),      cmplx<double>(NANd, -0.5),
+        cmplx<double>(NANd, 0),        cmplx<double>(NANd, NANd),
+};
+template <template <typename> typename test_struct>
+std::tuple<std::vector<cmplx<double>>, std::vector<cmplx<double>>>
+    marray_cplx_test_cases<test_struct>::comp_test_values({}, {});
+
+/// Maths
+
+// test_abs
+template <>
+const char *marray_cplx_test_cases<test_abs>::test_name = "abs test";
+// test_arg
+template <>
+const char *marray_cplx_test_cases<test_arg>::test_name = "arg test";
+// test_norm
+template <>
+const char *marray_cplx_test_cases<test_norm>::test_name = "norm test";
+
+// test_acos
+template <>
+const char *marray_cplx_test_cases<test_acos>::test_name = "acos test";
+// test_asin
+template <>
+const char *marray_cplx_test_cases<test_asin>::test_name = "asin test";
+// test_atan
+template <>
+const char *marray_cplx_test_cases<test_atan>::test_name = "atan test";
+// test_acosh
+template <>
+const char *marray_cplx_test_cases<test_acosh>::test_name = "acos test";
+// test_asinh
+template <>
+const char *marray_cplx_test_cases<test_asinh>::test_name = "asinh test";
+// test_atanh
+template <>
+const char *marray_cplx_test_cases<test_atanh>::test_name = "atanh test";
+// test_conj
+template <>
+const char *marray_cplx_test_cases<test_conj>::test_name = "conj test";
+// test_cos
+template <>
+const char *marray_cplx_test_cases<test_cos>::test_name = "cos test";
+// test_cosh
+template <>
+const char *marray_cplx_test_cases<test_cosh>::test_name = "cosh test";
+// test_exp
+template <>
+const char *marray_cplx_test_cases<test_exp>::test_name = "exp test";
+// test_log
+template <>
+const char *marray_cplx_test_cases<test_log>::test_name = "log test";
+// test_log10
+template <>
+const char *marray_cplx_test_cases<test_log10>::test_name = "log10 test";
+// test_proj
+template <>
+const char *marray_cplx_test_cases<test_proj>::test_name = "proj test";
+// test_sin
+template <>
+const char *marray_cplx_test_cases<test_sin>::test_name = "sin test";
+// test_sinh
+template <>
+const char *marray_cplx_test_cases<test_sinh>::test_name = "sinh test";
+// test_sqrt
+template <>
+const char *marray_cplx_test_cases<test_sqrt>::test_name = "sqrt test";
+// test_tan
+template <>
+const char *marray_cplx_test_cases<test_tan>::test_name = "tan test";
+// test_tanh
+template <>
+const char *marray_cplx_test_cases<test_tanh>::test_name = "tanh test";
+
+// test_polar
+template <>
+std::vector<cmplx<double>> marray_cplx_test_cases<test_polar>::std_test_values =
+    {
+        cmplx<double>(0, 1),   cmplx<double>(0, 0.5),   cmplx<double>(0, 0),
+
+        cmplx<double>(1, 1),   cmplx<double>(1, 0.5),   cmplx<double>(1, 0),
+
+        cmplx<double>(0.5, 1), cmplx<double>(0.5, 0.5), cmplx<double>(0.5, 0),
+};
+template <>
+const char *marray_cplx_test_cases<test_polar>::test_name = "polar test";
+
+// test_pow_cplx_cplx
+template <>
+const char *marray_cplx_test_cases<test_pow_cplx_cplx>::test_name =
+    "pow cplx cplx test";
+// test_pow_cplx_deci
+template <>
+const char *marray_cplx_test_cases<test_pow_cplx_deci>::test_name =
+    "pow cplx deci test";
+// test_pow_deci_cplx
+template <>
+const char *marray_cplx_test_cases<test_pow_deci_cplx>::test_name =
+    "pow deci cplx test";
+
+/// Operators
+
+// test_add
+template <>
+const char *marray_cplx_test_cases<test_add>::test_name = "add test";
+// test_sub
+template <>
+const char *marray_cplx_test_cases<test_sub>::test_name = "sub test";
+// test_mul
+template <>
+const char *marray_cplx_test_cases<test_mul>::test_name = "mul test";
+// test_div
+template <>
+const char *marray_cplx_test_cases<test_div>::test_name = "div test";
+
+// test_assign_add
+template <>
+const char *marray_cplx_test_cases<test_assign_add>::test_name =
+    "assign add test";
+// test_assign_sub
+template <>
+const char *marray_cplx_test_cases<test_assign_sub>::test_name =
+    "assign sub test";
+// test_assign_mul
+template <>
+const char *marray_cplx_test_cases<test_assign_mul>::test_name =
+    "assign mul test";
+// test_assign_div
+template <>
+const char *marray_cplx_test_cases<test_assign_div>::test_name =
+    "assign div test";
+
+// test_unary_add
+template <>
+const char *marray_cplx_test_cases<test_unary_add>::test_name =
+    "unary add test";
+// test_unary_sub
+template <>
+const char *marray_cplx_test_cases<test_unary_sub>::test_name =
+    "unary sub test";
+
+////////////////////////////////////////////////////////////////////////////////
+/// TEST CASES SCALAR
+////////////////////////////////////////////////////////////////////////////////
+
+// Driver
+template <template <typename> typename test_struct>
+struct marray_scalar_test_cases {
+  static std::vector<double> std_test_values;
+  static std::tuple<std::vector<double>, std::vector<double>> comp_test_values;
+
+  static const char *test_name;
+
+  bool operator()(sycl::queue &Q) {
+    bool test_passes = true;
+
+    if (!std_test_values.empty()) {
+      test_passes &= test_valid_types<test_struct>(Q, std_test_values);
+    }
+
+    const std::vector<double> init = std::get<0>(comp_test_values);
+    const std::vector<double> ref = std::get<1>(comp_test_values);
+
+    if (!init.empty() && !ref.empty()) {
+      test_passes &=
+          test_valid_types<test_struct>(Q, init, ref, /*use_ref*/ true);
+    }
+
+    if (!test_passes)
+      std::cerr << test_name << " failed\n";
+
+    return test_passes;
+  }
+};
+
+// Default values
+template <template <typename> typename test_struct>
+std::vector<double> marray_scalar_test_cases<test_struct>::std_test_values = {
+    0, 0.5, 1, -0, -0.5, -1, INFINITYd, NANd,
+};
+template <template <typename> typename test_struct>
+std::tuple<std::vector<double>, std::vector<double>>
+    marray_scalar_test_cases<test_struct>::comp_test_values({}, {});
+
+// test_real
+template <>
+const char *marray_scalar_test_cases<test_real>::test_name = "real test";
+// test_imag
+template <>
+const char *marray_scalar_test_cases<test_imag>::test_name = "imag test";

From 5a5f647a062c811a19030757f741ca4f821842cb Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Tue, 28 Mar 2023 15:13:51 +0200
Subject: [PATCH 07/39] Add marray complex getter tests

---
 .../sycl_complex_marray_getters_test.cpp      | 94 +++++++++++++++++++
 1 file changed, 94 insertions(+)
 create mode 100644 sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp

diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
new file mode 100644
index 0000000000000..158f0e4e9ba4b
--- /dev/null
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
@@ -0,0 +1,94 @@
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsycl-device-code-split=per_kernel %s -o %t.out
+// RUN: %CPU_RUN_PLACEHOLDER %t.out
+// RUN: %GPU_RUN_PLACEHOLDER %t.out
+// RUN: %ACC_RUN_PLACEHOLDER %t.out
+
+#include "sycl_complex_marray_test_cases.hpp"
+
+template <typename T> struct test_real {
+  bool operator()(sycl::queue &Q, const std::vector<double> &init,
+                  const std::vector<double> &ref = {}, bool use_ref = false) {
+    bool pass = true;
+
+    /* std::complex test cases */
+    sycl::marray<T, GETTERS_TEST_CASE_SIZE> std_in;
+    /* sycl::complex test cases */
+    sycl::marray<experimental::complex<T>, GETTERS_TEST_CASE_SIZE> cplx_in;
+
+    for (std::size_t i = 0; i < GETTERS_TEST_CASE_SIZE; ++i) {
+      std_in[i] = static_cast<T>(init[i]);
+      cplx_in[i] =
+          experimental::complex<T>{static_cast<T>(init[i]), static_cast<T>(0)};
+    }
+
+    auto *cplx_out =
+        sycl::malloc_shared<sycl::marray<T, GETTERS_TEST_CASE_SIZE>>(1, Q);
+
+    /* Check cplx::complex output from device */
+    Q.single_task([=]() { *cplx_out = cplx_in.real(); }).wait();
+    pass &= check_results(*cplx_out, std_in, /*is_device*/ true);
+
+    /* Check cplx::complex output from host */
+    *cplx_out = cplx_in.real();
+    pass &= check_results(*cplx_out, std_in, /*is_device*/ false);
+
+    sycl::free(cplx_out, Q);
+
+    return pass;
+  }
+};
+
+template <typename T> struct test_imag {
+  bool operator()(sycl::queue &Q, const std::vector<double> &init,
+                  const std::vector<double> &ref = {}, bool use_ref = false) {
+    bool pass = true;
+
+    /* std::complex test cases */
+    sycl::marray<T, GETTERS_TEST_CASE_SIZE> std_in;
+    /* sycl::complex test cases */
+    sycl::marray<experimental::complex<T>, GETTERS_TEST_CASE_SIZE> cplx_in;
+
+    for (std::size_t i = 0; i < GETTERS_TEST_CASE_SIZE; ++i) {
+      std_in[i] = static_cast<T>(init[i]);
+      cplx_in[i] =
+          experimental::complex<T>{static_cast<T>(0), static_cast<T>(init[i])};
+    }
+
+    auto *cplx_out =
+        sycl::malloc_shared<sycl::marray<T, GETTERS_TEST_CASE_SIZE>>(1, Q);
+
+    /* Check cplx::complex output from device */
+    Q.single_task([=]() { *cplx_out = cplx_in.imag(); }).wait();
+    pass &= check_results(*cplx_out, std_in, /*is_device*/ true);
+
+    /* Check cplx::complex output from host */
+    *cplx_out = cplx_in.imag();
+    pass &= check_results(*cplx_out, std_in, /*is_device*/ false);
+
+    sycl::free(cplx_out, Q);
+
+    return pass;
+  }
+};
+
+int main() {
+  sycl::queue Q;
+
+  bool test_passes = true;
+
+  /* Test real getter */
+
+  {
+    marray_scalar_test_cases<test_real> test;
+    test_passes &= test(Q);
+  }
+
+  /* Test imag getter */
+
+  {
+    marray_scalar_test_cases<test_imag> test;
+    test_passes &= test(Q);
+  }
+
+  return !test_passes;
+}

From 7db90aabbbfd497709508567df2a77f9ef98cd9a Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Tue, 28 Mar 2023 15:14:05 +0200
Subject: [PATCH 08/39] Add marray complex math tests

---
 .../Complex/sycl_complex_marray_math_test.cpp | 486 ++++++++++++++++++
 1 file changed, 486 insertions(+)
 create mode 100644 sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp

diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
new file mode 100644
index 0000000000000..3c19bacfc569d
--- /dev/null
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
@@ -0,0 +1,486 @@
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsycl-device-code-split=per_kernel %s -o %t.out
+// RUN: %CPU_RUN_PLACEHOLDER %t.out
+// RUN: %GPU_RUN_PLACEHOLDER %t.out
+// RUN: %ACC_RUN_PLACEHOLDER %t.out
+
+#include "sycl_complex_marray_test_cases.hpp"
+
+#define TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(func_name)                           \
+  template <typename T> struct test_##func_name {                              \
+    bool operator()(sycl::queue &Q, const std::vector<cmplx<double>> &init,    \
+                    const std::vector<cmplx<double>> &ref = {},                \
+                    bool use_ref = false) {                                    \
+      bool pass = true;                                                        \
+      using X = typename std::conditional<std::is_same<T, sycl::half>::value,  \
+                                          float, T>::type;                     \
+                                                                               \
+      /* std::complex test cases */                                            \
+      sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_in;            \
+      /* sycl::complex test cases */                                           \
+      sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE> cplx_in;  \
+                                                                               \
+      for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {               \
+        std_in[i] = init_std_complex<T>(init[i].re, init[i].im);               \
+        cplx_in[i] = experimental::complex<T>{static_cast<T>(init[i].re),      \
+                                              static_cast<T>(init[i].im)};     \
+      }                                                                        \
+                                                                               \
+      sycl::marray<std::complex<T>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
+      auto *cplx_out = sycl::malloc_shared<                                    \
+          sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1,   \
+                                                                          Q);  \
+                                                                               \
+      /* Get std::complex output */                                            \
+      if (use_ref) {                                                           \
+        for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {             \
+          T re = static_cast<T>(ref[i].re);                                    \
+          T im = static_cast<T>(ref[i].im);                                    \
+          std_out[i] = std::complex<T>{re, im};                                \
+        }                                                                      \
+      } else {                                                                 \
+        for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {             \
+          std_out[i] = std::func_name(std_in[i]);                              \
+        }                                                                      \
+      }                                                                        \
+                                                                               \
+      /* Check cplx::complex output from device */                             \
+      Q.single_task([=]() {                                                    \
+         *cplx_out = experimental::func_name(cplx_in);                         \
+       }).wait();                                                              \
+      pass &= check_results(*cplx_out, std_out, /*is_device*/ true);           \
+                                                                               \
+      /* Check cplx::complex output from host */                               \
+      *cplx_out = experimental::func_name(cplx_in);                            \
+      pass &= check_results(*cplx_out, std_out, /*is_device*/ false);          \
+                                                                               \
+      sycl::free(cplx_out, Q);                                                 \
+                                                                               \
+      return pass;                                                             \
+    }                                                                          \
+  };
+
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(acos)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(asin)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(atan)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(acosh)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(asinh)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(atanh)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(conj)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(cos)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(cosh)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(exp)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(log)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(log10)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(proj)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(sin)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(sinh)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(sqrt)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(tan)
+TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(tanh)
+
+#undef TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT
+
+#define TEST_MATH_MARRAY_CPLX_IN_DECI_OUT(func_name)                           \
+  template <typename T> struct test_##func_name {                              \
+    bool operator()(sycl::queue &Q, const std::vector<cmplx<double>> &init,    \
+                    const std::vector<cmplx<double>> &ref = {},                \
+                    bool use_ref = false) {                                    \
+      bool pass = true;                                                        \
+                                                                               \
+      using X = typename std::conditional<std::is_same<T, sycl::half>::value,  \
+                                          float, T>::type;                     \
+                                                                               \
+      /* std::complex test cases */                                            \
+      sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_in;            \
+      /* sycl::complex test cases */                                           \
+      sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE> cplx_in;  \
+                                                                               \
+      for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {               \
+        std_in[i] = init_std_complex<T>(init[i].re, init[i].im);               \
+        cplx_in[i] = experimental::complex<T>{static_cast<T>(init[i].re),      \
+                                              static_cast<T>(init[i].im)};     \
+      }                                                                        \
+                                                                               \
+      sycl::marray<T, DEFAULT_TEST_CASE_SIZE> std_out{};                       \
+      auto *cplx_out =                                                         \
+          sycl::malloc_shared<sycl::marray<T, DEFAULT_TEST_CASE_SIZE>>(1, Q);  \
+                                                                               \
+      /* Get std::complex output */                                            \
+      if (use_ref) {                                                           \
+        for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {             \
+          std_out[i] = static_cast<T>(ref[i].re);                              \
+        }                                                                      \
+      } else {                                                                 \
+        for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {             \
+          std_out[i] = std::func_name(std_in[i]);                              \
+        }                                                                      \
+      }                                                                        \
+                                                                               \
+      /* Check cplx::complex output from device */                             \
+      Q.single_task([=]() {                                                    \
+         *cplx_out = experimental::func_name(cplx_in);                         \
+       }).wait();                                                              \
+      pass &= check_results(*cplx_out, std_out, /*is_device*/ true);           \
+                                                                               \
+      /* Check cplx::complex output from host */                               \
+      *cplx_out = experimental::func_name(cplx_in);                            \
+      pass &= check_results(*cplx_out, std_out, /*is_device*/ false);          \
+                                                                               \
+      sycl::free(cplx_out, Q);                                                 \
+                                                                               \
+      return pass;                                                             \
+    }                                                                          \
+  };
+
+TEST_MATH_MARRAY_CPLX_IN_DECI_OUT(abs)
+TEST_MATH_MARRAY_CPLX_IN_DECI_OUT(arg)
+TEST_MATH_MARRAY_CPLX_IN_DECI_OUT(norm)
+
+#undef TEST_MARRAY_CPLX_IN_DECI_OUT
+
+template <typename T> struct test_polar {
+  bool operator()(sycl::queue &Q, const std::vector<cmplx<double>> &init,
+                  const std::vector<cmplx<double>> &ref = {},
+                  bool use_ref = false) {
+    bool pass = true;
+
+    /* test cases */
+    sycl::marray<T, POLAR_TEST_CASE_SIZE> rho;
+    sycl::marray<T, POLAR_TEST_CASE_SIZE> theta;
+    for (std::size_t i = 0; i < POLAR_TEST_CASE_SIZE; ++i) {
+      rho[i] = static_cast<T>(init[i].re);
+      theta[i] = static_cast<T>(init[i].im);
+    }
+
+    sycl::marray<std::complex<T>, POLAR_TEST_CASE_SIZE> std_out{};
+    auto *cplx_out = sycl::malloc_shared<
+        sycl::marray<experimental::complex<T>, POLAR_TEST_CASE_SIZE>>(1, Q);
+
+    /* Get std::complex output */
+    if (use_ref) {
+      for (std::size_t i = 0; i < POLAR_TEST_CASE_SIZE; ++i) {
+        T re = static_cast<T>(ref[i].re);
+        T im = static_cast<T>(ref[i].im);
+        std_out[i] = std::complex<T>{re, im};
+      }
+    } else {
+      for (std::size_t i = 0; i < POLAR_TEST_CASE_SIZE; ++i) {
+        std_out[i] = std::polar(rho[i], theta[i]);
+      }
+    }
+
+    /* Check cplx::complex output from device */
+    Q.single_task([=]() {
+       *cplx_out = experimental::polar(rho, theta);
+     }).wait();
+    pass &= check_results(*cplx_out, std_out, /*is_device*/ true);
+
+    /* Check cplx::complex output from host */
+    *cplx_out = experimental::polar(rho, theta);
+    pass &= check_results(*cplx_out, std_out, /*is_device*/ false);
+
+    sycl::free(cplx_out, Q);
+
+    return pass;
+  }
+};
+
+template <typename T> struct test_pow_cplx_cplx {
+  bool operator()(sycl::queue &Q, const std::vector<cmplx<double>> &init,
+                  const std::vector<cmplx<double>> &ref = {},
+                  bool use_ref = false) {
+    bool pass = true;
+
+    using X = typename std::conditional<std::is_same<T, sycl::half>::value,
+                                        float, T>::type;
+
+    /* std::complex test cases */
+    sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_in;
+    /* sycl::complex test cases */
+    sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE> cplx_in;
+
+    for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {
+      std_in[i] = init_std_complex<T>(init[i].re, init[i].im);
+      cplx_in[i] = experimental::complex<T>{static_cast<T>(init[i].re),
+                                            static_cast<T>(init[i].im)};
+    }
+
+    sycl::marray<std::complex<T>, DEFAULT_TEST_CASE_SIZE> std_out{};
+    auto *cplx_out = sycl::malloc_shared<
+        sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1, Q);
+
+    /* Get std::complex output */
+    if (use_ref) {
+      for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {
+        T re = static_cast<T>(ref[i].re);
+        T im = static_cast<T>(ref[i].im);
+        std_out[i] = std::complex<T>{re, im};
+      }
+    } else {
+      for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {
+        std_out[i] = std::pow(std_in[i], std_in[i]);
+      }
+    }
+
+    /* Check cplx::complex output from device */
+    Q.single_task([=]() {
+       *cplx_out = experimental::pow(cplx_in, cplx_in);
+     }).wait();
+    pass &= check_results(*cplx_out, std_out, /*is_device*/ true);
+
+    /* Check cplx::complex output from host */
+    *cplx_out = experimental::pow(cplx_in, cplx_in);
+    pass &= check_results(*cplx_out, std_out, /*is_device*/ false);
+
+    sycl::free(cplx_out, Q);
+
+    return pass;
+  }
+};
+
+template <typename T> struct test_pow_cplx_deci {
+  bool operator()(sycl::queue &Q, const std::vector<cmplx<double>> &init,
+                  const std::vector<cmplx<double>> &ref = {},
+                  bool use_ref = false) {
+    bool pass = true;
+
+    using X = typename std::conditional<std::is_same<T, sycl::half>::value,
+                                        float, T>::type;
+
+    /* std::complex test cases */
+    sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_in;
+    /* sycl::complex test cases */
+    sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE> cplx_in;
+
+    for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {
+      std_in[i] = init_std_complex<T>(init[i].re, init[i].im);
+      cplx_in[i] = experimental::complex<T>{static_cast<T>(init[i].re),
+                                            static_cast<T>(init[i].im)};
+    }
+
+    sycl::marray<std::complex<T>, DEFAULT_TEST_CASE_SIZE> std_out{};
+    auto *cplx_out = sycl::malloc_shared<
+        sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1, Q);
+
+    /* Get std::complex output */
+    if (use_ref) {
+      for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {
+        T re = static_cast<T>(ref[i].re);
+        T im = static_cast<T>(ref[i].im);
+        std_out[i] = std::complex<T>{re, im};
+      }
+    } else {
+      for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {
+        std_out[i] = std::pow(std_in[i], std_in[i].real());
+      }
+    }
+
+    /* Check cplx::complex output from device */
+    Q.single_task([=]() {
+       *cplx_out = experimental::pow(cplx_in, cplx_in.real());
+     }).wait();
+    pass &= check_results(*cplx_out, std_out, /*is_device*/ true);
+
+    /* Check cplx::complex output from host */
+    *cplx_out = experimental::pow(cplx_in, cplx_in.real());
+    pass &= check_results(*cplx_out, std_out, /*is_device*/ false);
+
+    sycl::free(cplx_out, Q);
+
+    return pass;
+  }
+};
+
+template <typename T> struct test_pow_deci_cplx {
+  bool operator()(sycl::queue &Q, const std::vector<cmplx<double>> &init,
+                  const std::vector<cmplx<double>> &ref = {},
+                  bool use_ref = false) {
+    bool pass = true;
+
+    using X = typename std::conditional<std::is_same<T, sycl::half>::value,
+                                        float, T>::type;
+
+    /* std::complex test cases */
+    sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_in;
+    /* sycl::complex test cases */
+    sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE> cplx_in;
+
+    for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {
+      std_in[i] = init_std_complex<T>(init[i].re, init[i].im);
+      cplx_in[i] = experimental::complex<T>{static_cast<T>(init[i].re),
+                                            static_cast<T>(init[i].im)};
+    }
+
+    sycl::marray<std::complex<T>, DEFAULT_TEST_CASE_SIZE> std_out{};
+    auto *cplx_out = sycl::malloc_shared<
+        sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1, Q);
+
+    /* Get std::complex output */
+    if (use_ref) {
+      for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {
+        T re = static_cast<T>(ref[i].re);
+        T im = static_cast<T>(ref[i].im);
+        std_out[i] = std::complex<T>{re, im};
+      }
+    } else {
+      for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {
+        std_out[i] = std::pow(std_in[i].real(), std_in[i]);
+      }
+    }
+
+    /* Check cplx::complex output from device */
+    Q.single_task([=]() {
+       *cplx_out = experimental::pow(cplx_in.real(), cplx_in);
+     }).wait();
+    pass &= check_results(*cplx_out, std_out, /*is_device*/ true);
+
+    /* Check cplx::complex output from host */
+    *cplx_out = experimental::pow(cplx_in.real(), cplx_in);
+    pass &= check_results(*cplx_out, std_out, /*is_device*/ false);
+
+    sycl::free(cplx_out, Q);
+
+    return pass;
+  }
+};
+
+int main() {
+  sycl::queue Q;
+
+  bool test_passes = true;
+
+  /* Test complex in, complex out functions */
+
+  {
+    marray_cplx_test_cases<test_acos> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_asin> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_atan> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_acosh> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_asinh> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_atanh> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_conj> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_cos> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_cosh> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_exp> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_log> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_log10> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_proj> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_sin> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_sinh> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_sqrt> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_tan> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_tanh> test;
+    test_passes &= test(Q);
+  }
+
+  /* Test complex in, decimal out functions */
+
+  {
+    marray_cplx_test_cases<test_abs> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_arg> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_norm> test;
+    test_passes &= test(Q);
+  }
+
+  /* Test polar function */
+
+  {
+    marray_cplx_test_cases<test_polar> test;
+    test_passes &= test(Q);
+  }
+
+  /* Test pow function */
+
+  {
+    marray_cplx_test_cases<test_pow_cplx_cplx> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_pow_cplx_deci> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_pow_deci_cplx> test;
+    test_passes &= test(Q);
+  }
+
+  return !test_passes;
+}

From 0a2b793857c7667ec5b08a0a2cec1f8cd84fc3c3 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Tue, 28 Mar 2023 15:14:20 +0200
Subject: [PATCH 09/39] Add marray complex operator tests

---
 .../sycl_complex_marray_operator_test.cpp     | 253 ++++++++++++++++++
 1 file changed, 253 insertions(+)
 create mode 100644 sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp

diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp
new file mode 100644
index 0000000000000..c7dca3502e9f6
--- /dev/null
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp
@@ -0,0 +1,253 @@
+// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsycl-device-code-split=per_kernel %s -o %t.out
+// RUN: %CPU_RUN_PLACEHOLDER %t.out
+// RUN: %GPU_RUN_PLACEHOLDER %t.out
+// RUN: %ACC_RUN_PLACEHOLDER %t.out
+
+#include "sycl_complex_marray_test_cases.hpp"
+
+#define TEST_BASIC_OPERATOR(op_name, op)                                       \
+  template <typename T> struct test_##op_name {                                \
+    bool operator()(sycl::queue &Q, const std::vector<cmplx<double>> &init,    \
+                    const std::vector<cmplx<double>> &ref = {},                \
+                    bool use_ref = false) {                                    \
+      bool pass = true;                                                        \
+                                                                               \
+      using X = typename std::conditional<std::is_same<T, sycl::half>::value,  \
+                                          float, T>::type;                     \
+                                                                               \
+      /* std::complex test cases */                                            \
+      sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_in;            \
+      /* sycl::complex test cases */                                           \
+      sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE> cplx_in;  \
+                                                                               \
+      for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {               \
+        std_in[i] = init_std_complex<T>(init[i].re, init[i].im);               \
+        cplx_in[i] = experimental::complex<T>{static_cast<T>(init[i].re),      \
+                                              static_cast<T>(init[i].im)};     \
+      }                                                                        \
+                                                                               \
+      sycl::marray<std::complex<T>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
+      auto *cplx_out = sycl::malloc_shared<                                    \
+          sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1,   \
+                                                                          Q);  \
+                                                                               \
+      /* Get std::complex output */                                            \
+      if (use_ref) {                                                           \
+        for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {             \
+          T re = static_cast<T>(ref[i].re);                                    \
+          T im = static_cast<T>(ref[i].im);                                    \
+          std_out[i] = std::complex<T>{re, im};                                \
+        }                                                                      \
+      } else {                                                                 \
+        for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {             \
+          std_out[i] = std_in[i] op std_in[i];                                 \
+        }                                                                      \
+      }                                                                        \
+                                                                               \
+      /* Check cplx::complex output from device */                             \
+      Q.single_task([=]() { *cplx_out = cplx_in op cplx_in; }).wait();         \
+      pass &= check_results(*cplx_out, std_out, /*is_device*/ true);           \
+                                                                               \
+      /* Check cplx::complex output from host */                               \
+      *cplx_out = cplx_in op cplx_in;                                          \
+      pass &= check_results(*cplx_out, std_out, /*is_device*/ false);          \
+                                                                               \
+      sycl::free(cplx_out, Q);                                                 \
+                                                                               \
+      return pass;                                                             \
+    }                                                                          \
+  };
+
+TEST_BASIC_OPERATOR(add, +)
+TEST_BASIC_OPERATOR(sub, -)
+TEST_BASIC_OPERATOR(mul, *)
+TEST_BASIC_OPERATOR(div, /)
+
+#undef TEST_BASIC_OPERATOR
+
+#define TEST_ASSIGN_OPERATOR(op_name, op)                                      \
+  template <typename T> struct test_##op_name {                                \
+    bool operator()(sycl::queue &Q, const std::vector<cmplx<double>> &init,    \
+                    const std::vector<cmplx<double>> &ref = {},                \
+                    bool use_ref = false) {                                    \
+      bool pass = true;                                                        \
+                                                                               \
+      using X = typename std::conditional<std::is_same<T, sycl::half>::value,  \
+                                          float, T>::type;                     \
+                                                                               \
+      /* std::complex test cases */                                            \
+      sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_in;            \
+      /* sycl::complex test cases */                                           \
+      sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE> cplx_in;  \
+                                                                               \
+      for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {               \
+        std_in[i] = init_std_complex<T>(init[i].re, init[i].im);               \
+        cplx_in[i] = experimental::complex<T>{static_cast<T>(init[i].re),      \
+                                              static_cast<T>(init[i].im)};     \
+      }                                                                        \
+                                                                               \
+      sycl::marray<std::complex<T>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
+      auto *cplx_out = sycl::malloc_shared<                                    \
+          sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1,   \
+                                                                          Q);  \
+                                                                               \
+      std_out = convert_marray<T, X>(std_in);                                  \
+      *cplx_out = cplx_in;                                                     \
+                                                                               \
+      /* Get std::complex output */                                            \
+      if (use_ref) {                                                           \
+        for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {             \
+          T re = static_cast<T>(ref[i].re);                                    \
+          T im = static_cast<T>(ref[i].im);                                    \
+          std_out[i] = std::complex<T>{re, im};                                \
+        }                                                                      \
+      } else {                                                                 \
+        for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {             \
+          std_out[i] op std_in[i];                                             \
+        }                                                                      \
+      }                                                                        \
+                                                                               \
+      /* Check cplx::complex output from device */                             \
+      Q.single_task([=]() { *cplx_out op cplx_in; }).wait();                   \
+      pass &= check_results(*cplx_out, std_out, /*is_device*/ true);           \
+                                                                               \
+      *cplx_out = cplx_in;                                                     \
+                                                                               \
+      /* Check cplx::complex output from host */                               \
+      *cplx_out op cplx_in;                                                    \
+      pass &= check_results(*cplx_out, std_out, /*is_device*/ false);          \
+                                                                               \
+      sycl::free(cplx_out, Q);                                                 \
+                                                                               \
+      return pass;                                                             \
+    }                                                                          \
+  };
+
+TEST_ASSIGN_OPERATOR(assign_add, +=)
+TEST_ASSIGN_OPERATOR(assign_sub, -=)
+TEST_ASSIGN_OPERATOR(assign_mul, *=)
+TEST_ASSIGN_OPERATOR(assign_div, /=)
+
+#undef TEST_ASSIGN_OPERATOR
+
+#define TEST_UNARY_OPERATOR(op_name, op)                                       \
+  template <typename T> struct test_##op_name {                                \
+    bool operator()(sycl::queue &Q, const std::vector<cmplx<double>> &init,    \
+                    const std::vector<cmplx<double>> &ref = {},                \
+                    bool use_ref = false) {                                    \
+      bool pass = true;                                                        \
+                                                                               \
+      using X = typename std::conditional<std::is_same<T, sycl::half>::value,  \
+                                          float, T>::type;                     \
+                                                                               \
+      /* std::complex test cases */                                            \
+      sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_in;            \
+      /* sycl::complex test cases */                                           \
+      sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE> cplx_in;  \
+                                                                               \
+      for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {               \
+        std_in[i] = init_std_complex<T>(init[i].re, init[i].im);               \
+        cplx_in[i] = experimental::complex<T>{static_cast<T>(init[i].re),      \
+                                              static_cast<T>(init[i].im)};     \
+      }                                                                        \
+                                                                               \
+      sycl::marray<std::complex<T>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
+      auto *cplx_out = sycl::malloc_shared<                                    \
+          sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1,   \
+                                                                          Q);  \
+                                                                               \
+      /* Get std::complex output */                                            \
+      if (use_ref) {                                                           \
+        for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {             \
+          T re = static_cast<T>(ref[i].re);                                    \
+          T im = static_cast<T>(ref[i].im);                                    \
+          std_out[i] = std::complex<T>{re, im};                                \
+        }                                                                      \
+      } else {                                                                 \
+        for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {             \
+          std_out[i] = op std_in[i];                                           \
+        }                                                                      \
+      }                                                                        \
+                                                                               \
+      /* Check cplx::complex output from device */                             \
+      Q.single_task([=]() { *cplx_out = op cplx_in; }).wait();                 \
+      pass &= check_results(*cplx_out, std_out, /*is_device*/ true);           \
+                                                                               \
+      /* Check cplx::complex output from host */                               \
+      *cplx_out = op cplx_in;                                                  \
+      pass &= check_results(*cplx_out, std_out, /*is_device*/ false);          \
+                                                                               \
+      sycl::free(cplx_out, Q);                                                 \
+                                                                               \
+      return pass;                                                             \
+    }                                                                          \
+  };
+
+TEST_UNARY_OPERATOR(unary_add, +)
+TEST_UNARY_OPERATOR(unary_sub, -)
+
+#undef TEST_UNARY_OPERATOR
+
+int main() {
+  sycl::queue Q;
+
+  bool test_passes = true;
+
+  /* Test basic arithmetic operator */
+
+  {
+    marray_cplx_test_cases<test_add> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_sub> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_mul> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_div> test;
+    test_passes &= test(Q);
+  }
+
+  /* Test assign arithmetic operator */
+
+  {
+    marray_cplx_test_cases<test_assign_add> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_assign_sub> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_assign_mul> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_assign_div> test;
+    test_passes &= test(Q);
+  }
+
+  /* Test unary operator */
+
+  {
+    marray_cplx_test_cases<test_unary_add> test;
+    test_passes &= test(Q);
+  }
+
+  {
+    marray_cplx_test_cases<test_unary_sub> test;
+    test_passes &= test(Q);
+  }
+
+  return !test_passes;
+}

From f9e3e76cee9d3930d3fa76f0b55e78def7463ff7 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Wed, 3 May 2023 10:49:03 +0200
Subject: [PATCH 10/39] Address PR's feedbacks by modifying the marray's
 constructors

---
 .../ext/oneapi/experimental/sycl_complex.hpp  | 70 ++++++++++++++++---
 sycl/test/extensions/test_marray_complex.cpp  | 22 ++++++
 2 files changed, 84 insertions(+), 8 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
index a6c509b6d2d83..31e4f79f439e8 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
@@ -981,6 +981,11 @@ tan(const complex<_Tp> &__x) {
 } // namespace oneapi
 } // namespace ext
 
+template <typename T> using marray_data = sycl::detail::vec_helper<T>;
+
+template <typename T>
+using marray_data_t = typename detail::vec_helper<T>::RetType;
+
 template <typename T, std::size_t NumElements>
 class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 private:
@@ -996,17 +1001,66 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 private:
   value_type MData[NumElements];
 
-public:
-  constexpr marray() : MData{} {};
+  // Trait for checking if an argument type is either convertible to the data
+  // type or an array of types convertible to the data type.
+  template <typename Type>
+  struct IsSuitableArgType : std::is_convertible<Type, ComplexDataT> {};
+  template <typename Type, size_t N>
+  struct IsSuitableArgType<marray<Type, N>>
+      : std::is_convertible<Type, ComplexDataT> {};
 
-  explicit constexpr marray(const ComplexDataT &arg) {
-    for (size_t i = 0; i < NumElements; ++i) {
-      MData[i] = arg;
+  // Trait for computing the conjunction of of IsSuitableArgType. The empty type
+  // list will trivially evaluate to true.
+  template <typename... ArgTN>
+  struct AllSuitableArgTypes : std::conjunction<IsSuitableArgType<ArgTN>...> {};
+
+  // Utility trait for creating an std::array from an marray argument.
+  template <typename ComplexDataT, typename Type, std::size_t... Is>
+  static constexpr std::array<ComplexDataT, sizeof...(Is)>
+  MArrayToArray(const marray<Type, sizeof...(Is)> &A,
+                std::index_sequence<Is...>) {
+    return {static_cast<ComplexDataT>(A.MData[Is])...};
+  }
+  template <typename ComplexDataT, typename Type, std::size_t N>
+  static constexpr std::array<ComplexDataT, N>
+  FlattenMArrayArgHelper(const marray<Type, N> &A) {
+    return MArrayToArray<ComplexDataT>(A, std::make_index_sequence<N>());
+  }
+  template <typename ComplexDataT, typename Type>
+  static constexpr auto FlattenMArrayArgHelper(const Type &A) {
+    return std::array<ComplexDataT, 1>{static_cast<ComplexDataT>(A)};
+  }
+  template <typename ComplexDataT, typename Type> struct FlattenMArrayArg {
+    constexpr auto operator()(const Type &A) const {
+      return FlattenMArrayArgHelper<ComplexDataT>(A);
     }
-  }
+  };
 
-  template <typename... ArgTN>
-  constexpr marray(const ArgTN &... args) : MData{args...} {};
+  // Alias for shortening the marray arguments to array converter.
+  template <typename ComplexDataT, typename... ArgTN>
+  using MArrayArgArrayCreator =
+      detail::ArrayCreator<ComplexDataT, FlattenMArrayArg, ArgTN...>;
+
+  template <size_t... Is>
+  constexpr marray(const std::array<ComplexDataT, NumElements> &Arr,
+                   std::index_sequence<Is...>)
+      : MData{Arr[Is]...} {}
+
+public:
+  constexpr marray() : MData{} {};
+
+  explicit constexpr marray(const ComplexDataT &arg)
+      : marray{sycl::detail::RepeatValue<NumElements>(
+                   static_cast<marray_data_t<ComplexDataT>>(arg)),
+               std::make_index_sequence<NumElements>()} {}
+
+  template <typename... ArgTN,
+            typename = std::enable_if_t<AllSuitableArgTypes<ArgTN...>::value &&
+                                        sycl::detail::GetMArrayArgsSize<
+                                            ArgTN...>::value == NumElements>>
+  constexpr marray(const ArgTN &... Args)
+      : marray{MArrayArgArrayCreator<ComplexDataT, ArgTN...>::Create(Args...),
+               std::make_index_sequence<NumElements>()} {}
 
   constexpr marray(const marray<ComplexDataT, NumElements> &rhs) = default;
   constexpr marray(marray<ComplexDataT, NumElements> &&rhs) = default;
diff --git a/sycl/test/extensions/test_marray_complex.cpp b/sycl/test/extensions/test_marray_complex.cpp
index 0a4118bdd56f2..146c28f85d1b6 100644
--- a/sycl/test/extensions/test_marray_complex.cpp
+++ b/sycl/test/extensions/test_marray_complex.cpp
@@ -213,6 +213,23 @@ template <typename T, std::size_t NumElements> struct test_pow_types {
   }
 };
 
+template <typename T> void check_constructors() {
+  using Complex = typename sycl::ext::oneapi::experimental::complex<T>;
+
+  {
+    sycl::marray<Complex, 1> a;
+    sycl::marray<Complex, 1> b{};
+    sycl::marray<Complex, 1> c{Complex{1, 0}};
+    sycl::marray<Complex, 2> d{Complex{1, 0}, Complex{2, 0}};
+  }
+  {
+    constexpr sycl::marray<Complex, 1> a;
+    constexpr sycl::marray<Complex, 1> b{};
+    constexpr sycl::marray<Complex, 1> c{Complex{1, 0}};
+    constexpr sycl::marray<Complex, 2> d{Complex{1, 0}, Complex{2, 0}};
+  }
+}
+
 int main() {
   // Check math function types
   test_valid_types<test_abs_types>();
@@ -249,5 +266,10 @@ int main() {
   test_valid_types<test_polar_types>();
   test_valid_types<test_pow_types>();
 
+  // Check constructors
+  check_constructors<sycl::half>();
+  check_constructors<float>();
+  check_constructors<double>();
+
   return 0;
 }

From 97f81e938ffe81cc0f8c515564c7cec6a13558f2 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Wed, 3 May 2023 11:39:09 +0200
Subject: [PATCH 11/39] format code with the latest clang-format

---
 sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
index 31e4f79f439e8..6c3e11b5f7a8b 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
@@ -61,7 +61,9 @@ template <class _Tp> struct __numeric_type {
   static const bool value = _IsNotSame<type, void>::value;
 };
 
-template <> struct __numeric_type<void> { static const bool value = true; };
+template <> struct __numeric_type<void> {
+  static const bool value = true;
+};
 
 template <class _A1, class _A2 = void, class _A3 = void,
           bool = __numeric_type<_A1>::value &&__numeric_type<_A2>::value
@@ -1058,7 +1060,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
             typename = std::enable_if_t<AllSuitableArgTypes<ArgTN...>::value &&
                                         sycl::detail::GetMArrayArgsSize<
                                             ArgTN...>::value == NumElements>>
-  constexpr marray(const ArgTN &... Args)
+  constexpr marray(const ArgTN &...Args)
       : marray{MArrayArgArrayCreator<ComplexDataT, ArgTN...>::Create(Args...),
                std::make_index_sequence<NumElements>()} {}
 

From 95c04537e698ae00e2c65840302f907c7c839d12 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Thu, 29 Jun 2023 08:48:42 +0200
Subject: [PATCH 12/39] Update marray tests with the latests %{build} and
 %{run}

---
 sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp  | 6 ++----
 sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp     | 6 ++----
 sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp | 6 ++----
 3 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
index 158f0e4e9ba4b..81bb3adcd7236 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
@@ -1,7 +1,5 @@
-// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsycl-device-code-split=per_kernel %s -o %t.out
-// RUN: %CPU_RUN_PLACEHOLDER %t.out
-// RUN: %GPU_RUN_PLACEHOLDER %t.out
-// RUN: %ACC_RUN_PLACEHOLDER %t.out
+// RUN: %{build} -fsycl-device-code-split=per_kernel -o %t.out
+// RUN: %{run} %t.out
 
 #include "sycl_complex_marray_test_cases.hpp"
 
diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
index 3c19bacfc569d..36bc624ee32e1 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
@@ -1,7 +1,5 @@
-// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsycl-device-code-split=per_kernel %s -o %t.out
-// RUN: %CPU_RUN_PLACEHOLDER %t.out
-// RUN: %GPU_RUN_PLACEHOLDER %t.out
-// RUN: %ACC_RUN_PLACEHOLDER %t.out
+// RUN: %{build} -fsycl-device-code-split=per_kernel -o %t.out
+// RUN: %{run} %t.out
 
 #include "sycl_complex_marray_test_cases.hpp"
 
diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp
index c7dca3502e9f6..4180a167a946d 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp
@@ -1,7 +1,5 @@
-// RUN: %clangxx -fsycl -fsycl-targets=%sycl_triple -fsycl-device-code-split=per_kernel %s -o %t.out
-// RUN: %CPU_RUN_PLACEHOLDER %t.out
-// RUN: %GPU_RUN_PLACEHOLDER %t.out
-// RUN: %ACC_RUN_PLACEHOLDER %t.out
+// RUN: %{build} -fsycl-device-code-split=per_kernel -o %t.out
+// RUN: %{run} %t.out
 
 #include "sycl_complex_marray_test_cases.hpp"
 

From 46079c204c8d3495ecefdf16d1c54e69717027b1 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Thu, 29 Jun 2023 08:50:16 +0200
Subject: [PATCH 13/39] Move marray's helper traits to detail's namespace, so
 exp::marray does not need to duplicate code

---
 .../ext/oneapi/experimental/sycl_complex.hpp  | 46 +---------
 sycl/include/sycl/marray.hpp                  | 87 +++++++++----------
 2 files changed, 45 insertions(+), 88 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
index 02cafd16de0d3..22baefd2b2be0 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
@@ -1024,46 +1024,6 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 private:
   value_type MData[NumElements];
 
-  // Trait for checking if an argument type is either convertible to the data
-  // type or an array of types convertible to the data type.
-  template <typename Type>
-  struct IsSuitableArgType : std::is_convertible<Type, ComplexDataT> {};
-  template <typename Type, size_t N>
-  struct IsSuitableArgType<marray<Type, N>>
-      : std::is_convertible<Type, ComplexDataT> {};
-
-  // Trait for computing the conjunction of of IsSuitableArgType. The empty type
-  // list will trivially evaluate to true.
-  template <typename... ArgTN>
-  struct AllSuitableArgTypes : std::conjunction<IsSuitableArgType<ArgTN>...> {};
-
-  // Utility trait for creating an std::array from an marray argument.
-  template <typename ComplexDataT, typename Type, std::size_t... Is>
-  static constexpr std::array<ComplexDataT, sizeof...(Is)>
-  MArrayToArray(const marray<Type, sizeof...(Is)> &A,
-                std::index_sequence<Is...>) {
-    return {static_cast<ComplexDataT>(A.MData[Is])...};
-  }
-  template <typename ComplexDataT, typename Type, std::size_t N>
-  static constexpr std::array<ComplexDataT, N>
-  FlattenMArrayArgHelper(const marray<Type, N> &A) {
-    return MArrayToArray<ComplexDataT>(A, std::make_index_sequence<N>());
-  }
-  template <typename ComplexDataT, typename Type>
-  static constexpr auto FlattenMArrayArgHelper(const Type &A) {
-    return std::array<ComplexDataT, 1>{static_cast<ComplexDataT>(A)};
-  }
-  template <typename ComplexDataT, typename Type> struct FlattenMArrayArg {
-    constexpr auto operator()(const Type &A) const {
-      return FlattenMArrayArgHelper<ComplexDataT>(A);
-    }
-  };
-
-  // Alias for shortening the marray arguments to array converter.
-  template <typename ComplexDataT, typename... ArgTN>
-  using MArrayArgArrayCreator =
-      detail::ArrayCreator<ComplexDataT, FlattenMArrayArg, ArgTN...>;
-
   template <size_t... Is>
   constexpr marray(const std::array<ComplexDataT, NumElements> &Arr,
                    std::index_sequence<Is...>)
@@ -1078,11 +1038,11 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
                std::make_index_sequence<NumElements>()} {}
 
   template <typename... ArgTN,
-            typename = std::enable_if_t<AllSuitableArgTypes<ArgTN...>::value &&
+            typename = std::enable_if_t<sycl::detail::AllSuitableArgTypes<ArgTN...>::value &&
                                         sycl::detail::GetMArrayArgsSize<
                                             ArgTN...>::value == NumElements>>
   constexpr marray(const ArgTN &...Args)
-      : marray{MArrayArgArrayCreator<ComplexDataT, ArgTN...>::Create(Args...),
+      : marray{sycl::detail::MArrayArgArrayCreator<ComplexDataT, ArgTN...>::Create(Args...),
                std::make_index_sequence<NumElements>()} {}
 
   constexpr marray(const marray<ComplexDataT, NumElements> &rhs) = default;
@@ -1114,7 +1074,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
   // subscript operator
   reference operator[](std::size_t i) { return MData[i]; }
-  const_reference operator[](std::size_t i) const { return MData[i]; }
+  constexpr const_reference operator[](std::size_t i) const { return MData[i]; }
 
   marray &operator=(const marray<ComplexDataT, NumElements> &rhs) = default;
   marray &operator=(const ComplexDataT &rhs) {
diff --git a/sycl/include/sycl/marray.hpp b/sycl/include/sycl/marray.hpp
index 850d6939383e1..6d6a5f8cbba89 100644
--- a/sycl/include/sycl/marray.hpp
+++ b/sycl/include/sycl/marray.hpp
@@ -39,6 +39,45 @@ template <typename T, typename... Ts> struct GetMArrayArgsSize<T, Ts...> {
   static constexpr std::size_t value = 1 + GetMArrayArgsSize<Ts...>::value;
 };
 
+// Trait for checking if an argument type is either convertible to the data
+// type or an array of types convertible to the data type.
+template <typename DataT, typename T>
+struct IsSuitableArgType : std::is_convertible<T, DataT> {};
+template <typename DataT, typename T, size_t N>
+struct IsSuitableArgType<DataT, marray<T, N>> : std::is_convertible<T, DataT> {};
+
+// Trait for computing the conjunction of of IsSuitableArgType. The empty type
+// list will trivially evaluate to true.
+template <typename DataT, typename... ArgTN>
+struct AllSuitableArgTypes : std::conjunction<IsSuitableArgType<DataT, ArgTN>...> {};
+
+// Utility trait for creating an std::array from an marray argument.
+template <typename DataT, typename T, std::size_t... Is>
+static constexpr std::array<DataT, sizeof...(Is)>
+MArrayToArray(const marray<T, sizeof...(Is)> &A, std::index_sequence<Is...>) {
+  // return {static_cast<DataT>(A.MData[Is])...};
+  return {static_cast<DataT>(A[Is])...};
+}
+template <typename DataT, typename T, std::size_t N>
+static constexpr std::array<DataT, N>
+FlattenMArrayArgHelper(const marray<T, N> &A) {
+  return MArrayToArray<DataT>(A, std::make_index_sequence<N>());
+}
+template <typename DataT, typename T>
+static constexpr auto FlattenMArrayArgHelper(const T &A) {
+  return std::array<DataT, 1>{static_cast<DataT>(A)};
+}
+template <typename DataT, typename T> struct FlattenMArrayArg {
+  constexpr auto operator()(const T &A) const {
+    return FlattenMArrayArgHelper<DataT>(A);
+  }
+};
+
+// Alias for shortening the marray arguments to array converter.
+template <typename DataT, typename... ArgTN>
+using MArrayArgArrayCreator =
+    detail::ArrayCreator<DataT, FlattenMArrayArg, ArgTN...>;
+
 } // namespace detail
 
 /// Provides a cross-platform math array class template that works on
@@ -58,48 +97,6 @@ template <typename Type, std::size_t NumElements> class marray {
 private:
   value_type MData[NumElements];
 
-  // Trait for checking if an argument type is either convertible to the data
-  // type or an array of types convertible to the data type.
-  template <typename T>
-  struct IsSuitableArgType : std::is_convertible<T, DataT> {};
-  template <typename T, size_t N>
-  struct IsSuitableArgType<marray<T, N>> : std::is_convertible<T, DataT> {};
-
-  // Trait for computing the conjunction of of IsSuitableArgType. The empty type
-  // list will trivially evaluate to true.
-  template <typename... ArgTN>
-  struct AllSuitableArgTypes : std::conjunction<IsSuitableArgType<ArgTN>...> {};
-
-  // Utility trait for creating an std::array from an marray argument.
-  template <typename DataT, typename T, std::size_t... Is>
-  static constexpr std::array<DataT, sizeof...(Is)>
-  MArrayToArray(const marray<T, sizeof...(Is)> &A, std::index_sequence<Is...>) {
-    return {static_cast<DataT>(A.MData[Is])...};
-  }
-  template <typename DataT, typename T, std::size_t N>
-  static constexpr std::array<DataT, N>
-  FlattenMArrayArgHelper(const marray<T, N> &A) {
-    return MArrayToArray<DataT>(A, std::make_index_sequence<N>());
-  }
-  template <typename DataT, typename T>
-  static constexpr auto FlattenMArrayArgHelper(const T &A) {
-    return std::array<DataT, 1>{static_cast<DataT>(A)};
-  }
-  template <typename DataT, typename T> struct FlattenMArrayArg {
-    constexpr auto operator()(const T &A) const {
-      return FlattenMArrayArgHelper<DataT>(A);
-    }
-  };
-
-  // Alias for shortening the marray arguments to array converter.
-  template <typename DataT, typename... ArgTN>
-  using MArrayArgArrayCreator =
-      detail::ArrayCreator<DataT, FlattenMArrayArg, ArgTN...>;
-
-  // FIXME: Other marray specializations needs to be a friend to access MData.
-  //        If the subscript operator is made constexpr this can be removed.
-  template <typename Type_, std::size_t NumElements_> friend class marray;
-
   constexpr void initialize_data(const Type &Arg) {
     for (size_t i = 0; i < NumElements; ++i) {
       MData[i] = Arg;
@@ -120,10 +117,10 @@ template <typename Type, std::size_t NumElements> class marray {
 
   template <typename... ArgTN,
             typename = std::enable_if_t<
-                AllSuitableArgTypes<ArgTN...>::value &&
+                detail::AllSuitableArgTypes<DataT, ArgTN...>::value &&
                 detail::GetMArrayArgsSize<ArgTN...>::value == NumElements>>
   constexpr marray(const ArgTN &...Args)
-      : marray{MArrayArgArrayCreator<DataT, ArgTN...>::Create(Args...),
+      : marray{detail::MArrayArgArrayCreator<DataT, ArgTN...>::Create(Args...),
                std::make_index_sequence<NumElements>()} {}
 
   constexpr marray(const marray<Type, NumElements> &Rhs) = default;
@@ -142,7 +139,7 @@ template <typename Type, std::size_t NumElements> class marray {
   // subscript operator
   reference operator[](std::size_t index) { return MData[index]; }
 
-  const_reference operator[](std::size_t index) const { return MData[index]; }
+  constexpr const_reference operator[](std::size_t index) const { return MData[index]; }
 
   marray &operator=(const marray<Type, NumElements> &Rhs) = default;
 

From c40fb022eb70d00584d211c7eec905b49f71c952 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Thu, 29 Jun 2023 08:53:23 +0200
Subject: [PATCH 14/39] Apply clang-format

---
 .../ext/oneapi/experimental/sycl_complex.hpp  | 19 +++++++++++--------
 sycl/include/sycl/marray.hpp                  | 10 +++++++---
 2 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
index 22baefd2b2be0..811ea068299f8 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
@@ -66,8 +66,8 @@ template <> struct __numeric_type<void> {
 };
 
 template <class _A1, class _A2 = void, class _A3 = void,
-          bool = __numeric_type<_A1>::value &&__numeric_type<_A2>::value
-              &&__numeric_type<_A3>::value>
+          bool = __numeric_type<_A1>::value && __numeric_type<_A2>::value &&
+                 __numeric_type<_A3>::value>
 class __promote_imp {
 public:
   static const bool value = false;
@@ -1037,13 +1037,16 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
                    static_cast<marray_data_t<ComplexDataT>>(arg)),
                std::make_index_sequence<NumElements>()} {}
 
-  template <typename... ArgTN,
-            typename = std::enable_if_t<sycl::detail::AllSuitableArgTypes<ArgTN...>::value &&
-                                        sycl::detail::GetMArrayArgsSize<
-                                            ArgTN...>::value == NumElements>>
+  template <
+      typename... ArgTN,
+      typename = std::enable_if_t<
+          sycl::detail::AllSuitableArgTypes<ArgTN...>::value &&
+          sycl::detail::GetMArrayArgsSize<ArgTN...>::value == NumElements>>
   constexpr marray(const ArgTN &...Args)
-      : marray{sycl::detail::MArrayArgArrayCreator<ComplexDataT, ArgTN...>::Create(Args...),
-               std::make_index_sequence<NumElements>()} {}
+      : marray{
+            sycl::detail::MArrayArgArrayCreator<ComplexDataT, ArgTN...>::Create(
+                Args...),
+            std::make_index_sequence<NumElements>()} {}
 
   constexpr marray(const marray<ComplexDataT, NumElements> &rhs) = default;
   constexpr marray(marray<ComplexDataT, NumElements> &&rhs) = default;
diff --git a/sycl/include/sycl/marray.hpp b/sycl/include/sycl/marray.hpp
index 6d6a5f8cbba89..6f3d85316d893 100644
--- a/sycl/include/sycl/marray.hpp
+++ b/sycl/include/sycl/marray.hpp
@@ -44,12 +44,14 @@ template <typename T, typename... Ts> struct GetMArrayArgsSize<T, Ts...> {
 template <typename DataT, typename T>
 struct IsSuitableArgType : std::is_convertible<T, DataT> {};
 template <typename DataT, typename T, size_t N>
-struct IsSuitableArgType<DataT, marray<T, N>> : std::is_convertible<T, DataT> {};
+struct IsSuitableArgType<DataT, marray<T, N>> : std::is_convertible<T, DataT> {
+};
 
 // Trait for computing the conjunction of of IsSuitableArgType. The empty type
 // list will trivially evaluate to true.
 template <typename DataT, typename... ArgTN>
-struct AllSuitableArgTypes : std::conjunction<IsSuitableArgType<DataT, ArgTN>...> {};
+struct AllSuitableArgTypes
+    : std::conjunction<IsSuitableArgType<DataT, ArgTN>...> {};
 
 // Utility trait for creating an std::array from an marray argument.
 template <typename DataT, typename T, std::size_t... Is>
@@ -139,7 +141,9 @@ template <typename Type, std::size_t NumElements> class marray {
   // subscript operator
   reference operator[](std::size_t index) { return MData[index]; }
 
-  constexpr const_reference operator[](std::size_t index) const { return MData[index]; }
+  constexpr const_reference operator[](std::size_t index) const {
+    return MData[index];
+  }
 
   marray &operator=(const marray<Type, NumElements> &Rhs) = default;
 

From 5bced0f7169162b7753319efb7244a69c55f4c02 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Mon, 24 Jul 2023 15:14:01 +0200
Subject: [PATCH 15/39] Encapsulate marray's helper into struct which is a
 friend of class marray

---
 .../ext/oneapi/experimental/sycl_complex.hpp  | 11 ++--
 sycl/include/sycl/marray.hpp                  | 51 +++++++++++--------
 2 files changed, 38 insertions(+), 24 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
index 811ea068299f8..796042e6178f3 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
@@ -1029,6 +1029,11 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
                    std::index_sequence<Is...>)
       : MData{Arr[Is]...} {}
 
+  /// FIXME: If the subscript operator is made constexpr this can be removed.
+  // detail::HelperFlattenMArrayArg::MArrayToArray needs to have access to
+  // MData.
+  friend class detail::HelperFlattenMArrayArg;
+
 public:
   constexpr marray() : MData{} {};
 
@@ -1040,9 +1045,9 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   template <
       typename... ArgTN,
       typename = std::enable_if_t<
-          sycl::detail::AllSuitableArgTypes<ArgTN...>::value &&
+          sycl::detail::AllSuitableArgTypes<ComplexDataT, ArgTN...>::value &&
           sycl::detail::GetMArrayArgsSize<ArgTN...>::value == NumElements>>
-  constexpr marray(const ArgTN &...Args)
+  constexpr marray(const ArgTN &... Args)
       : marray{
             sycl::detail::MArrayArgArrayCreator<ComplexDataT, ArgTN...>::Create(
                 Args...),
@@ -1077,7 +1082,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
   // subscript operator
   reference operator[](std::size_t i) { return MData[i]; }
-  constexpr const_reference operator[](std::size_t i) const { return MData[i]; }
+  const_reference operator[](std::size_t i) const { return MData[i]; }
 
   marray &operator=(const marray<ComplexDataT, NumElements> &rhs) = default;
   marray &operator=(const ComplexDataT &rhs) {
diff --git a/sycl/include/sycl/marray.hpp b/sycl/include/sycl/marray.hpp
index 6f3d85316d893..7c29254994822 100644
--- a/sycl/include/sycl/marray.hpp
+++ b/sycl/include/sycl/marray.hpp
@@ -53,25 +53,30 @@ template <typename DataT, typename... ArgTN>
 struct AllSuitableArgTypes
     : std::conjunction<IsSuitableArgType<DataT, ArgTN>...> {};
 
-// Utility trait for creating an std::array from an marray argument.
-template <typename DataT, typename T, std::size_t... Is>
-static constexpr std::array<DataT, sizeof...(Is)>
-MArrayToArray(const marray<T, sizeof...(Is)> &A, std::index_sequence<Is...>) {
-  // return {static_cast<DataT>(A.MData[Is])...};
-  return {static_cast<DataT>(A[Is])...};
-}
-template <typename DataT, typename T, std::size_t N>
-static constexpr std::array<DataT, N>
-FlattenMArrayArgHelper(const marray<T, N> &A) {
-  return MArrayToArray<DataT>(A, std::make_index_sequence<N>());
-}
-template <typename DataT, typename T>
-static constexpr auto FlattenMArrayArgHelper(const T &A) {
-  return std::array<DataT, 1>{static_cast<DataT>(A)};
-}
+class HelperFlattenMArrayArg {
+private:
+  // Utility trait for creating an std::array from an marray argument.
+  template <typename DataT, typename T, std::size_t... Is>
+  static constexpr std::array<DataT, sizeof...(Is)>
+  MArrayToArray(const marray<T, sizeof...(Is)> &A, std::index_sequence<Is...>) {
+    return {static_cast<DataT>(A.MData[Is])...};
+  }
+
+public:
+  template <typename DataT, typename T, std::size_t N>
+  static constexpr std::array<DataT, N>
+  FlattenMArrayArgHelper(const marray<T, N> &A) {
+    return MArrayToArray<DataT>(A, std::make_index_sequence<N>());
+  }
+  template <typename DataT, typename T>
+  static constexpr auto FlattenMArrayArgHelper(const T &A) {
+    return std::array<DataT, 1>{static_cast<DataT>(A)};
+  }
+};
+
 template <typename DataT, typename T> struct FlattenMArrayArg {
   constexpr auto operator()(const T &A) const {
-    return FlattenMArrayArgHelper<DataT>(A);
+    return HelperFlattenMArrayArg::FlattenMArrayArgHelper<DataT>(A);
   }
 };
 
@@ -99,6 +104,13 @@ template <typename Type, std::size_t NumElements> class marray {
 private:
   value_type MData[NumElements];
 
+  /// FIXME: If the subscript operator is made constexpr these can be removed.
+  // Other marray specializations needs to be a friend to access MData.
+  template <typename Type_, std::size_t NumElements_> friend class marray;
+  // detail::HelperFlattenMArrayArg::MArrayToArray needs to be a friend to
+  // access MData.
+  friend class detail::HelperFlattenMArrayArg;
+
   constexpr void initialize_data(const Type &Arg) {
     for (size_t i = 0; i < NumElements; ++i) {
       MData[i] = Arg;
@@ -140,10 +152,7 @@ template <typename Type, std::size_t NumElements> class marray {
 
   // subscript operator
   reference operator[](std::size_t index) { return MData[index]; }
-
-  constexpr const_reference operator[](std::size_t index) const {
-    return MData[index];
-  }
+  const_reference operator[](std::size_t index) const { return MData[index]; }
 
   marray &operator=(const marray<Type, NumElements> &Rhs) = default;
 

From 1fb5a4fd02ba2116e54b5e330925563b79e516ea Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Mon, 24 Jul 2023 15:14:41 +0200
Subject: [PATCH 16/39] Update marray's contructor tests

---
 sycl/test/extensions/test_marray_complex.cpp | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/sycl/test/extensions/test_marray_complex.cpp b/sycl/test/extensions/test_marray_complex.cpp
index 146c28f85d1b6..b169e737ba857 100644
--- a/sycl/test/extensions/test_marray_complex.cpp
+++ b/sycl/test/extensions/test_marray_complex.cpp
@@ -216,17 +216,19 @@ template <typename T, std::size_t NumElements> struct test_pow_types {
 template <typename T> void check_constructors() {
   using Complex = typename sycl::ext::oneapi::experimental::complex<T>;
 
+  constexpr Complex cplx{T{42}, T{0}};
+
   {
-    sycl::marray<Complex, 1> a;
-    sycl::marray<Complex, 1> b{};
-    sycl::marray<Complex, 1> c{Complex{1, 0}};
-    sycl::marray<Complex, 2> d{Complex{1, 0}, Complex{2, 0}};
+    sycl::marray<Complex, 1> a{};
+    sycl::marray<Complex, 1> b{cplx};
+    sycl::marray<Complex, 2> c{cplx, cplx};
+    sycl::marray<Complex, 4> d{c, c};
   }
   {
-    constexpr sycl::marray<Complex, 1> a;
-    constexpr sycl::marray<Complex, 1> b{};
-    constexpr sycl::marray<Complex, 1> c{Complex{1, 0}};
-    constexpr sycl::marray<Complex, 2> d{Complex{1, 0}, Complex{2, 0}};
+    constexpr sycl::marray<Complex, 1> a{};
+    constexpr sycl::marray<Complex, 1> b{cplx};
+    constexpr sycl::marray<Complex, 2> c{cplx, cplx};
+    constexpr sycl::marray<Complex, 4> d{c, c};
   }
 }
 

From 91c14e5396635b6b98a7c83e80d2b6f4dc509b0e Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Mon, 24 Jul 2023 15:22:21 +0200
Subject: [PATCH 17/39] format code with the latest clang-format

---
 sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
index 796042e6178f3..2498a14d14644 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
@@ -1047,7 +1047,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
       typename = std::enable_if_t<
           sycl::detail::AllSuitableArgTypes<ComplexDataT, ArgTN...>::value &&
           sycl::detail::GetMArrayArgsSize<ArgTN...>::value == NumElements>>
-  constexpr marray(const ArgTN &... Args)
+  constexpr marray(const ArgTN &...Args)
       : marray{
             sycl::detail::MArrayArgArrayCreator<ComplexDataT, ArgTN...>::Create(
                 Args...),

From 18b42778af850fb9b8e477d778714f216e1ad8b1 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Tue, 25 Jul 2023 09:36:45 +0200
Subject: [PATCH 18/39] Replace ComplexDataT by value_type

---
 .../ext/oneapi/experimental/sycl_complex.hpp  | 66 +++++++++----------
 1 file changed, 33 insertions(+), 33 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
index 108a549e0e662..e7445d94f75e2 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
@@ -1024,7 +1024,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   value_type MData[NumElements];
 
   template <size_t... Is>
-  constexpr marray(const std::array<ComplexDataT, NumElements> &Arr,
+  constexpr marray(const std::array<value_type, NumElements> &Arr,
                    std::index_sequence<Is...>)
       : MData{Arr[Is]...} {}
 
@@ -1036,28 +1036,28 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 public:
   constexpr marray() : MData{} {};
 
-  explicit constexpr marray(const ComplexDataT &arg)
+  explicit constexpr marray(const value_type &arg)
       : marray{sycl::detail::RepeatValue<NumElements>(
-                   static_cast<marray_data_t<ComplexDataT>>(arg)),
+                   static_cast<marray_data_t<value_type>>(arg)),
                std::make_index_sequence<NumElements>()} {}
 
   template <
       typename... ArgTN,
       typename = std::enable_if_t<
-          sycl::detail::AllSuitableArgTypes<ComplexDataT, ArgTN...>::value &&
+          sycl::detail::AllSuitableArgTypes<value_type, ArgTN...>::value &&
           sycl::detail::GetMArrayArgsSize<ArgTN...>::value == NumElements>>
   constexpr marray(const ArgTN &...Args)
       : marray{
-            sycl::detail::MArrayArgArrayCreator<ComplexDataT, ArgTN...>::Create(
+            sycl::detail::MArrayArgArrayCreator<value_type, ArgTN...>::Create(
                 Args...),
             std::make_index_sequence<NumElements>()} {}
 
-  constexpr marray(const marray<ComplexDataT, NumElements> &rhs) = default;
-  constexpr marray(marray<ComplexDataT, NumElements> &&rhs) = default;
+  constexpr marray(const marray<value_type, NumElements> &rhs) = default;
+  constexpr marray(marray<value_type, NumElements> &&rhs) = default;
 
   // Available only when: NumElements == 1
   template <typename = typename std::enable_if<NumElements == 1>>
-  operator ComplexDataT() const {
+  operator value_type() const {
     return MData[0];
   }
 
@@ -1083,8 +1083,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   reference operator[](std::size_t i) { return MData[i]; }
   const_reference operator[](std::size_t i) const { return MData[i]; }
 
-  marray &operator=(const marray<ComplexDataT, NumElements> &rhs) = default;
-  marray &operator=(const ComplexDataT &rhs) {
+  marray &operator=(const marray<value_type, NumElements> &rhs) = default;
+  marray &operator=(const value_type &rhs) {
     for (std::size_t i = 0; i < NumElements; ++i) {
       MData[i] = rhs;
     }
@@ -1108,7 +1108,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  friend marray operator op(const marray &lhs, const ComplexDataT &rhs) {      \
+  friend marray operator op(const marray &lhs, const value_type &rhs) {      \
     marray rtn;                                                                \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = lhs[i] op rhs;                                                  \
@@ -1116,7 +1116,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  friend marray operator op(const ComplexDataT &lhs, const marray &rhs) {      \
+  friend marray operator op(const value_type &lhs, const marray &rhs) {      \
     marray rtn;                                                                \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = lhs op rhs[i];                                                  \
@@ -1133,8 +1133,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
   // OP is: %
   friend marray operator%(const marray &lhs, const marray &rhs) = delete;
-  friend marray operator%(const marray &lhs, const ComplexDataT &rhs) = delete;
-  friend marray operator%(const ComplexDataT &lhs, const marray &rhs) = delete;
+  friend marray operator%(const marray &lhs, const value_type &rhs) = delete;
+  friend marray operator%(const value_type &lhs, const marray &rhs) = delete;
 
   // OP is: +=, -=, *=, /=
 #define OP(op)                                                                 \
@@ -1145,13 +1145,13 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return lhs;                                                                \
   }                                                                            \
                                                                                \
-  friend marray &operator op(marray &lhs, const ComplexDataT &rhs) {           \
+  friend marray &operator op(marray &lhs, const value_type &rhs) {           \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       lhs[i] op rhs;                                                           \
     }                                                                          \
     return lhs;                                                                \
   }                                                                            \
-  friend marray &operator op(ComplexDataT &lhs, const marray &rhs) {           \
+  friend marray &operator op(value_type &lhs, const marray &rhs) {           \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       lhs[i] op rhs;                                                           \
     }                                                                          \
@@ -1167,8 +1167,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
   // OP is: %=
   friend marray &operator%=(marray &lhs, const marray &rhs) = delete;
-  friend marray &operator%=(marray &lhs, const ComplexDataT &rhs) = delete;
-  friend marray &operator%=(ComplexDataT &lhs, const marray &rhs) = delete;
+  friend marray &operator%=(marray &lhs, const value_type &rhs) = delete;
+  friend marray &operator%=(value_type &lhs, const marray &rhs) = delete;
 
 // OP is: ++, --
 #define OP(op)                                                                 \
@@ -1182,9 +1182,9 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
 // OP is: unary +, unary -
 #define OP(op)                                                                 \
-  friend marray<ComplexDataT, NumElements> operator op(                        \
-      const marray<ComplexDataT, NumElements> &rhs) {                          \
-    marray<ComplexDataT, NumElements> rtn;                                     \
+  friend marray<value_type, NumElements> operator op(                        \
+      const marray<value_type, NumElements> &rhs) {                          \
+    marray<value_type, NumElements> rtn;                                     \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = op rhs[i];                                                      \
     }                                                                          \
@@ -1199,7 +1199,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 // OP is: &, |, ^
 #define OP(op)                                                                 \
   friend marray operator op(const marray &lhs, const marray &rhs) = delete;    \
-  friend marray operator op(const marray &lhs, const ComplexDataT &rhs) =      \
+  friend marray operator op(const marray &lhs, const value_type &rhs) =      \
       delete;
 
   OP(&)
@@ -1211,8 +1211,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 // OP is: &=, |=, ^=
 #define OP(op)                                                                 \
   friend marray &operator op(marray &lhs, const marray &rhs) = delete;         \
-  friend marray &operator op(marray &lhs, const ComplexDataT &rhs) = delete;   \
-  friend marray &operator op(ComplexDataT &lhs, const marray &rhs) = delete;
+  friend marray &operator op(marray &lhs, const value_type &rhs) = delete;   \
+  friend marray &operator op(value_type &lhs, const marray &rhs) = delete;
 
   OP(&=)
   OP(|=)
@@ -1225,8 +1225,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   friend marray<bool, NumElements> operator op(const marray &lhs,              \
                                                const marray &rhs) = delete;    \
   friend marray<bool, NumElements> operator op(                                \
-      const marray &lhs, const ComplexDataT &rhs) = delete;                    \
-  friend marray<bool, NumElements> operator op(const ComplexDataT &lhs,        \
+      const marray &lhs, const value_type &rhs) = delete;                    \
+  friend marray<bool, NumElements> operator op(const value_type &lhs,        \
                                                const marray &rhs) = delete;
 
   OP(&&)
@@ -1237,9 +1237,9 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 // OP is: <<, >>
 #define OP(op)                                                                 \
   friend marray operator op(const marray &lhs, const marray &rhs) = delete;    \
-  friend marray operator op(const marray &lhs, const ComplexDataT &rhs) =      \
+  friend marray operator op(const marray &lhs, const value_type &rhs) =      \
       delete;                                                                  \
-  friend marray operator op(const ComplexDataT &lhs, const marray &rhs) =      \
+  friend marray operator op(const value_type &lhs, const marray &rhs) =      \
       delete;
 
   OP(<<)
@@ -1250,7 +1250,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 // OP is: <<=, >>=
 #define OP(op)                                                                 \
   friend marray &operator op(marray &lhs, const marray &rhs) = delete;         \
-  friend marray &operator op(marray &lhs, const ComplexDataT &rhs) = delete;
+  friend marray &operator op(marray &lhs, const value_type &rhs) = delete;
 
   OP(<<=)
   OP(>>=)
@@ -1269,7 +1269,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   }                                                                            \
                                                                                \
   friend marray<bool, NumElements> operator op(const marray &lhs,              \
-                                               const ComplexDataT &rhs) {      \
+                                               const value_type &rhs) {      \
     marray<bool, NumElements> rtn;                                             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = lhs[i] op rhs;                                                  \
@@ -1277,7 +1277,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  friend marray<bool, NumElements> operator op(const ComplexDataT &lhs,        \
+  friend marray<bool, NumElements> operator op(const value_type &lhs,        \
                                                const marray &rhs) {            \
     marray<bool, NumElements> rtn;                                             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
@@ -1296,8 +1296,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   friend marray<bool, NumElements> operator op(const marray &lhs,              \
                                                const marray &rhs) = delete;    \
   friend marray<bool, NumElements> operator op(                                \
-      const marray &lhs, const ComplexDataT &rhs) = delete;                    \
-  friend marray<bool, NumElements> operator op(const ComplexDataT &lhs,        \
+      const marray &lhs, const value_type &rhs) = delete;                    \
+  friend marray<bool, NumElements> operator op(const value_type &lhs,        \
                                                const marray &rhs) = delete;
 
   OP(<);

From 1627da7751d4bac020fbddea30ad531b33d27e0d Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Tue, 25 Jul 2023 09:45:55 +0200
Subject: [PATCH 19/39] Remove -fsycl-device-code-split=per_kernel from the
 tests

---
 sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp  | 2 +-
 sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp     | 2 +-
 sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
index 81bb3adcd7236..ac369dc3f9c37 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
@@ -1,4 +1,4 @@
-// RUN: %{build} -fsycl-device-code-split=per_kernel -o %t.out
+// RUN: %{build} -o %t.out
 // RUN: %{run} %t.out
 
 #include "sycl_complex_marray_test_cases.hpp"
diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
index 36bc624ee32e1..abd711a04915b 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
@@ -1,4 +1,4 @@
-// RUN: %{build} -fsycl-device-code-split=per_kernel -o %t.out
+// RUN: %{build} -o %t.out
 // RUN: %{run} %t.out
 
 #include "sycl_complex_marray_test_cases.hpp"
diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp
index 4180a167a946d..111100e50f8a5 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp
@@ -1,4 +1,4 @@
-// RUN: %{build} -fsycl-device-code-split=per_kernel -o %t.out
+// RUN: %{build} -o %t.out
 // RUN: %{run} %t.out
 
 #include "sycl_complex_marray_test_cases.hpp"

From 884b12e6998cff21c60bc69f5eca39c2936c0f64 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Tue, 25 Jul 2023 12:10:31 +0200
Subject: [PATCH 20/39] Enable std::enable_if via Return type isntead of type
 template parameter where possible

---
 .../ext/oneapi/experimental/sycl_complex.hpp  | 85 ++++++++-----------
 1 file changed, 34 insertions(+), 51 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
index e7445d94f75e2..9868532ddb2a0 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
@@ -1056,7 +1056,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   constexpr marray(marray<value_type, NumElements> &&rhs) = default;
 
   // Available only when: NumElements == 1
-  template <typename = typename std::enable_if<NumElements == 1>>
+  template <std::size_t N = NumElements, typename = std::enable_if_t<N == 1, value_type>>
   operator value_type() const {
     return MData[0];
   }
@@ -1318,15 +1318,13 @@ namespace experimental {
 
 // Math marray overloads
 
-#define MATH_OP_ONE_PARAM(math_func, rtn_type, arg_type)                       \
-  template <typename T, std::size_t NumElements,                               \
-            typename = std::enable_if<is_genfloat<T>::value ||                 \
-                                      is_gencomplex<T>::value>>                \
-  _SYCL_EXT_CPLX_INLINE_VISIBILITY sycl::marray<rtn_type, NumElements>         \
-  math_func(const sycl::marray<arg_type, NumElements> &x) {                    \
+#define MATH_OP_ONE_PARAM(math_func, rtn_type, arg_type) \
+  template <typename T, std::size_t NumElements> \
+  _SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if_t<is_genfloat<T>::value || is_gencomplex<T>::value, sycl::marray<rtn_type, NumElements>> \
+  math_func(const sycl::marray<arg_type, NumElements> &x) { \
     sycl::marray<rtn_type, NumElements> rtn;                                   \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = sycl::ext::oneapi::experimental::math_func(x[i]);               \
+      rtn[i] = math_func(x[i]);               \
     }                                                                          \
     return rtn;                                                                \
   }
@@ -1356,39 +1354,30 @@ MATH_OP_ONE_PARAM(tanh, complex<T>, complex<T>);
 
 #undef MATH_OP_ONE_PARAM
 
-#define MATH_OP_TWO_PARAM(math_func, rtn_type, arg_type1, arg_type2)           \
-  template <typename T, std::size_t NumElements,                               \
-            typename = std::enable_if<is_genfloat<T>::value ||                 \
-                                      is_gencomplex<T>::value>>                \
-  _SYCL_EXT_CPLX_INLINE_VISIBILITY sycl::marray<rtn_type, NumElements>         \
-  math_func(const sycl::marray<arg_type1, NumElements> &x,                     \
-            const sycl::marray<arg_type2, NumElements> &y) {                   \
+#define MATH_OP_TWO_PARAM(math_func, rtn_type, arg_type1, arg_type2)                                                          \
+  template <typename T, std::size_t NumElements> \
+  _SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if_t<is_genfloat<T>::value || is_gencomplex<T>::value, sycl::marray<rtn_type, NumElements>> \
+  math_func(const sycl::marray<arg_type1, NumElements> &x, const sycl::marray<arg_type2, NumElements> &y) {                   \
     sycl::marray<rtn_type, NumElements> rtn;                                   \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = sycl::ext::oneapi::experimental::math_func(x[i], y[i]);         \
+      rtn[i] = math_func(x[i], y[i]);         \
     }                                                                          \
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  template <typename T, std::size_t NumElements,                               \
-            typename = std::enable_if<is_genfloat<T>::value ||                 \
-                                      is_gencomplex<T>::value>>                \
-  _SYCL_EXT_CPLX_INLINE_VISIBILITY sycl::marray<rtn_type, NumElements>         \
-  math_func(const sycl::marray<arg_type1, NumElements> &x,                     \
-            const arg_type2 &y) {                                              \
+  template <typename T, std::size_t NumElements> \
+   _SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if_t<is_genfloat<T>::value || is_gencomplex<T>::value, sycl::marray<rtn_type, NumElements>> \
+  math_func(const sycl::marray<arg_type1, NumElements> &x, const arg_type2 &y) {                    \
     sycl::marray<rtn_type, NumElements> rtn;                                   \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = sycl::ext::oneapi::experimental::math_func(x[i], y);            \
+      rtn[i] = math_func(x[i], y);            \
     }                                                                          \
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  template <typename T, std::size_t NumElements,                               \
-            typename = std::enable_if<is_genfloat<T>::value ||                 \
-                                      is_gencomplex<T>::value>>                \
-  _SYCL_EXT_CPLX_INLINE_VISIBILITY sycl::marray<rtn_type, NumElements>         \
-  math_func(const arg_type1 &x,                                                \
-            const sycl::marray<arg_type2, NumElements> &y) {                   \
+  template <typename T, std::size_t NumElements> \
+  _SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if_t<is_genfloat<T>::value || is_gencomplex<T>::value, sycl::marray<rtn_type, NumElements>> \
+  math_func(const arg_type1 &x, const sycl::marray<arg_type2, NumElements> &y) {                   \
     sycl::marray<rtn_type, NumElements> rtn;                                   \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = math_func(x, y[i]);                                             \
@@ -1404,39 +1393,33 @@ MATH_OP_TWO_PARAM(pow, complex<T>, T, complex<T>);
 
 // Special definition as polar requires default argument
 
-template <typename T, std::size_t NumElements,
-          typename = std::enable_if<is_genfloat<T>::value>>
-_SYCL_EXT_CPLX_INLINE_VISIBILITY
-    sycl::marray<sycl::ext::oneapi::experimental::complex<T>, NumElements>
-    polar(const sycl::marray<T, NumElements> &rho,
-          const sycl::marray<T, NumElements> &theta) {
-  sycl::marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> rtn;
+template <typename T, std::size_t NumElements>
+_SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if_t<is_genfloat<T>::value, sycl::marray<complex<T>, NumElements>>
+polar(const sycl::marray<T, NumElements> &rho, const sycl::marray<T, NumElements> &theta) {
+  sycl::marray<complex<T>, NumElements> rtn;
   for (std::size_t i = 0; i < NumElements; ++i) {
-    rtn[i] = sycl::ext::oneapi::experimental::polar(rho[i], theta[i]);
+    rtn[i] = polar(rho[i], theta[i]);
   }
   return rtn;
 }
 
-template <typename T, std::size_t NumElements,
-          typename = std::enable_if<is_genfloat<T>::value>>
-_SYCL_EXT_CPLX_INLINE_VISIBILITY
-    sycl::marray<sycl::ext::oneapi::experimental::complex<T>, NumElements>
-    polar(const sycl::marray<T, NumElements> &rho, const T &theta = 0) {
-  sycl::marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> rtn;
+template <typename T, std::size_t NumElements>
+_SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if_t<is_genfloat<T>::value, sycl::marray<complex<T>, NumElements>>
+polar(const sycl::marray<T, NumElements> &rho, const T &theta = 0) {
+  sycl::marray<complex<T>, NumElements> rtn;
   for (std::size_t i = 0; i < NumElements; ++i) {
-    rtn[i] = sycl::ext::oneapi::experimental::polar(rho[i], theta);
+    rtn[i] = polar(rho[i], theta);
   }
   return rtn;
 }
 
-template <typename T, std::size_t NumElements,
-          typename = std::enable_if<is_genfloat<T>::value>>
-_SYCL_EXT_CPLX_INLINE_VISIBILITY
-    sycl::marray<sycl::ext::oneapi::experimental::complex<T>, NumElements>
-    polar(const T &rho, const sycl::marray<T, NumElements> &theta) {
-  sycl::marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> rtn;
+
+template <typename T, std::size_t NumElements>
+_SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if_t<is_genfloat<T>::value, sycl::marray<complex<T>, NumElements>>
+polar(const T &rho, const sycl::marray<T, NumElements> &theta) {
+  sycl::marray<complex<T>, NumElements> rtn;
   for (std::size_t i = 0; i < NumElements; ++i) {
-    rtn[i] = sycl::ext::oneapi::experimental::polar(rho, theta[i]);
+    rtn[i] = polar(rho, theta[i]);
   }
   return rtn;
 }

From 79b2711bcdde897cce62e0e5abc872d6df86421c Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Tue, 25 Jul 2023 14:24:09 +0200
Subject: [PATCH 21/39] Run clang-format

---
 .../ext/oneapi/experimental/sycl_complex.hpp  | 108 +++++++++++-------
 1 file changed, 64 insertions(+), 44 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
index 9868532ddb2a0..4e61ef7edd169 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
@@ -1056,7 +1056,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   constexpr marray(marray<value_type, NumElements> &&rhs) = default;
 
   // Available only when: NumElements == 1
-  template <std::size_t N = NumElements, typename = std::enable_if_t<N == 1, value_type>>
+  template <std::size_t N = NumElements,
+            typename = std::enable_if_t<N == 1, value_type>>
   operator value_type() const {
     return MData[0];
   }
@@ -1108,7 +1109,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  friend marray operator op(const marray &lhs, const value_type &rhs) {      \
+  friend marray operator op(const marray &lhs, const value_type &rhs) {        \
     marray rtn;                                                                \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = lhs[i] op rhs;                                                  \
@@ -1116,7 +1117,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  friend marray operator op(const value_type &lhs, const marray &rhs) {      \
+  friend marray operator op(const value_type &lhs, const marray &rhs) {        \
     marray rtn;                                                                \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = lhs op rhs[i];                                                  \
@@ -1145,13 +1146,13 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return lhs;                                                                \
   }                                                                            \
                                                                                \
-  friend marray &operator op(marray &lhs, const value_type &rhs) {           \
+  friend marray &operator op(marray &lhs, const value_type &rhs) {             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       lhs[i] op rhs;                                                           \
     }                                                                          \
     return lhs;                                                                \
   }                                                                            \
-  friend marray &operator op(value_type &lhs, const marray &rhs) {           \
+  friend marray &operator op(value_type &lhs, const marray &rhs) {             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       lhs[i] op rhs;                                                           \
     }                                                                          \
@@ -1182,9 +1183,9 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
 // OP is: unary +, unary -
 #define OP(op)                                                                 \
-  friend marray<value_type, NumElements> operator op(                        \
-      const marray<value_type, NumElements> &rhs) {                          \
-    marray<value_type, NumElements> rtn;                                     \
+  friend marray<value_type, NumElements> operator op(                          \
+      const marray<value_type, NumElements> &rhs) {                            \
+    marray<value_type, NumElements> rtn;                                       \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = op rhs[i];                                                      \
     }                                                                          \
@@ -1199,8 +1200,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 // OP is: &, |, ^
 #define OP(op)                                                                 \
   friend marray operator op(const marray &lhs, const marray &rhs) = delete;    \
-  friend marray operator op(const marray &lhs, const value_type &rhs) =      \
-      delete;
+  friend marray operator op(const marray &lhs, const value_type &rhs) = delete;
 
   OP(&)
   OP(|)
@@ -1211,7 +1211,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 // OP is: &=, |=, ^=
 #define OP(op)                                                                 \
   friend marray &operator op(marray &lhs, const marray &rhs) = delete;         \
-  friend marray &operator op(marray &lhs, const value_type &rhs) = delete;   \
+  friend marray &operator op(marray &lhs, const value_type &rhs) = delete;     \
   friend marray &operator op(value_type &lhs, const marray &rhs) = delete;
 
   OP(&=)
@@ -1225,8 +1225,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   friend marray<bool, NumElements> operator op(const marray &lhs,              \
                                                const marray &rhs) = delete;    \
   friend marray<bool, NumElements> operator op(                                \
-      const marray &lhs, const value_type &rhs) = delete;                    \
-  friend marray<bool, NumElements> operator op(const value_type &lhs,        \
+      const marray &lhs, const value_type &rhs) = delete;                      \
+  friend marray<bool, NumElements> operator op(const value_type &lhs,          \
                                                const marray &rhs) = delete;
 
   OP(&&)
@@ -1237,10 +1237,9 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 // OP is: <<, >>
 #define OP(op)                                                                 \
   friend marray operator op(const marray &lhs, const marray &rhs) = delete;    \
-  friend marray operator op(const marray &lhs, const value_type &rhs) =      \
+  friend marray operator op(const marray &lhs, const value_type &rhs) =        \
       delete;                                                                  \
-  friend marray operator op(const value_type &lhs, const marray &rhs) =      \
-      delete;
+  friend marray operator op(const value_type &lhs, const marray &rhs) = delete;
 
   OP(<<)
   OP(>>)
@@ -1269,7 +1268,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   }                                                                            \
                                                                                \
   friend marray<bool, NumElements> operator op(const marray &lhs,              \
-                                               const value_type &rhs) {      \
+                                               const value_type &rhs) {        \
     marray<bool, NumElements> rtn;                                             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = lhs[i] op rhs;                                                  \
@@ -1277,7 +1276,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  friend marray<bool, NumElements> operator op(const value_type &lhs,        \
+  friend marray<bool, NumElements> operator op(const value_type &lhs,          \
                                                const marray &rhs) {            \
     marray<bool, NumElements> rtn;                                             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
@@ -1296,8 +1295,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   friend marray<bool, NumElements> operator op(const marray &lhs,              \
                                                const marray &rhs) = delete;    \
   friend marray<bool, NumElements> operator op(                                \
-      const marray &lhs, const value_type &rhs) = delete;                    \
-  friend marray<bool, NumElements> operator op(const value_type &lhs,        \
+      const marray &lhs, const value_type &rhs) = delete;                      \
+  friend marray<bool, NumElements> operator op(const value_type &lhs,          \
                                                const marray &rhs) = delete;
 
   OP(<);
@@ -1318,13 +1317,16 @@ namespace experimental {
 
 // Math marray overloads
 
-#define MATH_OP_ONE_PARAM(math_func, rtn_type, arg_type) \
-  template <typename T, std::size_t NumElements> \
-  _SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if_t<is_genfloat<T>::value || is_gencomplex<T>::value, sycl::marray<rtn_type, NumElements>> \
-  math_func(const sycl::marray<arg_type, NumElements> &x) { \
+#define MATH_OP_ONE_PARAM(math_func, rtn_type, arg_type)                       \
+  template <typename T, std::size_t NumElements>                               \
+  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
+      typename std::enable_if_t<is_genfloat<T>::value ||                       \
+                                    is_gencomplex<T>::value,                   \
+                                sycl::marray<rtn_type, NumElements>>           \
+      math_func(const sycl::marray<arg_type, NumElements> &x) {                \
     sycl::marray<rtn_type, NumElements> rtn;                                   \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = math_func(x[i]);               \
+      rtn[i] = math_func(x[i]);                                                \
     }                                                                          \
     return rtn;                                                                \
   }
@@ -1354,30 +1356,42 @@ MATH_OP_ONE_PARAM(tanh, complex<T>, complex<T>);
 
 #undef MATH_OP_ONE_PARAM
 
-#define MATH_OP_TWO_PARAM(math_func, rtn_type, arg_type1, arg_type2)                                                          \
-  template <typename T, std::size_t NumElements> \
-  _SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if_t<is_genfloat<T>::value || is_gencomplex<T>::value, sycl::marray<rtn_type, NumElements>> \
-  math_func(const sycl::marray<arg_type1, NumElements> &x, const sycl::marray<arg_type2, NumElements> &y) {                   \
+#define MATH_OP_TWO_PARAM(math_func, rtn_type, arg_type1, arg_type2)           \
+  template <typename T, std::size_t NumElements>                               \
+  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
+      typename std::enable_if_t<is_genfloat<T>::value ||                       \
+                                    is_gencomplex<T>::value,                   \
+                                sycl::marray<rtn_type, NumElements>>           \
+      math_func(const sycl::marray<arg_type1, NumElements> &x,                 \
+                const sycl::marray<arg_type2, NumElements> &y) {               \
     sycl::marray<rtn_type, NumElements> rtn;                                   \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = math_func(x[i], y[i]);         \
+      rtn[i] = math_func(x[i], y[i]);                                          \
     }                                                                          \
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  template <typename T, std::size_t NumElements> \
-   _SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if_t<is_genfloat<T>::value || is_gencomplex<T>::value, sycl::marray<rtn_type, NumElements>> \
-  math_func(const sycl::marray<arg_type1, NumElements> &x, const arg_type2 &y) {                    \
+  template <typename T, std::size_t NumElements>                               \
+  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
+      typename std::enable_if_t<is_genfloat<T>::value ||                       \
+                                    is_gencomplex<T>::value,                   \
+                                sycl::marray<rtn_type, NumElements>>           \
+      math_func(const sycl::marray<arg_type1, NumElements> &x,                 \
+                const arg_type2 &y) {                                          \
     sycl::marray<rtn_type, NumElements> rtn;                                   \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = math_func(x[i], y);            \
+      rtn[i] = math_func(x[i], y);                                             \
     }                                                                          \
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  template <typename T, std::size_t NumElements> \
-  _SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if_t<is_genfloat<T>::value || is_gencomplex<T>::value, sycl::marray<rtn_type, NumElements>> \
-  math_func(const arg_type1 &x, const sycl::marray<arg_type2, NumElements> &y) {                   \
+  template <typename T, std::size_t NumElements>                               \
+  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
+      typename std::enable_if_t<is_genfloat<T>::value ||                       \
+                                    is_gencomplex<T>::value,                   \
+                                sycl::marray<rtn_type, NumElements>>           \
+      math_func(const arg_type1 &x,                                            \
+                const sycl::marray<arg_type2, NumElements> &y) {               \
     sycl::marray<rtn_type, NumElements> rtn;                                   \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = math_func(x, y[i]);                                             \
@@ -1394,8 +1408,11 @@ MATH_OP_TWO_PARAM(pow, complex<T>, T, complex<T>);
 // Special definition as polar requires default argument
 
 template <typename T, std::size_t NumElements>
-_SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if_t<is_genfloat<T>::value, sycl::marray<complex<T>, NumElements>>
-polar(const sycl::marray<T, NumElements> &rho, const sycl::marray<T, NumElements> &theta) {
+_SYCL_EXT_CPLX_INLINE_VISIBILITY
+    typename std::enable_if_t<is_genfloat<T>::value,
+                              sycl::marray<complex<T>, NumElements>>
+    polar(const sycl::marray<T, NumElements> &rho,
+          const sycl::marray<T, NumElements> &theta) {
   sycl::marray<complex<T>, NumElements> rtn;
   for (std::size_t i = 0; i < NumElements; ++i) {
     rtn[i] = polar(rho[i], theta[i]);
@@ -1404,8 +1421,10 @@ polar(const sycl::marray<T, NumElements> &rho, const sycl::marray<T, NumElements
 }
 
 template <typename T, std::size_t NumElements>
-_SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if_t<is_genfloat<T>::value, sycl::marray<complex<T>, NumElements>>
-polar(const sycl::marray<T, NumElements> &rho, const T &theta = 0) {
+_SYCL_EXT_CPLX_INLINE_VISIBILITY
+    typename std::enable_if_t<is_genfloat<T>::value,
+                              sycl::marray<complex<T>, NumElements>>
+    polar(const sycl::marray<T, NumElements> &rho, const T &theta = 0) {
   sycl::marray<complex<T>, NumElements> rtn;
   for (std::size_t i = 0; i < NumElements; ++i) {
     rtn[i] = polar(rho[i], theta);
@@ -1413,10 +1432,11 @@ polar(const sycl::marray<T, NumElements> &rho, const T &theta = 0) {
   return rtn;
 }
 
-
 template <typename T, std::size_t NumElements>
-_SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if_t<is_genfloat<T>::value, sycl::marray<complex<T>, NumElements>>
-polar(const T &rho, const sycl::marray<T, NumElements> &theta) {
+_SYCL_EXT_CPLX_INLINE_VISIBILITY
+    typename std::enable_if_t<is_genfloat<T>::value,
+                              sycl::marray<complex<T>, NumElements>>
+    polar(const T &rho, const sycl::marray<T, NumElements> &theta) {
   sycl::marray<complex<T>, NumElements> rtn;
   for (std::size_t i = 0; i < NumElements; ++i) {
     rtn[i] = polar(rho, theta[i]);

From e4a1dbd1ad4f99d850c1da64998a39ce0194b3e7 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Mon, 7 Aug 2023 08:44:21 +0200
Subject: [PATCH 22/39] Remove special test cases for windows

---
 sycl/test-e2e/Complex/sycl_complex_marray_test_cases.hpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_test_cases.hpp b/sycl/test-e2e/Complex/sycl_complex_marray_test_cases.hpp
index 43436d024bc70..e914631ea0419 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_test_cases.hpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_test_cases.hpp
@@ -4,7 +4,7 @@
 
 #include "sycl_complex_helper.hpp"
 
-#define DEFAULT_TEST_CASE_SIZE 47
+#define DEFAULT_TEST_CASE_SIZE 45
 #define POLAR_TEST_CASE_SIZE 9
 #define GETTERS_TEST_CASE_SIZE 8
 
@@ -101,8 +101,7 @@ std::vector<cmplx<double>>
     marray_cplx_test_cases<test_struct>::std_test_values = {
         cmplx<double>(0, 1),           cmplx<double>(0, -1),
         cmplx<double>(0, 0.5),         cmplx<double>(0, -0.5),
-        cmplx<double>(0, 0),           cmplx<double>(0, INFINITYd),
-        cmplx<double>(0, NANd),
+        cmplx<double>(0, INFINITYd),   cmplx<double>(0, NANd),
 
         cmplx<double>(1, 1),           cmplx<double>(1, -1),
         cmplx<double>(1, 0.5),         cmplx<double>(1, -0.5),
@@ -126,7 +125,7 @@ std::vector<cmplx<double>>
 
         cmplx<double>(INFINITYd, 1),   cmplx<double>(INFINITYd, -1),
         cmplx<double>(INFINITYd, 0.5), cmplx<double>(INFINITYd, -0.5),
-        cmplx<double>(INFINITYd, 0),   cmplx<double>(INFINITYd, INFINITYd),
+        cmplx<double>(INFINITYd, 0),
 
         cmplx<double>(NANd, 1),        cmplx<double>(NANd, -1),
         cmplx<double>(NANd, 0.5),      cmplx<double>(NANd, -0.5),

From d2df5d1995abb7c0e6f20afb6a930dd114b2ef22 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Mon, 7 Aug 2023 10:35:09 +0200
Subject: [PATCH 23/39] Fix marray<std::complex<>> casting to never be a
 marray<std::complex<half>>

---
 .../Complex/sycl_complex_marray_math_test.cpp | 32 ++++++++++++-------
 .../sycl_complex_marray_operator_test.cpp     | 26 +++++++++------
 2 files changed, 36 insertions(+), 22 deletions(-)

diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
index abd711a04915b..466b155e93f3c 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
@@ -23,7 +23,7 @@
                                               static_cast<T>(init[i].im)};     \
       }                                                                        \
                                                                                \
-      sycl::marray<std::complex<T>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
+      sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
       auto *cplx_out = sycl::malloc_shared<                                    \
           sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1,   \
                                                                           Q);  \
@@ -45,11 +45,13 @@
       Q.single_task([=]() {                                                    \
          *cplx_out = experimental::func_name(cplx_in);                         \
        }).wait();                                                              \
-      pass &= check_results(*cplx_out, std_out, /*is_device*/ true);           \
+      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+                            /*is_device*/ true);                               \
                                                                                \
       /* Check cplx::complex output from host */                               \
       *cplx_out = experimental::func_name(cplx_in);                            \
-      pass &= check_results(*cplx_out, std_out, /*is_device*/ false);          \
+      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+                            /*is_device*/ false);                              \
                                                                                \
       sycl::free(cplx_out, Q);                                                 \
                                                                                \
@@ -203,7 +205,7 @@ template <typename T> struct test_pow_cplx_cplx {
                                             static_cast<T>(init[i].im)};
     }
 
-    sycl::marray<std::complex<T>, DEFAULT_TEST_CASE_SIZE> std_out{};
+    sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_out{};
     auto *cplx_out = sycl::malloc_shared<
         sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1, Q);
 
@@ -224,11 +226,13 @@ template <typename T> struct test_pow_cplx_cplx {
     Q.single_task([=]() {
        *cplx_out = experimental::pow(cplx_in, cplx_in);
      }).wait();
-    pass &= check_results(*cplx_out, std_out, /*is_device*/ true);
+    pass &= check_results(*cplx_out, convert_marray<T>(std_out),
+                          /*is_device*/ true);
 
     /* Check cplx::complex output from host */
     *cplx_out = experimental::pow(cplx_in, cplx_in);
-    pass &= check_results(*cplx_out, std_out, /*is_device*/ false);
+    pass &= check_results(*cplx_out, convert_marray<T>(std_out),
+                          /*is_device*/ false);
 
     sycl::free(cplx_out, Q);
 
@@ -256,7 +260,7 @@ template <typename T> struct test_pow_cplx_deci {
                                             static_cast<T>(init[i].im)};
     }
 
-    sycl::marray<std::complex<T>, DEFAULT_TEST_CASE_SIZE> std_out{};
+    sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_out{};
     auto *cplx_out = sycl::malloc_shared<
         sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1, Q);
 
@@ -277,11 +281,13 @@ template <typename T> struct test_pow_cplx_deci {
     Q.single_task([=]() {
        *cplx_out = experimental::pow(cplx_in, cplx_in.real());
      }).wait();
-    pass &= check_results(*cplx_out, std_out, /*is_device*/ true);
+    pass &= check_results(*cplx_out, convert_marray<T>(std_out),
+                          /*is_device*/ true);
 
     /* Check cplx::complex output from host */
     *cplx_out = experimental::pow(cplx_in, cplx_in.real());
-    pass &= check_results(*cplx_out, std_out, /*is_device*/ false);
+    pass &= check_results(*cplx_out, convert_marray<T>(std_out),
+                          /*is_device*/ false);
 
     sycl::free(cplx_out, Q);
 
@@ -309,7 +315,7 @@ template <typename T> struct test_pow_deci_cplx {
                                             static_cast<T>(init[i].im)};
     }
 
-    sycl::marray<std::complex<T>, DEFAULT_TEST_CASE_SIZE> std_out{};
+    sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_out{};
     auto *cplx_out = sycl::malloc_shared<
         sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1, Q);
 
@@ -330,11 +336,13 @@ template <typename T> struct test_pow_deci_cplx {
     Q.single_task([=]() {
        *cplx_out = experimental::pow(cplx_in.real(), cplx_in);
      }).wait();
-    pass &= check_results(*cplx_out, std_out, /*is_device*/ true);
+    pass &= check_results(*cplx_out, convert_marray<T>(std_out),
+                          /*is_device*/ true);
 
     /* Check cplx::complex output from host */
     *cplx_out = experimental::pow(cplx_in.real(), cplx_in);
-    pass &= check_results(*cplx_out, std_out, /*is_device*/ false);
+    pass &= check_results(*cplx_out, convert_marray<T>(std_out),
+                          /*is_device*/ false);
 
     sycl::free(cplx_out, Q);
 
diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp
index 111100e50f8a5..c454a5ce76302 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp
@@ -24,7 +24,7 @@
                                               static_cast<T>(init[i].im)};     \
       }                                                                        \
                                                                                \
-      sycl::marray<std::complex<T>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
+      sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
       auto *cplx_out = sycl::malloc_shared<                                    \
           sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1,   \
                                                                           Q);  \
@@ -44,11 +44,13 @@
                                                                                \
       /* Check cplx::complex output from device */                             \
       Q.single_task([=]() { *cplx_out = cplx_in op cplx_in; }).wait();         \
-      pass &= check_results(*cplx_out, std_out, /*is_device*/ true);           \
+      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+                            /*is_device*/ true);                               \
                                                                                \
       /* Check cplx::complex output from host */                               \
       *cplx_out = cplx_in op cplx_in;                                          \
-      pass &= check_results(*cplx_out, std_out, /*is_device*/ false);          \
+      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+                            /*is_device*/ false);                              \
                                                                                \
       sycl::free(cplx_out, Q);                                                 \
                                                                                \
@@ -84,12 +86,12 @@ TEST_BASIC_OPERATOR(div, /)
                                               static_cast<T>(init[i].im)};     \
       }                                                                        \
                                                                                \
-      sycl::marray<std::complex<T>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
+      sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
       auto *cplx_out = sycl::malloc_shared<                                    \
           sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1,   \
                                                                           Q);  \
                                                                                \
-      std_out = convert_marray<T, X>(std_in);                                  \
+      std_out = std_in;                                                        \
       *cplx_out = cplx_in;                                                     \
                                                                                \
       /* Get std::complex output */                                            \
@@ -107,13 +109,15 @@ TEST_BASIC_OPERATOR(div, /)
                                                                                \
       /* Check cplx::complex output from device */                             \
       Q.single_task([=]() { *cplx_out op cplx_in; }).wait();                   \
-      pass &= check_results(*cplx_out, std_out, /*is_device*/ true);           \
+      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+                            /*is_device*/ true);                               \
                                                                                \
       *cplx_out = cplx_in;                                                     \
                                                                                \
       /* Check cplx::complex output from host */                               \
       *cplx_out op cplx_in;                                                    \
-      pass &= check_results(*cplx_out, std_out, /*is_device*/ false);          \
+      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+                            /*is_device*/ false);                              \
                                                                                \
       sycl::free(cplx_out, Q);                                                 \
                                                                                \
@@ -149,7 +153,7 @@ TEST_ASSIGN_OPERATOR(assign_div, /=)
                                               static_cast<T>(init[i].im)};     \
       }                                                                        \
                                                                                \
-      sycl::marray<std::complex<T>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
+      sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
       auto *cplx_out = sycl::malloc_shared<                                    \
           sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1,   \
                                                                           Q);  \
@@ -169,11 +173,13 @@ TEST_ASSIGN_OPERATOR(assign_div, /=)
                                                                                \
       /* Check cplx::complex output from device */                             \
       Q.single_task([=]() { *cplx_out = op cplx_in; }).wait();                 \
-      pass &= check_results(*cplx_out, std_out, /*is_device*/ true);           \
+      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+                            /*is_device*/ true);                               \
                                                                                \
       /* Check cplx::complex output from host */                               \
       *cplx_out = op cplx_in;                                                  \
-      pass &= check_results(*cplx_out, std_out, /*is_device*/ false);          \
+      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+                            /*is_device*/ false);                              \
                                                                                \
       sycl::free(cplx_out, Q);                                                 \
                                                                                \

From 8d086dd8e60e6808cd9445e484f8f14ce827b6d7 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Tue, 8 Aug 2023 09:56:30 +0200
Subject: [PATCH 24/39] Use a less conflicting name for defining the marray's
 macros

---
 .../ext/oneapi/experimental/sycl_complex.hpp  | 205 ++++++++++--------
 1 file changed, 109 insertions(+), 96 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
index 4e5968fc2f554..9e709e9a2403e 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
@@ -1078,8 +1078,12 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   iterator end() { return MData + NumElements; }
   const_iterator end() const { return MData + NumElements; }
 
-  // OP is: +, -, *, /
-#define OP(op)                                                                 \
+#ifdef MARRAY_CPLX_OP
+#error "Multiple definition of MARRAY_CPLX_OP"
+#endif
+
+  // MARRAY_CPLX_OP is: +, -, *, /
+#define MARRAY_CPLX_OP(op)                                                     \
   friend marray operator op(const marray &lhs, const marray &rhs) {            \
     marray rtn;                                                                \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
@@ -1104,20 +1108,20 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }
 
-  OP(+)
-  OP(-)
-  OP(*)
-  OP(/)
+  MARRAY_CPLX_OP(+)
+  MARRAY_CPLX_OP(-)
+  MARRAY_CPLX_OP(*)
+  MARRAY_CPLX_OP(/)
 
-#undef OP
+#undef MARRAY_CPLX_OP
 
-  // OP is: %
+  // MARRAY_CPLX_OP is: %
   friend marray operator%(const marray &lhs, const marray &rhs) = delete;
   friend marray operator%(const marray &lhs, const value_type &rhs) = delete;
   friend marray operator%(const value_type &lhs, const marray &rhs) = delete;
 
-  // OP is: +=, -=, *=, /=
-#define OP(op)                                                                 \
+  // MARRAY_CPLX_OP is: +=, -=, *=, /=
+#define MARRAY_CPLX_OP(op)                                                     \
   friend marray &operator op(marray &lhs, const marray &rhs) {                 \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       lhs[i] op rhs[i];                                                        \
@@ -1138,30 +1142,30 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return lhs;                                                                \
   }
 
-  OP(+=)
-  OP(-=)
-  OP(*=)
-  OP(/=)
+  MARRAY_CPLX_OP(+=)
+  MARRAY_CPLX_OP(-=)
+  MARRAY_CPLX_OP(*=)
+  MARRAY_CPLX_OP(/=)
 
-#undef OP
+#undef MARRAY_CPLX_OP
 
-  // OP is: %=
+  // MARRAY_CPLX_OP is: %=
   friend marray &operator%=(marray &lhs, const marray &rhs) = delete;
   friend marray &operator%=(marray &lhs, const value_type &rhs) = delete;
   friend marray &operator%=(value_type &lhs, const marray &rhs) = delete;
 
-// OP is: ++, --
-#define OP(op)                                                                 \
+// MARRAY_CPLX_OP is: ++, --
+#define MARRAY_CPLX_OP(op)                                                     \
   friend marray operator op(marray &lhs, int) = delete;                        \
   friend marray &operator op(marray &rhs) = delete;
 
-  OP(++)
-  OP(--)
+  MARRAY_CPLX_OP(++)
+  MARRAY_CPLX_OP(--)
 
-#undef OP
+#undef MARRAY_CPLX_OP
 
-// OP is: unary +, unary -
-#define OP(op)                                                                 \
+// MARRAY_CPLX_OP is: unary +, unary -
+#define MARRAY_CPLX_OP(op)                                                     \
   friend marray<value_type, NumElements> operator op(                          \
       const marray<value_type, NumElements> &rhs) {                            \
     marray<value_type, NumElements> rtn;                                       \
@@ -1171,36 +1175,36 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }
 
-  OP(+)
-  OP(-)
+  MARRAY_CPLX_OP(+)
+  MARRAY_CPLX_OP(-)
 
-#undef OP
+#undef MARRAY_CPLX_OP
 
-// OP is: &, |, ^
-#define OP(op)                                                                 \
+// MARRAY_CPLX_OP is: &, |, ^
+#define MARRAY_CPLX_OP(op)                                                     \
   friend marray operator op(const marray &lhs, const marray &rhs) = delete;    \
   friend marray operator op(const marray &lhs, const value_type &rhs) = delete;
 
-  OP(&)
-  OP(|)
-  OP(^)
+  MARRAY_CPLX_OP(&)
+  MARRAY_CPLX_OP(|)
+  MARRAY_CPLX_OP(^)
 
-#undef OP
+#undef MARRAY_CPLX_OP
 
-// OP is: &=, |=, ^=
-#define OP(op)                                                                 \
+// MARRAY_CPLX_OP is: &=, |=, ^=
+#define MARRAY_CPLX_OP(op)                                                     \
   friend marray &operator op(marray &lhs, const marray &rhs) = delete;         \
   friend marray &operator op(marray &lhs, const value_type &rhs) = delete;     \
   friend marray &operator op(value_type &lhs, const marray &rhs) = delete;
 
-  OP(&=)
-  OP(|=)
-  OP(^=)
+  MARRAY_CPLX_OP(&=)
+  MARRAY_CPLX_OP(|=)
+  MARRAY_CPLX_OP(^=)
 
-#undef OP
+#undef MARRAY_CPLX_OP
 
-// OP is: &&, ||
-#define OP(op)                                                                 \
+// MARRAY_CPLX_OP is: &&, ||
+#define MARRAY_CPLX_OP(op)                                                     \
   friend marray<bool, NumElements> operator op(const marray &lhs,              \
                                                const marray &rhs) = delete;    \
   friend marray<bool, NumElements> operator op(                                \
@@ -1208,35 +1212,35 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   friend marray<bool, NumElements> operator op(const value_type &lhs,          \
                                                const marray &rhs) = delete;
 
-  OP(&&)
-  OP(||)
+  MARRAY_CPLX_OP(&&)
+  MARRAY_CPLX_OP(||)
 
-#undef OP
+#undef MARRAY_CPLX_OP
 
-// OP is: <<, >>
-#define OP(op)                                                                 \
+// MARRAY_CPLX_OP is: <<, >>
+#define MARRAY_CPLX_OP(op)                                                     \
   friend marray operator op(const marray &lhs, const marray &rhs) = delete;    \
   friend marray operator op(const marray &lhs, const value_type &rhs) =        \
       delete;                                                                  \
   friend marray operator op(const value_type &lhs, const marray &rhs) = delete;
 
-  OP(<<)
-  OP(>>)
+  MARRAY_CPLX_OP(<<)
+  MARRAY_CPLX_OP(>>)
 
-#undef OP
+#undef MARRAY_CPLX_OP
 
-// OP is: <<=, >>=
-#define OP(op)                                                                 \
+// MARRAY_CPLX_OP is: <<=, >>=
+#define MARRAY_CPLX_OP(op)                                                     \
   friend marray &operator op(marray &lhs, const marray &rhs) = delete;         \
   friend marray &operator op(marray &lhs, const value_type &rhs) = delete;
 
-  OP(<<=)
-  OP(>>=)
+  MARRAY_CPLX_OP(<<=)
+  MARRAY_CPLX_OP(>>=)
 
-#undef OP
+#undef MARRAY_CPLX_OP
 
-  // OP is: ==, !=
-#define OP(op)                                                                 \
+  // MARRAY_CPLX_OP is: ==, !=
+#define MARRAY_CPLX_OP(op)                                                     \
   friend marray<bool, NumElements> operator op(const marray &lhs,              \
                                                const marray &rhs) {            \
     marray<bool, NumElements> rtn;                                             \
@@ -1264,13 +1268,13 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }
 
-  OP(==)
-  OP(!=)
+  MARRAY_CPLX_OP(==)
+  MARRAY_CPLX_OP(!=)
 
-#undef OP
+#undef MARRAY_CPLX_OP
 
-  // OP is: <, >, <=, >=
-#define OP(op)                                                                 \
+  // MARRAY_CPLX_OP is: <, >, <=, >=
+#define MARRAY_CPLX_OP(op)                                                     \
   friend marray<bool, NumElements> operator op(const marray &lhs,              \
                                                const marray &rhs) = delete;    \
   friend marray<bool, NumElements> operator op(                                \
@@ -1278,12 +1282,12 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   friend marray<bool, NumElements> operator op(const value_type &lhs,          \
                                                const marray &rhs) = delete;
 
-  OP(<);
-  OP(>);
-  OP(<=);
-  OP(>=);
+  MARRAY_CPLX_OP(<);
+  MARRAY_CPLX_OP(>);
+  MARRAY_CPLX_OP(<=);
+  MARRAY_CPLX_OP(>=);
 
-#undef OP
+#undef MARRAY_CPLX_OP
 
   friend marray operator~(const marray &v) = delete;
 
@@ -1296,7 +1300,11 @@ namespace experimental {
 
 // Math marray overloads
 
-#define MATH_OP_ONE_PARAM(math_func, rtn_type, arg_type)                       \
+#ifdef MARRAY_CPLX_MATH_OP_ONE_PARAM
+#error "Multiple definition of MARRAY_CPLX_MATH_OP_ONE_PARAM"
+#endif
+
+#define MARRAY_CPLX_MATH_OP_ONE_PARAM(math_func, rtn_type, arg_type)           \
   template <typename T, std::size_t NumElements>                               \
   _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
       typename std::enable_if_t<is_genfloat<T>::value ||                       \
@@ -1310,32 +1318,37 @@ namespace experimental {
     return rtn;                                                                \
   }
 
-MATH_OP_ONE_PARAM(abs, T, complex<T>);
-MATH_OP_ONE_PARAM(acos, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(asin, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(atan, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(acosh, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(asinh, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(atanh, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(arg, T, complex<T>);
-MATH_OP_ONE_PARAM(conj, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(cos, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(cosh, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(exp, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(log, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(log10, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(norm, T, complex<T>);
-MATH_OP_ONE_PARAM(proj, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(proj, complex<T>, T);
-MATH_OP_ONE_PARAM(sin, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(sinh, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(sqrt, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(tan, complex<T>, complex<T>);
-MATH_OP_ONE_PARAM(tanh, complex<T>, complex<T>);
-
-#undef MATH_OP_ONE_PARAM
-
-#define MATH_OP_TWO_PARAM(math_func, rtn_type, arg_type1, arg_type2)           \
+MARRAY_CPLX_MATH_OP_ONE_PARAM(abs, T, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(acos, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(asin, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(atan, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(acosh, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(asinh, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(atanh, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(arg, T, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(conj, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(cos, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(cosh, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(exp, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(log, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(log10, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(norm, T, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(proj, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(proj, complex<T>, T);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(sin, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(sinh, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(sqrt, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(tan, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(tanh, complex<T>, complex<T>);
+
+#undef MARRAY_CPLX_MATH_OP_ONE_PARAM
+
+#ifdef MARRAY_CPLX_MATH_OP_TWO_PARAM
+#error "Multiple definition of MARRAY_CPLX_MATH_OP_TWO_PARAM"
+#endif
+
+#define MARRAY_CPLX_MATH_OP_TWO_PARAM(math_func, rtn_type, arg_type1,          \
+                                      arg_type2)                               \
   template <typename T, std::size_t NumElements>                               \
   _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
       typename std::enable_if_t<is_genfloat<T>::value ||                       \
@@ -1378,11 +1391,11 @@ MATH_OP_ONE_PARAM(tanh, complex<T>, complex<T>);
     return rtn;                                                                \
   }
 
-MATH_OP_TWO_PARAM(pow, complex<T>, complex<T>, T);
-MATH_OP_TWO_PARAM(pow, complex<T>, complex<T>, complex<T>);
-MATH_OP_TWO_PARAM(pow, complex<T>, T, complex<T>);
+MARRAY_CPLX_MATH_OP_TWO_PARAM(pow, complex<T>, complex<T>, T);
+MARRAY_CPLX_MATH_OP_TWO_PARAM(pow, complex<T>, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_TWO_PARAM(pow, complex<T>, T, complex<T>);
 
-#undef MATH_OP_TWO_PARAM
+#undef MARRAY_CPLX_MATH_OP_TWO_PARAM
 
 // Special definition as polar requires default argument
 

From b92cce6ea00f75be8deb57b1e9f2b0f37202e67a Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Tue, 12 Sep 2023 09:44:44 +0200
Subject: [PATCH 25/39] Apply clang-format

---
 .../ext/oneapi/experimental/sycl_complex.hpp  | 50 +++++++++----------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
index bdeba6a43d41f..f58eafefeb67e 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
@@ -1150,20 +1150,20 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
   // MARRAY_CPLX_OP is: +=, -=, *=, /=
 #define MARRAY_CPLX_OP(op)                                                     \
-  friend marray &operator op(marray &lhs, const marray &rhs) {                 \
+  friend marray &operator op(marray & lhs, const marray & rhs) {               \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       lhs[i] op rhs[i];                                                        \
     }                                                                          \
     return lhs;                                                                \
   }                                                                            \
                                                                                \
-  friend marray &operator op(marray &lhs, const value_type &rhs) {             \
+  friend marray &operator op(marray & lhs, const value_type & rhs) {           \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       lhs[i] op rhs;                                                           \
     }                                                                          \
     return lhs;                                                                \
   }                                                                            \
-  friend marray &operator op(value_type &lhs, const marray &rhs) {             \
+  friend marray &operator op(value_type & lhs, const marray & rhs) {           \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       lhs[i] op rhs;                                                           \
     }                                                                          \
@@ -1185,7 +1185,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 // MARRAY_CPLX_OP is: ++, --
 #define MARRAY_CPLX_OP(op)                                                     \
   friend marray operator op(marray &lhs, int) = delete;                        \
-  friend marray &operator op(marray &rhs) = delete;
+  friend marray &operator op(marray & rhs) = delete;
 
   MARRAY_CPLX_OP(++)
   MARRAY_CPLX_OP(--)
@@ -1221,9 +1221,9 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
 // MARRAY_CPLX_OP is: &=, |=, ^=
 #define MARRAY_CPLX_OP(op)                                                     \
-  friend marray &operator op(marray &lhs, const marray &rhs) = delete;         \
-  friend marray &operator op(marray &lhs, const value_type &rhs) = delete;     \
-  friend marray &operator op(value_type &lhs, const marray &rhs) = delete;
+  friend marray &operator op(marray & lhs, const marray & rhs) = delete;       \
+  friend marray &operator op(marray & lhs, const value_type & rhs) = delete;   \
+  friend marray &operator op(value_type & lhs, const marray & rhs) = delete;
 
   MARRAY_CPLX_OP(&=)
   MARRAY_CPLX_OP(|=)
@@ -1233,12 +1233,12 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
 // MARRAY_CPLX_OP is: &&, ||
 #define MARRAY_CPLX_OP(op)                                                     \
-  friend marray<bool, NumElements> operator op(const marray &lhs,              \
-                                               const marray &rhs) = delete;    \
+  friend marray<bool, NumElements> operator op(const marray & lhs,             \
+                                               const marray & rhs) = delete;   \
   friend marray<bool, NumElements> operator op(                                \
-      const marray &lhs, const value_type &rhs) = delete;                      \
-  friend marray<bool, NumElements> operator op(const value_type &lhs,          \
-                                               const marray &rhs) = delete;
+      const marray & lhs, const value_type & rhs) = delete;                    \
+  friend marray<bool, NumElements> operator op(const value_type & lhs,         \
+                                               const marray & rhs) = delete;
 
   MARRAY_CPLX_OP(&&)
   MARRAY_CPLX_OP(||)
@@ -1259,8 +1259,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
 // MARRAY_CPLX_OP is: <<=, >>=
 #define MARRAY_CPLX_OP(op)                                                     \
-  friend marray &operator op(marray &lhs, const marray &rhs) = delete;         \
-  friend marray &operator op(marray &lhs, const value_type &rhs) = delete;
+  friend marray &operator op(marray & lhs, const marray & rhs) = delete;       \
+  friend marray &operator op(marray & lhs, const value_type & rhs) = delete;
 
   MARRAY_CPLX_OP(<<=)
   MARRAY_CPLX_OP(>>=)
@@ -1269,8 +1269,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
   // MARRAY_CPLX_OP is: ==, !=
 #define MARRAY_CPLX_OP(op)                                                     \
-  friend marray<bool, NumElements> operator op(const marray &lhs,              \
-                                               const marray &rhs) {            \
+  friend marray<bool, NumElements> operator op(const marray & lhs,             \
+                                               const marray & rhs) {           \
     marray<bool, NumElements> rtn;                                             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = lhs[i] op rhs[i];                                               \
@@ -1278,8 +1278,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  friend marray<bool, NumElements> operator op(const marray &lhs,              \
-                                               const value_type &rhs) {        \
+  friend marray<bool, NumElements> operator op(const marray & lhs,             \
+                                               const value_type & rhs) {       \
     marray<bool, NumElements> rtn;                                             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = lhs[i] op rhs;                                                  \
@@ -1287,8 +1287,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  friend marray<bool, NumElements> operator op(const value_type &lhs,          \
-                                               const marray &rhs) {            \
+  friend marray<bool, NumElements> operator op(const value_type & lhs,         \
+                                               const marray & rhs) {           \
     marray<bool, NumElements> rtn;                                             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = lhs op rhs[i];                                                  \
@@ -1303,12 +1303,12 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
   // MARRAY_CPLX_OP is: <, >, <=, >=
 #define MARRAY_CPLX_OP(op)                                                     \
-  friend marray<bool, NumElements> operator op(const marray &lhs,              \
-                                               const marray &rhs) = delete;    \
+  friend marray<bool, NumElements> operator op(const marray & lhs,             \
+                                               const marray & rhs) = delete;   \
   friend marray<bool, NumElements> operator op(                                \
-      const marray &lhs, const value_type &rhs) = delete;                      \
-  friend marray<bool, NumElements> operator op(const value_type &lhs,          \
-                                               const marray &rhs) = delete;
+      const marray & lhs, const value_type & rhs) = delete;                    \
+  friend marray<bool, NumElements> operator op(const value_type & lhs,         \
+                                               const marray & rhs) = delete;
 
   MARRAY_CPLX_OP(<);
   MARRAY_CPLX_OP(>);

From a179509346910c0d409b6590576517799f51c0c7 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Thu, 2 Nov 2023 10:01:00 +0100
Subject: [PATCH 26/39] Split marray header file and tests into multiple files

---
 .../oneapi/experimental/complex/complex.hpp   |   2 +
 .../complex/detail/complex_math.hpp           | 458 ------------------
 .../experimental/complex/detail/marray.hpp    | 332 +++++++++++++
 .../complex/detail/marray_math.hpp            | 163 +++++++
 .../marray.cpp}                               |   2 +-
 5 files changed, 498 insertions(+), 459 deletions(-)
 create mode 100644 sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
 create mode 100644 sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp
 rename sycl/test/extensions/{test_marray_complex.cpp => complex/marray.cpp} (99%)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/complex/complex.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/complex.hpp
index ad6653081ff48..aeac3ced79c5f 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/complex/complex.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/complex.hpp
@@ -12,5 +12,7 @@
 
 #include "./detail/complex.hpp"
 #include "./detail/complex_math.hpp"
+#include "./detail/marray.hpp"
+#include "./detail/marray_math.hpp"
 
 #endif // SYCL_EXT_ONEAPI_COMPLEX
diff --git a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/complex_math.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/complex_math.hpp
index 094dd48332e6a..cca76b7e988a5 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/complex_math.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/complex_math.hpp
@@ -628,463 +628,5 @@ __DPCPP_SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY constexpr
 } // namespace oneapi
 } // namespace ext
 
-template <typename T> using marray_data = sycl::detail::vec_helper<T>;
-
-template <typename T>
-using marray_data_t = typename detail::vec_helper<T>::RetType;
-
-template <typename T, std::size_t NumElements>
-class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
-private:
-  using ComplexDataT = sycl::ext::oneapi::experimental::complex<T>;
-
-public:
-  using value_type = ComplexDataT;
-  using reference = ComplexDataT &;
-  using const_reference = const ComplexDataT &;
-  using iterator = ComplexDataT *;
-  using const_iterator = const ComplexDataT *;
-
-private:
-  value_type MData[NumElements];
-
-  template <size_t... Is>
-  constexpr marray(const std::array<value_type, NumElements> &Arr,
-                   std::index_sequence<Is...>)
-      : MData{Arr[Is]...} {}
-
-  /// FIXME: If the subscript operator is made constexpr this can be removed.
-  // detail::HelperFlattenMArrayArg::MArrayToArray needs to have access to
-  // MData.
-  friend class detail::HelperFlattenMArrayArg;
-
-public:
-  constexpr marray() : MData{} {};
-
-  explicit constexpr marray(const value_type &arg)
-      : marray{sycl::detail::RepeatValue<NumElements>(
-                   static_cast<marray_data_t<value_type>>(arg)),
-               std::make_index_sequence<NumElements>()} {}
-
-  template <
-      typename... ArgTN,
-      typename = std::enable_if_t<
-          sycl::detail::AllSuitableArgTypes<value_type, ArgTN...>::value &&
-          sycl::detail::GetMArrayArgsSize<ArgTN...>::value == NumElements>>
-  constexpr marray(const ArgTN &...Args)
-      : marray{
-            sycl::detail::MArrayArgArrayCreator<value_type, ArgTN...>::Create(
-                Args...),
-            std::make_index_sequence<NumElements>()} {}
-
-  constexpr marray(const marray<value_type, NumElements> &rhs) = default;
-  constexpr marray(marray<value_type, NumElements> &&rhs) = default;
-
-  // Available only when: NumElements == 1
-  template <std::size_t N = NumElements,
-            typename = std::enable_if_t<N == 1, value_type>>
-  operator value_type() const {
-    return MData[0];
-  }
-
-  static constexpr std::size_t size() noexcept { return NumElements; }
-
-  marray<T, NumElements> real() const {
-    sycl::marray<T, NumElements> rtn;
-    for (std::size_t i = 0; i < NumElements; ++i) {
-      rtn[i] = MData[i].real();
-    }
-    return rtn;
-  }
-
-  marray<T, NumElements> imag() const {
-    sycl::marray<T, NumElements> rtn;
-    for (std::size_t i = 0; i < NumElements; ++i) {
-      rtn[i] = MData[i].imag();
-    }
-    return rtn;
-  }
-
-  // subscript operator
-  reference operator[](std::size_t i) { return MData[i]; }
-  const_reference operator[](std::size_t i) const { return MData[i]; }
-
-  marray &operator=(const marray<value_type, NumElements> &rhs) = default;
-  marray &operator=(const value_type &rhs) {
-    for (std::size_t i = 0; i < NumElements; ++i) {
-      MData[i] = rhs;
-    }
-    return *this;
-  }
-
-  // iterator functions
-  iterator begin() { return MData; }
-  const_iterator begin() const { return MData; }
-
-  iterator end() { return MData + NumElements; }
-  const_iterator end() const { return MData + NumElements; }
-
-#ifdef MARRAY_CPLX_OP
-#error "Multiple definition of MARRAY_CPLX_OP"
-#endif
-
-  // MARRAY_CPLX_OP is: +, -, *, /
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray operator op(const marray &lhs, const marray &rhs) {            \
-    marray rtn;                                                                \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = lhs[i] op rhs[i];                                               \
-    }                                                                          \
-    return rtn;                                                                \
-  }                                                                            \
-                                                                               \
-  friend marray operator op(const marray &lhs, const value_type &rhs) {        \
-    marray rtn;                                                                \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = lhs[i] op rhs;                                                  \
-    }                                                                          \
-    return rtn;                                                                \
-  }                                                                            \
-                                                                               \
-  friend marray operator op(const value_type &lhs, const marray &rhs) {        \
-    marray rtn;                                                                \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = lhs op rhs[i];                                                  \
-    }                                                                          \
-    return rtn;                                                                \
-  }
-
-  MARRAY_CPLX_OP(+)
-  MARRAY_CPLX_OP(-)
-  MARRAY_CPLX_OP(*)
-  MARRAY_CPLX_OP(/)
-
-#undef MARRAY_CPLX_OP
-
-  // MARRAY_CPLX_OP is: %
-  friend marray operator%(const marray &lhs, const marray &rhs) = delete;
-  friend marray operator%(const marray &lhs, const value_type &rhs) = delete;
-  friend marray operator%(const value_type &lhs, const marray &rhs) = delete;
-
-  // MARRAY_CPLX_OP is: +=, -=, *=, /=
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray &operator op(marray & lhs, const marray & rhs) {               \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      lhs[i] op rhs[i];                                                        \
-    }                                                                          \
-    return lhs;                                                                \
-  }                                                                            \
-                                                                               \
-  friend marray &operator op(marray & lhs, const value_type & rhs) {           \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      lhs[i] op rhs;                                                           \
-    }                                                                          \
-    return lhs;                                                                \
-  }                                                                            \
-  friend marray &operator op(value_type & lhs, const marray & rhs) {           \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      lhs[i] op rhs;                                                           \
-    }                                                                          \
-    return lhs;                                                                \
-  }
-
-  MARRAY_CPLX_OP(+=)
-  MARRAY_CPLX_OP(-=)
-  MARRAY_CPLX_OP(*=)
-  MARRAY_CPLX_OP(/=)
-
-#undef MARRAY_CPLX_OP
-
-  // MARRAY_CPLX_OP is: %=
-  friend marray &operator%=(marray &lhs, const marray &rhs) = delete;
-  friend marray &operator%=(marray &lhs, const value_type &rhs) = delete;
-  friend marray &operator%=(value_type &lhs, const marray &rhs) = delete;
-
-// MARRAY_CPLX_OP is: ++, --
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray operator op(marray &lhs, int) = delete;                        \
-  friend marray &operator op(marray & rhs) = delete;
-
-  MARRAY_CPLX_OP(++)
-  MARRAY_CPLX_OP(--)
-
-#undef MARRAY_CPLX_OP
-
-// MARRAY_CPLX_OP is: unary +, unary -
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray<value_type, NumElements> operator op(                          \
-      const marray<value_type, NumElements> &rhs) {                            \
-    marray<value_type, NumElements> rtn;                                       \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = op rhs[i];                                                      \
-    }                                                                          \
-    return rtn;                                                                \
-  }
-
-  MARRAY_CPLX_OP(+)
-  MARRAY_CPLX_OP(-)
-
-#undef MARRAY_CPLX_OP
-
-// MARRAY_CPLX_OP is: &, |, ^
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray operator op(const marray &lhs, const marray &rhs) = delete;    \
-  friend marray operator op(const marray &lhs, const value_type &rhs) = delete;
-
-  MARRAY_CPLX_OP(&)
-  MARRAY_CPLX_OP(|)
-  MARRAY_CPLX_OP(^)
-
-#undef MARRAY_CPLX_OP
-
-// MARRAY_CPLX_OP is: &=, |=, ^=
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray &operator op(marray & lhs, const marray & rhs) = delete;       \
-  friend marray &operator op(marray & lhs, const value_type & rhs) = delete;   \
-  friend marray &operator op(value_type & lhs, const marray & rhs) = delete;
-
-  MARRAY_CPLX_OP(&=)
-  MARRAY_CPLX_OP(|=)
-  MARRAY_CPLX_OP(^=)
-
-#undef MARRAY_CPLX_OP
-
-// MARRAY_CPLX_OP is: &&, ||
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray<bool, NumElements> operator op(const marray & lhs,             \
-                                               const marray & rhs) = delete;   \
-  friend marray<bool, NumElements> operator op(                                \
-      const marray & lhs, const value_type & rhs) = delete;                    \
-  friend marray<bool, NumElements> operator op(const value_type & lhs,         \
-                                               const marray & rhs) = delete;
-
-  MARRAY_CPLX_OP(&&)
-  MARRAY_CPLX_OP(||)
-
-#undef MARRAY_CPLX_OP
-
-// MARRAY_CPLX_OP is: <<, >>
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray operator op(const marray &lhs, const marray &rhs) = delete;    \
-  friend marray operator op(const marray &lhs, const value_type &rhs) =        \
-      delete;                                                                  \
-  friend marray operator op(const value_type &lhs, const marray &rhs) = delete;
-
-  MARRAY_CPLX_OP(<<)
-  MARRAY_CPLX_OP(>>)
-
-#undef MARRAY_CPLX_OP
-
-// MARRAY_CPLX_OP is: <<=, >>=
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray &operator op(marray & lhs, const marray & rhs) = delete;       \
-  friend marray &operator op(marray & lhs, const value_type & rhs) = delete;
-
-  MARRAY_CPLX_OP(<<=)
-  MARRAY_CPLX_OP(>>=)
-
-#undef MARRAY_CPLX_OP
-
-  // MARRAY_CPLX_OP is: ==, !=
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray<bool, NumElements> operator op(const marray & lhs,             \
-                                               const marray & rhs) {           \
-    marray<bool, NumElements> rtn;                                             \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = lhs[i] op rhs[i];                                               \
-    }                                                                          \
-    return rtn;                                                                \
-  }                                                                            \
-                                                                               \
-  friend marray<bool, NumElements> operator op(const marray & lhs,             \
-                                               const value_type & rhs) {       \
-    marray<bool, NumElements> rtn;                                             \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = lhs[i] op rhs;                                                  \
-    }                                                                          \
-    return rtn;                                                                \
-  }                                                                            \
-                                                                               \
-  friend marray<bool, NumElements> operator op(const value_type & lhs,         \
-                                               const marray & rhs) {           \
-    marray<bool, NumElements> rtn;                                             \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = lhs op rhs[i];                                                  \
-    }                                                                          \
-    return rtn;                                                                \
-  }
-
-  MARRAY_CPLX_OP(==)
-  MARRAY_CPLX_OP(!=)
-
-#undef MARRAY_CPLX_OP
-
-  // MARRAY_CPLX_OP is: <, >, <=, >=
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray<bool, NumElements> operator op(const marray & lhs,             \
-                                               const marray & rhs) = delete;   \
-  friend marray<bool, NumElements> operator op(                                \
-      const marray & lhs, const value_type & rhs) = delete;                    \
-  friend marray<bool, NumElements> operator op(const value_type & lhs,         \
-                                               const marray & rhs) = delete;
-
-  MARRAY_CPLX_OP(<);
-  MARRAY_CPLX_OP(>);
-  MARRAY_CPLX_OP(<=);
-  MARRAY_CPLX_OP(>=);
-
-#undef MARRAY_CPLX_OP
-
-  friend marray operator~(const marray &v) = delete;
-
-  friend marray<bool, NumElements> operator!(const marray &v) = delete;
-};
-
-namespace ext {
-namespace oneapi {
-namespace experimental {
-
-// Math marray overloads
-
-#ifdef MARRAY_CPLX_MATH_OP_ONE_PARAM
-#error "Multiple definition of MARRAY_CPLX_MATH_OP_ONE_PARAM"
-#endif
-
-#define MARRAY_CPLX_MATH_OP_ONE_PARAM(math_func, rtn_type, arg_type)           \
-  template <typename T, std::size_t NumElements>                               \
-  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
-      typename std::enable_if_t<is_genfloat<T>::value ||                       \
-                                    is_gencomplex<T>::value,                   \
-                                sycl::marray<rtn_type, NumElements>>           \
-      math_func(const sycl::marray<arg_type, NumElements> &x) {                \
-    sycl::marray<rtn_type, NumElements> rtn;                                   \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = math_func(x[i]);                                                \
-    }                                                                          \
-    return rtn;                                                                \
-  }
-
-MARRAY_CPLX_MATH_OP_ONE_PARAM(abs, T, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(acos, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(asin, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(atan, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(acosh, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(asinh, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(atanh, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(arg, T, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(conj, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(cos, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(cosh, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(exp, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(log, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(log10, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(norm, T, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(proj, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(proj, complex<T>, T);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(sin, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(sinh, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(sqrt, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(tan, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(tanh, complex<T>, complex<T>);
-
-#undef MARRAY_CPLX_MATH_OP_ONE_PARAM
-
-#ifdef MARRAY_CPLX_MATH_OP_TWO_PARAM
-#error "Multiple definition of MARRAY_CPLX_MATH_OP_TWO_PARAM"
-#endif
-
-#define MARRAY_CPLX_MATH_OP_TWO_PARAM(math_func, rtn_type, arg_type1,          \
-                                      arg_type2)                               \
-  template <typename T, std::size_t NumElements>                               \
-  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
-      typename std::enable_if_t<is_genfloat<T>::value ||                       \
-                                    is_gencomplex<T>::value,                   \
-                                sycl::marray<rtn_type, NumElements>>           \
-      math_func(const sycl::marray<arg_type1, NumElements> &x,                 \
-                const sycl::marray<arg_type2, NumElements> &y) {               \
-    sycl::marray<rtn_type, NumElements> rtn;                                   \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = math_func(x[i], y[i]);                                          \
-    }                                                                          \
-    return rtn;                                                                \
-  }                                                                            \
-                                                                               \
-  template <typename T, std::size_t NumElements>                               \
-  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
-      typename std::enable_if_t<is_genfloat<T>::value ||                       \
-                                    is_gencomplex<T>::value,                   \
-                                sycl::marray<rtn_type, NumElements>>           \
-      math_func(const sycl::marray<arg_type1, NumElements> &x,                 \
-                const arg_type2 &y) {                                          \
-    sycl::marray<rtn_type, NumElements> rtn;                                   \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = math_func(x[i], y);                                             \
-    }                                                                          \
-    return rtn;                                                                \
-  }                                                                            \
-                                                                               \
-  template <typename T, std::size_t NumElements>                               \
-  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
-      typename std::enable_if_t<is_genfloat<T>::value ||                       \
-                                    is_gencomplex<T>::value,                   \
-                                sycl::marray<rtn_type, NumElements>>           \
-      math_func(const arg_type1 &x,                                            \
-                const sycl::marray<arg_type2, NumElements> &y) {               \
-    sycl::marray<rtn_type, NumElements> rtn;                                   \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = math_func(x, y[i]);                                             \
-    }                                                                          \
-    return rtn;                                                                \
-  }
-
-MARRAY_CPLX_MATH_OP_TWO_PARAM(pow, complex<T>, complex<T>, T);
-MARRAY_CPLX_MATH_OP_TWO_PARAM(pow, complex<T>, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_TWO_PARAM(pow, complex<T>, T, complex<T>);
-
-#undef MARRAY_CPLX_MATH_OP_TWO_PARAM
-
-// Special definition as polar requires default argument
-
-template <typename T, std::size_t NumElements>
-_SYCL_EXT_CPLX_INLINE_VISIBILITY
-    typename std::enable_if_t<is_genfloat<T>::value,
-                              sycl::marray<complex<T>, NumElements>>
-    polar(const sycl::marray<T, NumElements> &rho,
-          const sycl::marray<T, NumElements> &theta) {
-  sycl::marray<complex<T>, NumElements> rtn;
-  for (std::size_t i = 0; i < NumElements; ++i) {
-    rtn[i] = polar(rho[i], theta[i]);
-  }
-  return rtn;
-}
-
-template <typename T, std::size_t NumElements>
-_SYCL_EXT_CPLX_INLINE_VISIBILITY
-    typename std::enable_if_t<is_genfloat<T>::value,
-                              sycl::marray<complex<T>, NumElements>>
-    polar(const sycl::marray<T, NumElements> &rho, const T &theta = 0) {
-  sycl::marray<complex<T>, NumElements> rtn;
-  for (std::size_t i = 0; i < NumElements; ++i) {
-    rtn[i] = polar(rho[i], theta);
-  }
-  return rtn;
-}
-
-template <typename T, std::size_t NumElements>
-_SYCL_EXT_CPLX_INLINE_VISIBILITY
-    typename std::enable_if_t<is_genfloat<T>::value,
-                              sycl::marray<complex<T>, NumElements>>
-    polar(const T &rho, const sycl::marray<T, NumElements> &theta) {
-  sycl::marray<complex<T>, NumElements> rtn;
-  for (std::size_t i = 0; i < NumElements; ++i) {
-    rtn[i] = polar(rho, theta[i]);
-  }
-  return rtn;
-}
-
-} // namespace experimental
-} // namespace oneapi
-} // namespace ext
-
 } // namespace _V1
 } // namespace sycl
diff --git a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
new file mode 100644
index 0000000000000..d7f622135ddef
--- /dev/null
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
@@ -0,0 +1,332 @@
+//===- marray.hpp ---------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "common.hpp"
+
+#include <sycl/types.hpp>
+#include <sycl/marray.hpp>
+
+namespace sycl {
+inline namespace _V1 {
+
+template <typename T> using marray_data = sycl::detail::vec_helper<T>;
+
+template <typename T>
+using marray_data_t = typename detail::vec_helper<T>::RetType;
+
+template <typename T, std::size_t NumElements>
+class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
+private:
+  using ComplexDataT = sycl::ext::oneapi::experimental::complex<T>;
+
+public:
+  using value_type = ComplexDataT;
+  using reference = ComplexDataT &;
+  using const_reference = const ComplexDataT &;
+  using iterator = ComplexDataT *;
+  using const_iterator = const ComplexDataT *;
+
+private:
+  value_type MData[NumElements];
+
+  template <size_t... Is>
+  constexpr marray(const std::array<value_type, NumElements> &Arr,
+                   std::index_sequence<Is...>)
+      : MData{Arr[Is]...} {}
+
+  /// FIXME: If the subscript operator is made constexpr this can be removed.
+  // detail::HelperFlattenMArrayArg::MArrayToArray needs to have access to
+  // MData.
+  friend class detail::HelperFlattenMArrayArg;
+
+public:
+  constexpr marray() : MData{} {};
+
+  explicit constexpr marray(const value_type &arg)
+      : marray{sycl::detail::RepeatValue<NumElements>(
+                   static_cast<marray_data_t<value_type>>(arg)),
+               std::make_index_sequence<NumElements>()} {}
+
+  template <
+      typename... ArgTN,
+      typename = std::enable_if_t<
+          sycl::detail::AllSuitableArgTypes<value_type, ArgTN...>::value &&
+          sycl::detail::GetMArrayArgsSize<ArgTN...>::value == NumElements>>
+  constexpr marray(const ArgTN &...Args)
+      : marray{
+            sycl::detail::MArrayArgArrayCreator<value_type, ArgTN...>::Create(
+                Args...),
+            std::make_index_sequence<NumElements>()} {}
+
+  constexpr marray(const marray<value_type, NumElements> &rhs) = default;
+  constexpr marray(marray<value_type, NumElements> &&rhs) = default;
+
+  // Available only when: NumElements == 1
+  template <std::size_t N = NumElements,
+            typename = std::enable_if_t<N == 1, value_type>>
+  operator value_type() const {
+    return MData[0];
+  }
+
+  static constexpr std::size_t size() noexcept { return NumElements; }
+
+  marray<T, NumElements> real() const {
+    sycl::marray<T, NumElements> rtn;
+    for (std::size_t i = 0; i < NumElements; ++i) {
+      rtn[i] = MData[i].real();
+    }
+    return rtn;
+  }
+
+  marray<T, NumElements> imag() const {
+    sycl::marray<T, NumElements> rtn;
+    for (std::size_t i = 0; i < NumElements; ++i) {
+      rtn[i] = MData[i].imag();
+    }
+    return rtn;
+  }
+
+  // subscript operator
+  reference operator[](std::size_t i) { return MData[i]; }
+  const_reference operator[](std::size_t i) const { return MData[i]; }
+
+  marray &operator=(const marray<value_type, NumElements> &rhs) = default;
+  marray &operator=(const value_type &rhs) {
+    for (std::size_t i = 0; i < NumElements; ++i) {
+      MData[i] = rhs;
+    }
+    return *this;
+  }
+
+  // iterator functions
+  iterator begin() { return MData; }
+  const_iterator begin() const { return MData; }
+
+  iterator end() { return MData + NumElements; }
+  const_iterator end() const { return MData + NumElements; }
+
+#ifdef MARRAY_CPLX_OP
+#error "Multiple definition of MARRAY_CPLX_OP"
+#endif
+
+  // MARRAY_CPLX_OP is: +, -, *, /
+#define MARRAY_CPLX_OP(op)                                                     \
+  friend marray operator op(const marray &lhs, const marray &rhs) {            \
+    marray rtn;                                                                \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = lhs[i] op rhs[i];                                               \
+    }                                                                          \
+    return rtn;                                                                \
+  }                                                                            \
+                                                                               \
+  friend marray operator op(const marray &lhs, const value_type &rhs) {        \
+    marray rtn;                                                                \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = lhs[i] op rhs;                                                  \
+    }                                                                          \
+    return rtn;                                                                \
+  }                                                                            \
+                                                                               \
+  friend marray operator op(const value_type &lhs, const marray &rhs) {        \
+    marray rtn;                                                                \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = lhs op rhs[i];                                                  \
+    }                                                                          \
+    return rtn;                                                                \
+  }
+
+  MARRAY_CPLX_OP(+)
+  MARRAY_CPLX_OP(-)
+  MARRAY_CPLX_OP(*)
+  MARRAY_CPLX_OP(/)
+
+#undef MARRAY_CPLX_OP
+
+  // MARRAY_CPLX_OP is: %
+  friend marray operator%(const marray &lhs, const marray &rhs) = delete;
+  friend marray operator%(const marray &lhs, const value_type &rhs) = delete;
+  friend marray operator%(const value_type &lhs, const marray &rhs) = delete;
+
+  // MARRAY_CPLX_OP is: +=, -=, *=, /=
+#define MARRAY_CPLX_OP(op)                                                     \
+  friend marray &operator op(marray & lhs, const marray & rhs) {               \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      lhs[i] op rhs[i];                                                        \
+    }                                                                          \
+    return lhs;                                                                \
+  }                                                                            \
+                                                                               \
+  friend marray &operator op(marray & lhs, const value_type & rhs) {           \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      lhs[i] op rhs;                                                           \
+    }                                                                          \
+    return lhs;                                                                \
+  }                                                                            \
+  friend marray &operator op(value_type & lhs, const marray & rhs) {           \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      lhs[i] op rhs;                                                           \
+    }                                                                          \
+    return lhs;                                                                \
+  }
+
+  MARRAY_CPLX_OP(+=)
+  MARRAY_CPLX_OP(-=)
+  MARRAY_CPLX_OP(*=)
+  MARRAY_CPLX_OP(/=)
+
+#undef MARRAY_CPLX_OP
+
+  // MARRAY_CPLX_OP is: %=
+  friend marray &operator%=(marray &lhs, const marray &rhs) = delete;
+  friend marray &operator%=(marray &lhs, const value_type &rhs) = delete;
+  friend marray &operator%=(value_type &lhs, const marray &rhs) = delete;
+
+// MARRAY_CPLX_OP is: ++, --
+#define MARRAY_CPLX_OP(op)                                                     \
+  friend marray operator op(marray &lhs, int) = delete;                        \
+  friend marray &operator op(marray & rhs) = delete;
+
+  MARRAY_CPLX_OP(++)
+  MARRAY_CPLX_OP(--)
+
+#undef MARRAY_CPLX_OP
+
+// MARRAY_CPLX_OP is: unary +, unary -
+#define MARRAY_CPLX_OP(op)                                                     \
+  friend marray<value_type, NumElements> operator op(                          \
+      const marray<value_type, NumElements> &rhs) {                            \
+    marray<value_type, NumElements> rtn;                                       \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = op rhs[i];                                                      \
+    }                                                                          \
+    return rtn;                                                                \
+  }
+
+  MARRAY_CPLX_OP(+)
+  MARRAY_CPLX_OP(-)
+
+#undef MARRAY_CPLX_OP
+
+// MARRAY_CPLX_OP is: &, |, ^
+#define MARRAY_CPLX_OP(op)                                                     \
+  friend marray operator op(const marray &lhs, const marray &rhs) = delete;    \
+  friend marray operator op(const marray &lhs, const value_type &rhs) = delete;
+
+  MARRAY_CPLX_OP(&)
+  MARRAY_CPLX_OP(|)
+  MARRAY_CPLX_OP(^)
+
+#undef MARRAY_CPLX_OP
+
+// MARRAY_CPLX_OP is: &=, |=, ^=
+#define MARRAY_CPLX_OP(op)                                                     \
+  friend marray &operator op(marray & lhs, const marray & rhs) = delete;       \
+  friend marray &operator op(marray & lhs, const value_type & rhs) = delete;   \
+  friend marray &operator op(value_type & lhs, const marray & rhs) = delete;
+
+  MARRAY_CPLX_OP(&=)
+  MARRAY_CPLX_OP(|=)
+  MARRAY_CPLX_OP(^=)
+
+#undef MARRAY_CPLX_OP
+
+// MARRAY_CPLX_OP is: &&, ||
+#define MARRAY_CPLX_OP(op)                                                     \
+  friend marray<bool, NumElements> operator op(const marray & lhs,             \
+                                               const marray & rhs) = delete;   \
+  friend marray<bool, NumElements> operator op(                                \
+      const marray & lhs, const value_type & rhs) = delete;                    \
+  friend marray<bool, NumElements> operator op(const value_type & lhs,         \
+                                               const marray & rhs) = delete;
+
+  MARRAY_CPLX_OP(&&)
+  MARRAY_CPLX_OP(||)
+
+#undef MARRAY_CPLX_OP
+
+// MARRAY_CPLX_OP is: <<, >>
+#define MARRAY_CPLX_OP(op)                                                     \
+  friend marray operator op(const marray &lhs, const marray &rhs) = delete;    \
+  friend marray operator op(const marray &lhs, const value_type &rhs) =        \
+      delete;                                                                  \
+  friend marray operator op(const value_type &lhs, const marray &rhs) = delete;
+
+  MARRAY_CPLX_OP(<<)
+  MARRAY_CPLX_OP(>>)
+
+#undef MARRAY_CPLX_OP
+
+// MARRAY_CPLX_OP is: <<=, >>=
+#define MARRAY_CPLX_OP(op)                                                     \
+  friend marray &operator op(marray & lhs, const marray & rhs) = delete;       \
+  friend marray &operator op(marray & lhs, const value_type & rhs) = delete;
+
+  MARRAY_CPLX_OP(<<=)
+  MARRAY_CPLX_OP(>>=)
+
+#undef MARRAY_CPLX_OP
+
+  // MARRAY_CPLX_OP is: ==, !=
+#define MARRAY_CPLX_OP(op)                                                     \
+  friend marray<bool, NumElements> operator op(const marray & lhs,             \
+                                               const marray & rhs) {           \
+    marray<bool, NumElements> rtn;                                             \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = lhs[i] op rhs[i];                                               \
+    }                                                                          \
+    return rtn;                                                                \
+  }                                                                            \
+                                                                               \
+  friend marray<bool, NumElements> operator op(const marray & lhs,             \
+                                               const value_type & rhs) {       \
+    marray<bool, NumElements> rtn;                                             \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = lhs[i] op rhs;                                                  \
+    }                                                                          \
+    return rtn;                                                                \
+  }                                                                            \
+                                                                               \
+  friend marray<bool, NumElements> operator op(const value_type & lhs,         \
+                                               const marray & rhs) {           \
+    marray<bool, NumElements> rtn;                                             \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = lhs op rhs[i];                                                  \
+    }                                                                          \
+    return rtn;                                                                \
+  }
+
+  MARRAY_CPLX_OP(==)
+  MARRAY_CPLX_OP(!=)
+
+#undef MARRAY_CPLX_OP
+
+  // MARRAY_CPLX_OP is: <, >, <=, >=
+#define MARRAY_CPLX_OP(op)                                                     \
+  friend marray<bool, NumElements> operator op(const marray & lhs,             \
+                                               const marray & rhs) = delete;   \
+  friend marray<bool, NumElements> operator op(                                \
+      const marray & lhs, const value_type & rhs) = delete;                    \
+  friend marray<bool, NumElements> operator op(const value_type & lhs,         \
+                                               const marray & rhs) = delete;
+
+  MARRAY_CPLX_OP(<);
+  MARRAY_CPLX_OP(>);
+  MARRAY_CPLX_OP(<=);
+  MARRAY_CPLX_OP(>=);
+
+#undef MARRAY_CPLX_OP
+
+  friend marray operator~(const marray &v) = delete;
+
+  friend marray<bool, NumElements> operator!(const marray &v) = delete;
+};
+
+} // namespace _V1
+} // namespace sycl
diff --git a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp
new file mode 100644
index 0000000000000..8dc806c355268
--- /dev/null
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp
@@ -0,0 +1,163 @@
+//===- marray_math.hpp ----------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "common.hpp"
+
+#include <sycl/marray.hpp>
+
+namespace sycl {
+inline namespace _V1 {
+
+namespace ext {
+namespace oneapi {
+namespace experimental {
+
+#ifdef MARRAY_CPLX_MATH_OP_ONE_PARAM
+#error "Multiple definition of MARRAY_CPLX_MATH_OP_ONE_PARAM"
+#endif
+
+#define MARRAY_CPLX_MATH_OP_ONE_PARAM(math_func, rtn_type, arg_type)           \
+  template <typename T, std::size_t NumElements>                               \
+  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
+      typename std::enable_if_t<is_genfloat<T>::value ||                       \
+                                    is_gencomplex<T>::value,                   \
+                                sycl::marray<rtn_type, NumElements>>           \
+      math_func(const sycl::marray<arg_type, NumElements> &x) {                \
+    sycl::marray<rtn_type, NumElements> rtn;                                   \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = math_func(x[i]);                                                \
+    }                                                                          \
+    return rtn;                                                                \
+  }
+
+MARRAY_CPLX_MATH_OP_ONE_PARAM(abs, T, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(acos, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(asin, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(atan, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(acosh, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(asinh, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(atanh, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(arg, T, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(conj, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(cos, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(cosh, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(exp, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(log, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(log10, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(norm, T, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(proj, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(proj, complex<T>, T);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(sin, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(sinh, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(sqrt, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(tan, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_ONE_PARAM(tanh, complex<T>, complex<T>);
+
+#undef MARRAY_CPLX_MATH_OP_ONE_PARAM
+
+#ifdef MARRAY_CPLX_MATH_OP_TWO_PARAM
+#error "Multiple definition of MARRAY_CPLX_MATH_OP_TWO_PARAM"
+#endif
+
+#define MARRAY_CPLX_MATH_OP_TWO_PARAM(math_func, rtn_type, arg_type1,          \
+                                      arg_type2)                               \
+  template <typename T, std::size_t NumElements>                               \
+  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
+      typename std::enable_if_t<is_genfloat<T>::value ||                       \
+                                    is_gencomplex<T>::value,                   \
+                                sycl::marray<rtn_type, NumElements>>           \
+      math_func(const sycl::marray<arg_type1, NumElements> &x,                 \
+                const sycl::marray<arg_type2, NumElements> &y) {               \
+    sycl::marray<rtn_type, NumElements> rtn;                                   \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = math_func(x[i], y[i]);                                          \
+    }                                                                          \
+    return rtn;                                                                \
+  }                                                                            \
+                                                                               \
+  template <typename T, std::size_t NumElements>                               \
+  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
+      typename std::enable_if_t<is_genfloat<T>::value ||                       \
+                                    is_gencomplex<T>::value,                   \
+                                sycl::marray<rtn_type, NumElements>>           \
+      math_func(const sycl::marray<arg_type1, NumElements> &x,                 \
+                const arg_type2 &y) {                                          \
+    sycl::marray<rtn_type, NumElements> rtn;                                   \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = math_func(x[i], y);                                             \
+    }                                                                          \
+    return rtn;                                                                \
+  }                                                                            \
+                                                                               \
+  template <typename T, std::size_t NumElements>                               \
+  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
+      typename std::enable_if_t<is_genfloat<T>::value ||                       \
+                                    is_gencomplex<T>::value,                   \
+                                sycl::marray<rtn_type, NumElements>>           \
+      math_func(const arg_type1 &x,                                            \
+                const sycl::marray<arg_type2, NumElements> &y) {               \
+    sycl::marray<rtn_type, NumElements> rtn;                                   \
+    for (std::size_t i = 0; i < NumElements; ++i) {                            \
+      rtn[i] = math_func(x, y[i]);                                             \
+    }                                                                          \
+    return rtn;                                                                \
+  }
+
+MARRAY_CPLX_MATH_OP_TWO_PARAM(pow, complex<T>, complex<T>, T);
+MARRAY_CPLX_MATH_OP_TWO_PARAM(pow, complex<T>, complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP_TWO_PARAM(pow, complex<T>, T, complex<T>);
+
+#undef MARRAY_CPLX_MATH_OP_TWO_PARAM
+
+// Special definition as polar requires default argument
+
+template <typename T, std::size_t NumElements>
+_SYCL_EXT_CPLX_INLINE_VISIBILITY
+    typename std::enable_if_t<is_genfloat<T>::value,
+                              sycl::marray<complex<T>, NumElements>>
+    polar(const sycl::marray<T, NumElements> &rho,
+          const sycl::marray<T, NumElements> &theta) {
+  sycl::marray<complex<T>, NumElements> rtn;
+  for (std::size_t i = 0; i < NumElements; ++i) {
+    rtn[i] = polar(rho[i], theta[i]);
+  }
+  return rtn;
+}
+
+template <typename T, std::size_t NumElements>
+_SYCL_EXT_CPLX_INLINE_VISIBILITY
+    typename std::enable_if_t<is_genfloat<T>::value,
+                              sycl::marray<complex<T>, NumElements>>
+    polar(const sycl::marray<T, NumElements> &rho, const T &theta = 0) {
+  sycl::marray<complex<T>, NumElements> rtn;
+  for (std::size_t i = 0; i < NumElements; ++i) {
+    rtn[i] = polar(rho[i], theta);
+  }
+  return rtn;
+}
+
+template <typename T, std::size_t NumElements>
+_SYCL_EXT_CPLX_INLINE_VISIBILITY
+    typename std::enable_if_t<is_genfloat<T>::value,
+                              sycl::marray<complex<T>, NumElements>>
+    polar(const T &rho, const sycl::marray<T, NumElements> &theta) {
+  sycl::marray<complex<T>, NumElements> rtn;
+  for (std::size_t i = 0; i < NumElements; ++i) {
+    rtn[i] = polar(rho, theta[i]);
+  }
+  return rtn;
+}
+
+} // namespace experimental
+} // namespace oneapi
+} // namespace ext
+
+} // namespace _V1
+} // namespace sycl
diff --git a/sycl/test/extensions/test_marray_complex.cpp b/sycl/test/extensions/complex/marray.cpp
similarity index 99%
rename from sycl/test/extensions/test_marray_complex.cpp
rename to sycl/test/extensions/complex/marray.cpp
index b169e737ba857..82b268f37c055 100644
--- a/sycl/test/extensions/test_marray_complex.cpp
+++ b/sycl/test/extensions/complex/marray.cpp
@@ -2,7 +2,7 @@
 
 #define SYCL_EXT_ONEAPI_COMPLEX
 
-#include <sycl/ext/oneapi/experimental/sycl_complex.hpp>
+#include <sycl/ext/oneapi/experimental/complex/complex.hpp>
 #include <sycl/sycl.hpp>
 
 using namespace sycl::ext::oneapi::experimental;

From 8799339225e505c2fe1c4e17895d58d0c490b388 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Thu, 2 Nov 2023 10:02:17 +0100
Subject: [PATCH 27/39] Apply clang-format

---
 .../sycl/ext/oneapi/experimental/complex/detail/marray.hpp      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
index d7f622135ddef..20f6f5a9b25cb 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
@@ -10,8 +10,8 @@
 
 #include "common.hpp"
 
-#include <sycl/types.hpp>
 #include <sycl/marray.hpp>
+#include <sycl/types.hpp>
 
 namespace sycl {
 inline namespace _V1 {

From f756d3827114e6a4673e868b583ecd0e84c5256e Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Thu, 2 Nov 2023 14:18:50 +0100
Subject: [PATCH 28/39] Remove the real and imag member functions

---
 .../experimental/complex/detail/marray.hpp       | 16 ----------------
 1 file changed, 16 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
index 20f6f5a9b25cb..d088ee2cd354c 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
@@ -77,22 +77,6 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
   static constexpr std::size_t size() noexcept { return NumElements; }
 
-  marray<T, NumElements> real() const {
-    sycl::marray<T, NumElements> rtn;
-    for (std::size_t i = 0; i < NumElements; ++i) {
-      rtn[i] = MData[i].real();
-    }
-    return rtn;
-  }
-
-  marray<T, NumElements> imag() const {
-    sycl::marray<T, NumElements> rtn;
-    for (std::size_t i = 0; i < NumElements; ++i) {
-      rtn[i] = MData[i].imag();
-    }
-    return rtn;
-  }
-
   // subscript operator
   reference operator[](std::size_t i) { return MData[i]; }
   const_reference operator[](std::size_t i) const { return MData[i]; }

From 051db38250a59352039fb56380db40e45a8bdf92 Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Thu, 2 Nov 2023 14:19:17 +0100
Subject: [PATCH 29/39] Add new real and imag free functions

---
 .../complex/detail/marray_math.hpp            | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp
index 8dc806c355268..f48571c9e37fb 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp
@@ -155,6 +155,32 @@ _SYCL_EXT_CPLX_INLINE_VISIBILITY
   return rtn;
 }
 
+// real
+
+template<typename T, std::size_t NumElements>
+_SYCL_EXT_CPLX_INLINE_VISIBILITY
+typename std::enable_if_t<is_genfloat<T>::value, sycl::marray<T, NumElements>>
+real(const marray<complex<T>, NumElements> &z) {
+  sycl::marray<T, NumElements> rtn;
+  for (std::size_t i = 0; i < NumElements; ++i) {
+    rtn[i] = z[i].real();
+  }
+  return rtn;
+}
+
+// imag
+
+template<typename T, std::size_t NumElements>
+_SYCL_EXT_CPLX_INLINE_VISIBILITY
+typename std::enable_if_t<is_genfloat<T>::value, sycl::marray<T, NumElements>>
+imag(const marray<complex<T>, NumElements> &z) {
+  sycl::marray<T, NumElements> rtn;
+  for (std::size_t i = 0; i < NumElements; ++i) {
+    rtn[i] = z[i].imag();
+  }
+  return rtn;
+}
+
 } // namespace experimental
 } // namespace oneapi
 } // namespace ext

From 80b41ba9b0a5af23c5ff139b9224d2511e86b94b Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Thu, 2 Nov 2023 14:19:36 +0100
Subject: [PATCH 30/39] Update tests

---
 .../test-e2e/Complex/sycl_complex_marray_getters_test.cpp | 8 ++++----
 sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp   | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
index ac369dc3f9c37..d531dbe3091bf 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
@@ -23,11 +23,11 @@ template <typename T> struct test_real {
         sycl::malloc_shared<sycl::marray<T, GETTERS_TEST_CASE_SIZE>>(1, Q);
 
     /* Check cplx::complex output from device */
-    Q.single_task([=]() { *cplx_out = cplx_in.real(); }).wait();
+    Q.single_task([=]() { *cplx_out = sycl::ext::oneapi::experimental::real(cplx_in); }).wait();
     pass &= check_results(*cplx_out, std_in, /*is_device*/ true);
 
     /* Check cplx::complex output from host */
-    *cplx_out = cplx_in.real();
+    *cplx_out = sycl::ext::oneapi::experimental::real(cplx_in);
     pass &= check_results(*cplx_out, std_in, /*is_device*/ false);
 
     sycl::free(cplx_out, Q);
@@ -56,11 +56,11 @@ template <typename T> struct test_imag {
         sycl::malloc_shared<sycl::marray<T, GETTERS_TEST_CASE_SIZE>>(1, Q);
 
     /* Check cplx::complex output from device */
-    Q.single_task([=]() { *cplx_out = cplx_in.imag(); }).wait();
+    Q.single_task([=]() { *cplx_out = sycl::ext::oneapi::experimental::imag(cplx_in); }).wait();
     pass &= check_results(*cplx_out, std_in, /*is_device*/ true);
 
     /* Check cplx::complex output from host */
-    *cplx_out = cplx_in.imag();
+    *cplx_out = sycl::ext::oneapi::experimental::imag(cplx_in);
     pass &= check_results(*cplx_out, std_in, /*is_device*/ false);
 
     sycl::free(cplx_out, Q);
diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
index 466b155e93f3c..4fff7514e6bb0 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
@@ -279,13 +279,13 @@ template <typename T> struct test_pow_cplx_deci {
 
     /* Check cplx::complex output from device */
     Q.single_task([=]() {
-       *cplx_out = experimental::pow(cplx_in, cplx_in.real());
+       *cplx_out = experimental::pow(cplx_in, sycl::ext::oneapi::experimental::real(cplx_in));
      }).wait();
     pass &= check_results(*cplx_out, convert_marray<T>(std_out),
                           /*is_device*/ true);
 
     /* Check cplx::complex output from host */
-    *cplx_out = experimental::pow(cplx_in, cplx_in.real());
+    *cplx_out = experimental::pow(cplx_in, sycl::ext::oneapi::experimental::real(cplx_in));
     pass &= check_results(*cplx_out, convert_marray<T>(std_out),
                           /*is_device*/ false);
 
@@ -334,13 +334,13 @@ template <typename T> struct test_pow_deci_cplx {
 
     /* Check cplx::complex output from device */
     Q.single_task([=]() {
-       *cplx_out = experimental::pow(cplx_in.real(), cplx_in);
+       *cplx_out = experimental::pow(sycl::ext::oneapi::experimental::real(cplx_in), cplx_in);
      }).wait();
     pass &= check_results(*cplx_out, convert_marray<T>(std_out),
                           /*is_device*/ true);
 
     /* Check cplx::complex output from host */
-    *cplx_out = experimental::pow(cplx_in.real(), cplx_in);
+    *cplx_out = experimental::pow(sycl::ext::oneapi::experimental::real(cplx_in), cplx_in);
     pass &= check_results(*cplx_out, convert_marray<T>(std_out),
                           /*is_device*/ false);
 

From 4dd8cd767177c533d8a34fb203c971eff442884b Mon Sep 17 00:00:00 2001
From: jle-quel <jeffersonlequellec@me.com>
Date: Thu, 2 Nov 2023 15:38:25 +0100
Subject: [PATCH 31/39] Apply clang-format

---
 .../experimental/complex/detail/marray_math.hpp    | 14 ++++++++------
 .../Complex/sycl_complex_marray_getters_test.cpp   |  8 ++++++--
 .../Complex/sycl_complex_marray_math_test.cpp      | 12 ++++++++----
 3 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp
index f48571c9e37fb..dccda84bfa96c 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp
@@ -157,10 +157,11 @@ _SYCL_EXT_CPLX_INLINE_VISIBILITY
 
 // real
 
-template<typename T, std::size_t NumElements>
+template <typename T, std::size_t NumElements>
 _SYCL_EXT_CPLX_INLINE_VISIBILITY
-typename std::enable_if_t<is_genfloat<T>::value, sycl::marray<T, NumElements>>
-real(const marray<complex<T>, NumElements> &z) {
+    typename std::enable_if_t<is_genfloat<T>::value,
+                              sycl::marray<T, NumElements>>
+    real(const marray<complex<T>, NumElements> &z) {
   sycl::marray<T, NumElements> rtn;
   for (std::size_t i = 0; i < NumElements; ++i) {
     rtn[i] = z[i].real();
@@ -170,10 +171,11 @@ real(const marray<complex<T>, NumElements> &z) {
 
 // imag
 
-template<typename T, std::size_t NumElements>
+template <typename T, std::size_t NumElements>
 _SYCL_EXT_CPLX_INLINE_VISIBILITY
-typename std::enable_if_t<is_genfloat<T>::value, sycl::marray<T, NumElements>>
-imag(const marray<complex<T>, NumElements> &z) {
+    typename std::enable_if_t<is_genfloat<T>::value,
+                              sycl::marray<T, NumElements>>
+    imag(const marray<complex<T>, NumElements> &z) {
   sycl::marray<T, NumElements> rtn;
   for (std::size_t i = 0; i < NumElements; ++i) {
     rtn[i] = z[i].imag();
diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
index d531dbe3091bf..b374aa7000345 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
@@ -23,7 +23,9 @@ template <typename T> struct test_real {
         sycl::malloc_shared<sycl::marray<T, GETTERS_TEST_CASE_SIZE>>(1, Q);
 
     /* Check cplx::complex output from device */
-    Q.single_task([=]() { *cplx_out = sycl::ext::oneapi::experimental::real(cplx_in); }).wait();
+    Q.single_task([=]() {
+       *cplx_out = sycl::ext::oneapi::experimental::real(cplx_in);
+     }).wait();
     pass &= check_results(*cplx_out, std_in, /*is_device*/ true);
 
     /* Check cplx::complex output from host */
@@ -56,7 +58,9 @@ template <typename T> struct test_imag {
         sycl::malloc_shared<sycl::marray<T, GETTERS_TEST_CASE_SIZE>>(1, Q);
 
     /* Check cplx::complex output from device */
-    Q.single_task([=]() { *cplx_out = sycl::ext::oneapi::experimental::imag(cplx_in); }).wait();
+    Q.single_task([=]() {
+       *cplx_out = sycl::ext::oneapi::experimental::imag(cplx_in);
+     }).wait();
     pass &= check_results(*cplx_out, std_in, /*is_device*/ true);
 
     /* Check cplx::complex output from host */
diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
index 4fff7514e6bb0..9f75c31b2d620 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
@@ -279,13 +279,15 @@ template <typename T> struct test_pow_cplx_deci {
 
     /* Check cplx::complex output from device */
     Q.single_task([=]() {
-       *cplx_out = experimental::pow(cplx_in, sycl::ext::oneapi::experimental::real(cplx_in));
+       *cplx_out = experimental::pow(
+           cplx_in, sycl::ext::oneapi::experimental::real(cplx_in));
      }).wait();
     pass &= check_results(*cplx_out, convert_marray<T>(std_out),
                           /*is_device*/ true);
 
     /* Check cplx::complex output from host */
-    *cplx_out = experimental::pow(cplx_in, sycl::ext::oneapi::experimental::real(cplx_in));
+    *cplx_out = experimental::pow(
+        cplx_in, sycl::ext::oneapi::experimental::real(cplx_in));
     pass &= check_results(*cplx_out, convert_marray<T>(std_out),
                           /*is_device*/ false);
 
@@ -334,13 +336,15 @@ template <typename T> struct test_pow_deci_cplx {
 
     /* Check cplx::complex output from device */
     Q.single_task([=]() {
-       *cplx_out = experimental::pow(sycl::ext::oneapi::experimental::real(cplx_in), cplx_in);
+       *cplx_out = experimental::pow(
+           sycl::ext::oneapi::experimental::real(cplx_in), cplx_in);
      }).wait();
     pass &= check_results(*cplx_out, convert_marray<T>(std_out),
                           /*is_device*/ true);
 
     /* Check cplx::complex output from host */
-    *cplx_out = experimental::pow(sycl::ext::oneapi::experimental::real(cplx_in), cplx_in);
+    *cplx_out = experimental::pow(
+        sycl::ext::oneapi::experimental::real(cplx_in), cplx_in);
     pass &= check_results(*cplx_out, convert_marray<T>(std_out),
                           /*is_device*/ false);
 

From 4728073d63222b910fec6703e4ca4dcd8fd8c5d2 Mon Sep 17 00:00:00 2001
From: Jefferson Le Quellec <jefferson.lequellec@codeplay.com>
Date: Tue, 13 Feb 2024 15:07:56 +0100
Subject: [PATCH 32/39] Rename HelperFlattenMArrayArg to FlattenMArrayArgHelper
 and update name of static methods

---
 .../oneapi/experimental/complex/detail/marray.hpp   |  4 ++--
 sycl/include/sycl/marray.hpp                        | 13 ++++++-------
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
index d088ee2cd354c..b849302206773 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
@@ -42,9 +42,9 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
       : MData{Arr[Is]...} {}
 
   /// FIXME: If the subscript operator is made constexpr this can be removed.
-  // detail::HelperFlattenMArrayArg::MArrayToArray needs to have access to
+  // detail::FlattenMArrayArgHelper::MArrayToArray needs to have access to
   // MData.
-  friend class detail::HelperFlattenMArrayArg;
+  friend class detail::FlattenMArrayArgHelper;
 
 public:
   constexpr marray() : MData{} {};
diff --git a/sycl/include/sycl/marray.hpp b/sycl/include/sycl/marray.hpp
index f75918c23a320..cf73bdf454ec0 100644
--- a/sycl/include/sycl/marray.hpp
+++ b/sycl/include/sycl/marray.hpp
@@ -53,7 +53,7 @@ template <typename DataT, typename... ArgTN>
 struct AllSuitableArgTypes
     : std::conjunction<IsSuitableArgType<DataT, ArgTN>...> {};
 
-class HelperFlattenMArrayArg {
+class FlattenMArrayArgHelper {
 private:
   // Utility trait for creating an std::array from an marray argument.
   template <typename DataT, typename T, std::size_t... Is>
@@ -64,19 +64,18 @@ class HelperFlattenMArrayArg {
 
 public:
   template <typename DataT, typename T, std::size_t N>
-  static constexpr std::array<DataT, N>
-  FlattenMArrayArgHelper(const marray<T, N> &A) {
+  static constexpr std::array<DataT, N> FlattenMArray(const marray<T, N> &A) {
     return MArrayToArray<DataT>(A, std::make_index_sequence<N>());
   }
   template <typename DataT, typename T>
-  static constexpr auto FlattenMArrayArgHelper(const T &A) {
+  static constexpr auto FlattenMArray(const T &A) {
     return std::array<DataT, 1>{static_cast<DataT>(A)};
   }
 };
 
 template <typename DataT, typename T> struct FlattenMArrayArg {
   constexpr auto operator()(const T &A) const {
-    return HelperFlattenMArrayArg::FlattenMArrayArgHelper<DataT>(A);
+    return FlattenMArrayArgHelper::FlattenMArray<DataT>(A);
   }
 };
 
@@ -107,9 +106,9 @@ template <typename Type, std::size_t NumElements> class marray {
   /// FIXME: If the subscript operator is made constexpr these can be removed.
   // Other marray specializations needs to be a friend to access MData.
   template <typename Type_, std::size_t NumElements_> friend class marray;
-  // detail::HelperFlattenMArrayArg::MArrayToArray needs to be a friend to
+  // detail::FlattenMArrayArgHelper::MArrayToArray needs to be a friend to
   // access MData.
-  friend class detail::HelperFlattenMArrayArg;
+  friend class detail::FlattenMArrayArgHelper;
 
   constexpr void initialize_data(const Type &Arg) {
     for (size_t i = 0; i < NumElements; ++i) {

From fd2759fbb93330f12225bb3b0ee541b2621f3391 Mon Sep 17 00:00:00 2001
From: Jefferson Le Quellec <jefferson.lequellec@codeplay.com>
Date: Tue, 13 Feb 2024 15:10:15 +0100
Subject: [PATCH 33/39] Update FIXME comments

---
 .../sycl/ext/oneapi/experimental/complex/detail/marray.hpp     | 2 +-
 sycl/include/sycl/marray.hpp                                   | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
index b849302206773..b739d98d5ec70 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
@@ -41,9 +41,9 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
                    std::index_sequence<Is...>)
       : MData{Arr[Is]...} {}
 
-  /// FIXME: If the subscript operator is made constexpr this can be removed.
   // detail::FlattenMArrayArgHelper::MArrayToArray needs to have access to
   // MData.
+  // FIXME: If the subscript operator is made constexpr this can be removed.
   friend class detail::FlattenMArrayArgHelper;
 
 public:
diff --git a/sycl/include/sycl/marray.hpp b/sycl/include/sycl/marray.hpp
index cf73bdf454ec0..0b5677a5d13d1 100644
--- a/sycl/include/sycl/marray.hpp
+++ b/sycl/include/sycl/marray.hpp
@@ -103,11 +103,12 @@ template <typename Type, std::size_t NumElements> class marray {
 private:
   value_type MData[NumElements];
 
-  /// FIXME: If the subscript operator is made constexpr these can be removed.
   // Other marray specializations needs to be a friend to access MData.
+  // FIXME: If the subscript operator is made constexpr these can be removed.
   template <typename Type_, std::size_t NumElements_> friend class marray;
   // detail::FlattenMArrayArgHelper::MArrayToArray needs to be a friend to
   // access MData.
+  // FIXME: If the subscript operator is made constexpr these can be removed.
   friend class detail::FlattenMArrayArgHelper;
 
   constexpr void initialize_data(const Type &Arg) {

From 152156c5376efb2d72bdbd406b2f7cf100bb348c Mon Sep 17 00:00:00 2001
From: Jefferson Le Quellec <jefferson.lequellec@codeplay.com>
Date: Tue, 13 Feb 2024 16:12:09 +0100
Subject: [PATCH 34/39] Make marray_data_t a private type alias

---
 .../ext/oneapi/experimental/complex/detail/marray.hpp     | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
index b739d98d5ec70..8e941aa90c39b 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
@@ -16,15 +16,11 @@
 namespace sycl {
 inline namespace _V1 {
 
-template <typename T> using marray_data = sycl::detail::vec_helper<T>;
-
-template <typename T>
-using marray_data_t = typename detail::vec_helper<T>::RetType;
-
 template <typename T, std::size_t NumElements>
 class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 private:
   using ComplexDataT = sycl::ext::oneapi::experimental::complex<T>;
+  using MarrayDataT = typename sycl::detail::vec_helper<ComplexDataT>::RetType;
 
 public:
   using value_type = ComplexDataT;
@@ -51,7 +47,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
   explicit constexpr marray(const value_type &arg)
       : marray{sycl::detail::RepeatValue<NumElements>(
-                   static_cast<marray_data_t<value_type>>(arg)),
+                   static_cast<MarrayDataT>(arg)),
                std::make_index_sequence<NumElements>()} {}
 
   template <

From 735b2b8ebc9aa5186897fd5313337839aaa085eb Mon Sep 17 00:00:00 2001
From: Jefferson Le Quellec <jefferson.lequellec@codeplay.com>
Date: Mon, 6 May 2024 15:30:21 +0200
Subject: [PATCH 35/39] Apply review's and new specification's changes

---
 .../experimental/complex/detail/marray.hpp    | 232 ++++++------------
 1 file changed, 73 insertions(+), 159 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
index 8e941aa90c39b..4b41368c0a874 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
@@ -92,171 +92,105 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   iterator end() { return MData + NumElements; }
   const_iterator end() const { return MData + NumElements; }
 
-#ifdef MARRAY_CPLX_OP
-#error "Multiple definition of MARRAY_CPLX_OP"
+////////////////////////////////////////////////////////////////////////////////
+/// ASSIGNMENT OPERATORS
+////////////////////////////////////////////////////////////////////////////////
+
+#ifdef IMPL_ASSIGN_MARRAY_CPLX_OP
+#error "Multiple definition of IMPL_ASSIGN_MARRAY_CPLX_OP"
 #endif
 
-  // MARRAY_CPLX_OP is: +, -, *, /
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray operator op(const marray &lhs, const marray &rhs) {            \
-    marray rtn;                                                                \
+#define IMPL_ASSIGN_MARRAY_CPLX_OP(op)                                         \
+  friend marray &operator op(marray &lhs, const marray &rhs) {                 \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = lhs[i] op rhs[i];                                               \
+      lhs[i] op rhs[i];                                                        \
     }                                                                          \
-    return rtn;                                                                \
+    return lhs;                                                                \
   }                                                                            \
                                                                                \
-  friend marray operator op(const marray &lhs, const value_type &rhs) {        \
-    marray rtn;                                                                \
+  friend marray &operator op(marray &lhs, const value_type &rhs) {             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = lhs[i] op rhs;                                                  \
+      lhs[i] op rhs;                                                           \
     }                                                                          \
-    return rtn;                                                                \
-  }                                                                            \
-                                                                               \
-  friend marray operator op(const value_type &lhs, const marray &rhs) {        \
+    return lhs;                                                                \
+  }
+
+  IMPL_ASSIGN_MARRAY_CPLX_OP(+=)
+  IMPL_ASSIGN_MARRAY_CPLX_OP(-=)
+  IMPL_ASSIGN_MARRAY_CPLX_OP(*=)
+  IMPL_ASSIGN_MARRAY_CPLX_OP(/=)
+
+#undef IMPL_ASSIGN_MARRAY_CPLX_OP
+
+////////////////////////////////////////////////////////////////////////////////
+// ARITHMETIC OPERATORS
+////////////////////////////////////////////////////////////////////////////////
+
+#ifdef IMPL_UNARY_MARRAY_CPLX_OP
+#error "Multiple definition of IMPL_UNARY_MARRAY_CPLX_OP"
+#endif
+
+#define IMPL_UNARY_MARRAY_CPLX_OP(op)                                          \
+  friend marray operator op(const marray &lhs) {                               \
     marray rtn;                                                                \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = lhs op rhs[i];                                                  \
+      rtn[i] = op lhs[i];                                                      \
     }                                                                          \
     return rtn;                                                                \
   }
 
-  MARRAY_CPLX_OP(+)
-  MARRAY_CPLX_OP(-)
-  MARRAY_CPLX_OP(*)
-  MARRAY_CPLX_OP(/)
+  IMPL_UNARY_MARRAY_CPLX_OP(+)
+  IMPL_UNARY_MARRAY_CPLX_OP(-)
 
-#undef MARRAY_CPLX_OP
+#undef IMPL_UNARY_MARRAY_CPLX_OP
 
-  // MARRAY_CPLX_OP is: %
-  friend marray operator%(const marray &lhs, const marray &rhs) = delete;
-  friend marray operator%(const marray &lhs, const value_type &rhs) = delete;
-  friend marray operator%(const value_type &lhs, const marray &rhs) = delete;
+#ifdef IMPL_ARITH_MARRAY_CPLX_OP
+#error "Multiple definition of IMPL_ARITH_MARRAY_CPLX_OP"
+#endif
 
-  // MARRAY_CPLX_OP is: +=, -=, *=, /=
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray &operator op(marray & lhs, const marray & rhs) {               \
+#define IMPL_ARITH_MARRAY_CPLX_OP(op)                                          \
+  friend marray operator op(const marray &lhs, const marray &rhs) {            \
+    marray rtn;                                                                \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      lhs[i] op rhs[i];                                                        \
+      rtn[i] = lhs[i] op rhs[i];                                               \
     }                                                                          \
-    return lhs;                                                                \
+    return rtn;                                                                \
   }                                                                            \
                                                                                \
-  friend marray &operator op(marray & lhs, const value_type & rhs) {           \
+  friend marray operator op(const marray &lhs, const value_type &rhs) {        \
+    marray rtn;                                                                \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      lhs[i] op rhs;                                                           \
+      rtn[i] = lhs[i] op rhs;                                                  \
     }                                                                          \
-    return lhs;                                                                \
+    return rtn;                                                                \
   }                                                                            \
-  friend marray &operator op(value_type & lhs, const marray & rhs) {           \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      lhs[i] op rhs;                                                           \
-    }                                                                          \
-    return lhs;                                                                \
-  }
-
-  MARRAY_CPLX_OP(+=)
-  MARRAY_CPLX_OP(-=)
-  MARRAY_CPLX_OP(*=)
-  MARRAY_CPLX_OP(/=)
-
-#undef MARRAY_CPLX_OP
-
-  // MARRAY_CPLX_OP is: %=
-  friend marray &operator%=(marray &lhs, const marray &rhs) = delete;
-  friend marray &operator%=(marray &lhs, const value_type &rhs) = delete;
-  friend marray &operator%=(value_type &lhs, const marray &rhs) = delete;
-
-// MARRAY_CPLX_OP is: ++, --
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray operator op(marray &lhs, int) = delete;                        \
-  friend marray &operator op(marray & rhs) = delete;
-
-  MARRAY_CPLX_OP(++)
-  MARRAY_CPLX_OP(--)
-
-#undef MARRAY_CPLX_OP
-
-// MARRAY_CPLX_OP is: unary +, unary -
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray<value_type, NumElements> operator op(                          \
-      const marray<value_type, NumElements> &rhs) {                            \
-    marray<value_type, NumElements> rtn;                                       \
+                                                                               \
+  friend marray operator op(const value_type &lhs, const marray &rhs) {        \
+    marray rtn;                                                                \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = op rhs[i];                                                      \
+      rtn[i] = lhs op rhs[i];                                                  \
     }                                                                          \
     return rtn;                                                                \
   }
 
-  MARRAY_CPLX_OP(+)
-  MARRAY_CPLX_OP(-)
-
-#undef MARRAY_CPLX_OP
+  IMPL_ARITH_MARRAY_CPLX_OP(+)
+  IMPL_ARITH_MARRAY_CPLX_OP(-)
+  IMPL_ARITH_MARRAY_CPLX_OP(*)
+  IMPL_ARITH_MARRAY_CPLX_OP(/)
 
-// MARRAY_CPLX_OP is: &, |, ^
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray operator op(const marray &lhs, const marray &rhs) = delete;    \
-  friend marray operator op(const marray &lhs, const value_type &rhs) = delete;
+#undef IMPL_ARITH_MARRAY_CPLX_OP
 
-  MARRAY_CPLX_OP(&)
-  MARRAY_CPLX_OP(|)
-  MARRAY_CPLX_OP(^)
+////////////////////////////////////////////////////////////////////////////////
+// COMPARAISON OPERATORS
+////////////////////////////////////////////////////////////////////////////////
 
-#undef MARRAY_CPLX_OP
-
-// MARRAY_CPLX_OP is: &=, |=, ^=
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray &operator op(marray & lhs, const marray & rhs) = delete;       \
-  friend marray &operator op(marray & lhs, const value_type & rhs) = delete;   \
-  friend marray &operator op(value_type & lhs, const marray & rhs) = delete;
-
-  MARRAY_CPLX_OP(&=)
-  MARRAY_CPLX_OP(|=)
-  MARRAY_CPLX_OP(^=)
-
-#undef MARRAY_CPLX_OP
-
-// MARRAY_CPLX_OP is: &&, ||
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray<bool, NumElements> operator op(const marray & lhs,             \
-                                               const marray & rhs) = delete;   \
-  friend marray<bool, NumElements> operator op(                                \
-      const marray & lhs, const value_type & rhs) = delete;                    \
-  friend marray<bool, NumElements> operator op(const value_type & lhs,         \
-                                               const marray & rhs) = delete;
-
-  MARRAY_CPLX_OP(&&)
-  MARRAY_CPLX_OP(||)
-
-#undef MARRAY_CPLX_OP
-
-// MARRAY_CPLX_OP is: <<, >>
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray operator op(const marray &lhs, const marray &rhs) = delete;    \
-  friend marray operator op(const marray &lhs, const value_type &rhs) =        \
-      delete;                                                                  \
-  friend marray operator op(const value_type &lhs, const marray &rhs) = delete;
-
-  MARRAY_CPLX_OP(<<)
-  MARRAY_CPLX_OP(>>)
-
-#undef MARRAY_CPLX_OP
-
-// MARRAY_CPLX_OP is: <<=, >>=
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray &operator op(marray & lhs, const marray & rhs) = delete;       \
-  friend marray &operator op(marray & lhs, const value_type & rhs) = delete;
-
-  MARRAY_CPLX_OP(<<=)
-  MARRAY_CPLX_OP(>>=)
-
-#undef MARRAY_CPLX_OP
+#ifdef IMPL_COMP_MARRAY_CPLX_OP
+#error "Multiple definition of IMPL_COMP_MARRAY_CPLX_OP"
+#endif
 
-  // MARRAY_CPLX_OP is: ==, !=
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray<bool, NumElements> operator op(const marray & lhs,             \
-                                               const marray & rhs) {           \
+#define IMPL_COMP_MARRAY_CPLX_OP(op)                                           \
+  friend marray<bool, NumElements> operator op(const marray &lhs,              \
+                                               const marray &rhs) {            \
     marray<bool, NumElements> rtn;                                             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = lhs[i] op rhs[i];                                               \
@@ -264,8 +198,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  friend marray<bool, NumElements> operator op(const marray & lhs,             \
-                                               const value_type & rhs) {       \
+  friend marray<bool, NumElements> operator op(const marray &lhs,              \
+                                               const value_type &rhs) {        \
     marray<bool, NumElements> rtn;                                             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = lhs[i] op rhs;                                                  \
@@ -273,8 +207,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  friend marray<bool, NumElements> operator op(const value_type & lhs,         \
-                                               const marray & rhs) {           \
+  friend marray<bool, NumElements> operator op(const value_type &lhs,          \
+                                               const marray &rhs) {            \
     marray<bool, NumElements> rtn;                                             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = lhs op rhs[i];                                                  \
@@ -282,30 +216,10 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }
 
-  MARRAY_CPLX_OP(==)
-  MARRAY_CPLX_OP(!=)
-
-#undef MARRAY_CPLX_OP
-
-  // MARRAY_CPLX_OP is: <, >, <=, >=
-#define MARRAY_CPLX_OP(op)                                                     \
-  friend marray<bool, NumElements> operator op(const marray & lhs,             \
-                                               const marray & rhs) = delete;   \
-  friend marray<bool, NumElements> operator op(                                \
-      const marray & lhs, const value_type & rhs) = delete;                    \
-  friend marray<bool, NumElements> operator op(const value_type & lhs,         \
-                                               const marray & rhs) = delete;
-
-  MARRAY_CPLX_OP(<);
-  MARRAY_CPLX_OP(>);
-  MARRAY_CPLX_OP(<=);
-  MARRAY_CPLX_OP(>=);
-
-#undef MARRAY_CPLX_OP
-
-  friend marray operator~(const marray &v) = delete;
+  IMPL_COMP_MARRAY_CPLX_OP(==)
+  IMPL_COMP_MARRAY_CPLX_OP(!=)
 
-  friend marray<bool, NumElements> operator!(const marray &v) = delete;
+#undef IMPL_COMP_MARRAY_CPLX_OP
 };
 
 } // namespace _V1

From 0fed583db13e5e5314b9eff9eff2ca1abab1ed91 Mon Sep 17 00:00:00 2001
From: Jefferson Le Quellec <jefferson.lequellec@codeplay.com>
Date: Tue, 7 May 2024 09:39:51 +0200
Subject: [PATCH 36/39] Apply clang-format

---
 .../oneapi/experimental/complex/detail/marray.hpp  | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
index 4b41368c0a874..1f7d38ddd05b8 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
@@ -55,7 +55,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
       typename = std::enable_if_t<
           sycl::detail::AllSuitableArgTypes<value_type, ArgTN...>::value &&
           sycl::detail::GetMArrayArgsSize<ArgTN...>::value == NumElements>>
-  constexpr marray(const ArgTN &...Args)
+  constexpr marray(const ArgTN &... Args)
       : marray{
             sycl::detail::MArrayArgArrayCreator<value_type, ArgTN...>::Create(
                 Args...),
@@ -92,9 +92,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
   iterator end() { return MData + NumElements; }
   const_iterator end() const { return MData + NumElements; }
 
-////////////////////////////////////////////////////////////////////////////////
-/// ASSIGNMENT OPERATORS
-////////////////////////////////////////////////////////////////////////////////
+  /// ASSIGNMENT OPERATORS
 
 #ifdef IMPL_ASSIGN_MARRAY_CPLX_OP
 #error "Multiple definition of IMPL_ASSIGN_MARRAY_CPLX_OP"
@@ -122,9 +120,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
 #undef IMPL_ASSIGN_MARRAY_CPLX_OP
 
-////////////////////////////////////////////////////////////////////////////////
-// ARITHMETIC OPERATORS
-////////////////////////////////////////////////////////////////////////////////
+  /// ARITHMETIC OPERATORS
 
 #ifdef IMPL_UNARY_MARRAY_CPLX_OP
 #error "Multiple definition of IMPL_UNARY_MARRAY_CPLX_OP"
@@ -180,9 +176,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 
 #undef IMPL_ARITH_MARRAY_CPLX_OP
 
-////////////////////////////////////////////////////////////////////////////////
-// COMPARAISON OPERATORS
-////////////////////////////////////////////////////////////////////////////////
+  /// COMPARAISON OPERATORS
 
 #ifdef IMPL_COMP_MARRAY_CPLX_OP
 #error "Multiple definition of IMPL_COMP_MARRAY_CPLX_OP"

From 38e2f9c59916b38b03abaa84e8c63835ac6cc943 Mon Sep 17 00:00:00 2001
From: Jefferson Le Quellec <jefferson.lequellec@codeplay.com>
Date: Fri, 10 May 2024 12:14:04 +0200
Subject: [PATCH 37/39] Rewrite tests that fail when usm_shared_allocations is
 not supported

---
 .../sycl_complex_marray_getters_test.cpp      |  48 +++---
 .../Complex/sycl_complex_marray_math_test.cpp | 145 ++++++++++--------
 .../sycl_complex_marray_operator_test.cpp     |  76 +++++----
 3 files changed, 154 insertions(+), 115 deletions(-)

diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
index b374aa7000345..f1ba3326ff5ad 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
@@ -19,20 +19,24 @@ template <typename T> struct test_real {
           experimental::complex<T>{static_cast<T>(init[i]), static_cast<T>(0)};
     }
 
-    auto *cplx_out =
-        sycl::malloc_shared<sycl::marray<T, GETTERS_TEST_CASE_SIZE>>(1, Q);
+    sycl::buffer<sycl::marray<T, GETTERS_TEST_CASE_SIZE>> cplx_out_buf{
+        sycl::range{1}};
+
+    Q.submit([&](sycl::handler &cgh) {
+      sycl::accessor cplx_out{cplx_out_buf, cgh};
+
+      cgh.single_task([=]() {
+        cplx_out[0] = sycl::ext::oneapi::experimental::real(cplx_in);
+      });
+    });
 
     /* Check cplx::complex output from device */
-    Q.single_task([=]() {
-       *cplx_out = sycl::ext::oneapi::experimental::real(cplx_in);
-     }).wait();
-    pass &= check_results(*cplx_out, std_in, /*is_device*/ true);
+    sycl::host_accessor cplx_out_acc{cplx_out_buf};
+    pass &= check_results(cplx_out_acc[0], std_in, /*is_device*/ true);
 
     /* Check cplx::complex output from host */
-    *cplx_out = sycl::ext::oneapi::experimental::real(cplx_in);
-    pass &= check_results(*cplx_out, std_in, /*is_device*/ false);
-
-    sycl::free(cplx_out, Q);
+    cplx_out_acc[0] = sycl::ext::oneapi::experimental::real(cplx_in);
+    pass &= check_results(cplx_out_acc[0], std_in, /*is_device*/ false);
 
     return pass;
   }
@@ -54,20 +58,24 @@ template <typename T> struct test_imag {
           experimental::complex<T>{static_cast<T>(0), static_cast<T>(init[i])};
     }
 
-    auto *cplx_out =
-        sycl::malloc_shared<sycl::marray<T, GETTERS_TEST_CASE_SIZE>>(1, Q);
+    sycl::buffer<sycl::marray<T, GETTERS_TEST_CASE_SIZE>> cplx_out_buf{
+        sycl::range{1}};
+
+    Q.submit([&](sycl::handler &cgh) {
+      sycl::accessor cplx_out{cplx_out_buf, cgh};
+
+      cgh.single_task([=]() {
+        cplx_out[0] = sycl::ext::oneapi::experimental::imag(cplx_in);
+      });
+    });
 
     /* Check cplx::complex output from device */
-    Q.single_task([=]() {
-       *cplx_out = sycl::ext::oneapi::experimental::imag(cplx_in);
-     }).wait();
-    pass &= check_results(*cplx_out, std_in, /*is_device*/ true);
+    sycl::host_accessor cplx_out_acc{cplx_out_buf};
+    pass &= check_results(cplx_out_acc[0], std_in, /*is_device*/ true);
 
     /* Check cplx::complex output from host */
-    *cplx_out = sycl::ext::oneapi::experimental::imag(cplx_in);
-    pass &= check_results(*cplx_out, std_in, /*is_device*/ false);
-
-    sycl::free(cplx_out, Q);
+    cplx_out_acc[0] = sycl::ext::oneapi::experimental::imag(cplx_in);
+    pass &= check_results(cplx_out_acc[0], std_in, /*is_device*/ false);
 
     return pass;
   }
diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
index 9f75c31b2d620..cab43cfaeef47 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
@@ -24,9 +24,9 @@
       }                                                                        \
                                                                                \
       sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
-      auto *cplx_out = sycl::malloc_shared<                                    \
-          sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1,   \
-                                                                          Q);  \
+      sycl::buffer<                                                            \
+          sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>      \
+          cplx_out_buf{sycl::range{1}};                                        \
                                                                                \
       /* Get std::complex output */                                            \
       if (use_ref) {                                                           \
@@ -41,20 +41,23 @@
         }                                                                      \
       }                                                                        \
                                                                                \
+      Q.submit([&](sycl::handler &cgh) {                                       \
+        sycl::accessor cplx_out{cplx_out_buf, cgh};                            \
+                                                                               \
+        cgh.single_task(                                                       \
+            [=]() { cplx_out[0] = experimental::func_name(cplx_in); });        \
+      });                                                                      \
+                                                                               \
       /* Check cplx::complex output from device */                             \
-      Q.single_task([=]() {                                                    \
-         *cplx_out = experimental::func_name(cplx_in);                         \
-       }).wait();                                                              \
-      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+      sycl::host_accessor cplx_out_acc{cplx_out_buf};                          \
+      pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),       \
                             /*is_device*/ true);                               \
                                                                                \
       /* Check cplx::complex output from host */                               \
-      *cplx_out = experimental::func_name(cplx_in);                            \
-      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+      cplx_out_acc[0] = experimental::func_name(cplx_in);                      \
+      pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),       \
                             /*is_device*/ false);                              \
                                                                                \
-      sycl::free(cplx_out, Q);                                                 \
-                                                                               \
       return pass;                                                             \
     }                                                                          \
   };
@@ -102,8 +105,8 @@ TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(tanh)
       }                                                                        \
                                                                                \
       sycl::marray<T, DEFAULT_TEST_CASE_SIZE> std_out{};                       \
-      auto *cplx_out =                                                         \
-          sycl::malloc_shared<sycl::marray<T, DEFAULT_TEST_CASE_SIZE>>(1, Q);  \
+      sycl::buffer<sycl::marray<T, DEFAULT_TEST_CASE_SIZE>> cplx_out_buf{      \
+          sycl::range{1}};                                                     \
                                                                                \
       /* Get std::complex output */                                            \
       if (use_ref) {                                                           \
@@ -116,17 +119,20 @@ TEST_MATH_MARRAY_CPLX_IN_CPLX_OUT(tanh)
         }                                                                      \
       }                                                                        \
                                                                                \
+      Q.submit([&](sycl::handler &cgh) {                                       \
+        sycl::accessor cplx_out{cplx_out_buf, cgh};                            \
+                                                                               \
+        cgh.single_task(                                                       \
+            [=]() { cplx_out[0] = experimental::func_name(cplx_in); });        \
+      });                                                                      \
+                                                                               \
       /* Check cplx::complex output from device */                             \
-      Q.single_task([=]() {                                                    \
-         *cplx_out = experimental::func_name(cplx_in);                         \
-       }).wait();                                                              \
-      pass &= check_results(*cplx_out, std_out, /*is_device*/ true);           \
+      sycl::host_accessor cplx_out_acc{cplx_out_buf};                          \
+      pass &= check_results(cplx_out_acc[0], std_out, /*is_device*/ true);     \
                                                                                \
       /* Check cplx::complex output from host */                               \
-      *cplx_out = experimental::func_name(cplx_in);                            \
-      pass &= check_results(*cplx_out, std_out, /*is_device*/ false);          \
-                                                                               \
-      sycl::free(cplx_out, Q);                                                 \
+      cplx_out_acc[0] = experimental::func_name(cplx_in);                      \
+      pass &= check_results(cplx_out_acc[0], std_out, /*is_device*/ false);    \
                                                                                \
       return pass;                                                             \
     }                                                                          \
@@ -153,8 +159,8 @@ template <typename T> struct test_polar {
     }
 
     sycl::marray<std::complex<T>, POLAR_TEST_CASE_SIZE> std_out{};
-    auto *cplx_out = sycl::malloc_shared<
-        sycl::marray<experimental::complex<T>, POLAR_TEST_CASE_SIZE>>(1, Q);
+    sycl::buffer<sycl::marray<experimental::complex<T>, POLAR_TEST_CASE_SIZE>>
+        cplx_out_buf{sycl::range{1}};
 
     /* Get std::complex output */
     if (use_ref) {
@@ -169,17 +175,19 @@ template <typename T> struct test_polar {
       }
     }
 
+    Q.submit([&](sycl::handler &cgh) {
+      sycl::accessor cplx_out{cplx_out_buf, cgh};
+
+      cgh.single_task([=]() { cplx_out[0] = experimental::polar(rho, theta); });
+    });
+
     /* Check cplx::complex output from device */
-    Q.single_task([=]() {
-       *cplx_out = experimental::polar(rho, theta);
-     }).wait();
-    pass &= check_results(*cplx_out, std_out, /*is_device*/ true);
+    sycl::host_accessor cplx_out_acc{cplx_out_buf};
+    pass &= check_results(cplx_out_acc[0], std_out, /*is_device*/ true);
 
     /* Check cplx::complex output from host */
-    *cplx_out = experimental::polar(rho, theta);
-    pass &= check_results(*cplx_out, std_out, /*is_device*/ false);
-
-    sycl::free(cplx_out, Q);
+    cplx_out_acc[0] = experimental::polar(rho, theta);
+    pass &= check_results(cplx_out_acc[0], std_out, /*is_device*/ false);
 
     return pass;
   }
@@ -206,8 +214,8 @@ template <typename T> struct test_pow_cplx_cplx {
     }
 
     sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_out{};
-    auto *cplx_out = sycl::malloc_shared<
-        sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1, Q);
+    sycl::buffer<sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>
+        cplx_out_buf{sycl::range{1}};
 
     /* Get std::complex output */
     if (use_ref) {
@@ -222,20 +230,23 @@ template <typename T> struct test_pow_cplx_cplx {
       }
     }
 
+    Q.submit([&](sycl::handler &cgh) {
+      sycl::accessor cplx_out{cplx_out_buf, cgh};
+
+      cgh.single_task(
+          [=]() { cplx_out[0] = experimental::pow(cplx_in, cplx_in); });
+    });
+
     /* Check cplx::complex output from device */
-    Q.single_task([=]() {
-       *cplx_out = experimental::pow(cplx_in, cplx_in);
-     }).wait();
-    pass &= check_results(*cplx_out, convert_marray<T>(std_out),
+    sycl::host_accessor cplx_out_acc{cplx_out_buf};
+    pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),
                           /*is_device*/ true);
 
     /* Check cplx::complex output from host */
-    *cplx_out = experimental::pow(cplx_in, cplx_in);
-    pass &= check_results(*cplx_out, convert_marray<T>(std_out),
+    cplx_out_acc[0] = experimental::pow(cplx_in, cplx_in);
+    pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),
                           /*is_device*/ false);
 
-    sycl::free(cplx_out, Q);
-
     return pass;
   }
 };
@@ -261,8 +272,8 @@ template <typename T> struct test_pow_cplx_deci {
     }
 
     sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_out{};
-    auto *cplx_out = sycl::malloc_shared<
-        sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1, Q);
+    sycl::buffer<sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>
+        cplx_out_buf{sycl::range{1}};
 
     /* Get std::complex output */
     if (use_ref) {
@@ -277,22 +288,26 @@ template <typename T> struct test_pow_cplx_deci {
       }
     }
 
+    Q.submit([&](sycl::handler &cgh) {
+      sycl::accessor cplx_out{cplx_out_buf, cgh};
+
+      cgh.single_task([=]() {
+        cplx_out[0] = experimental::pow(
+            cplx_in, sycl::ext::oneapi::experimental::real(cplx_in));
+      });
+    });
+
     /* Check cplx::complex output from device */
-    Q.single_task([=]() {
-       *cplx_out = experimental::pow(
-           cplx_in, sycl::ext::oneapi::experimental::real(cplx_in));
-     }).wait();
-    pass &= check_results(*cplx_out, convert_marray<T>(std_out),
+    sycl::host_accessor cplx_out_acc{cplx_out_buf};
+    pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),
                           /*is_device*/ true);
 
     /* Check cplx::complex output from host */
-    *cplx_out = experimental::pow(
+    cplx_out_acc[0] = experimental::pow(
         cplx_in, sycl::ext::oneapi::experimental::real(cplx_in));
-    pass &= check_results(*cplx_out, convert_marray<T>(std_out),
+    pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),
                           /*is_device*/ false);
 
-    sycl::free(cplx_out, Q);
-
     return pass;
   }
 };
@@ -318,8 +333,8 @@ template <typename T> struct test_pow_deci_cplx {
     }
 
     sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_out{};
-    auto *cplx_out = sycl::malloc_shared<
-        sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1, Q);
+    sycl::buffer<sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>
+        cplx_out_buf{sycl::range{1}};
 
     /* Get std::complex output */
     if (use_ref) {
@@ -334,22 +349,26 @@ template <typename T> struct test_pow_deci_cplx {
       }
     }
 
+    Q.submit([&](sycl::handler &cgh) {
+      sycl::accessor cplx_out{cplx_out_buf, cgh};
+
+      cgh.single_task([=]() {
+        cplx_out[0] = experimental::pow(
+            sycl::ext::oneapi::experimental::real(cplx_in), cplx_in);
+      });
+    });
+
     /* Check cplx::complex output from device */
-    Q.single_task([=]() {
-       *cplx_out = experimental::pow(
-           sycl::ext::oneapi::experimental::real(cplx_in), cplx_in);
-     }).wait();
-    pass &= check_results(*cplx_out, convert_marray<T>(std_out),
+    sycl::host_accessor cplx_out_acc{cplx_out_buf};
+    pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),
                           /*is_device*/ true);
 
     /* Check cplx::complex output from host */
-    *cplx_out = experimental::pow(
+    cplx_out_acc[0] = experimental::pow(
         sycl::ext::oneapi::experimental::real(cplx_in), cplx_in);
-    pass &= check_results(*cplx_out, convert_marray<T>(std_out),
+    pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),
                           /*is_device*/ false);
 
-    sycl::free(cplx_out, Q);
-
     return pass;
   }
 };
diff --git a/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp b/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp
index c454a5ce76302..6db6709c2e903 100644
--- a/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp
@@ -25,9 +25,9 @@
       }                                                                        \
                                                                                \
       sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
-      auto *cplx_out = sycl::malloc_shared<                                    \
-          sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1,   \
-                                                                          Q);  \
+      sycl::buffer<                                                            \
+          sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>      \
+          cplx_out_buf{sycl::range{1}};                                        \
                                                                                \
       /* Get std::complex output */                                            \
       if (use_ref) {                                                           \
@@ -42,18 +42,22 @@
         }                                                                      \
       }                                                                        \
                                                                                \
+      Q.submit([&](sycl::handler &cgh) {                                       \
+        sycl::accessor cplx_out{cplx_out_buf, cgh};                            \
+                                                                               \
+        cgh.single_task([=]() { cplx_out[0] = cplx_in op cplx_in; });          \
+      });                                                                      \
+                                                                               \
       /* Check cplx::complex output from device */                             \
-      Q.single_task([=]() { *cplx_out = cplx_in op cplx_in; }).wait();         \
-      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+      sycl::host_accessor cplx_out_acc{cplx_out_buf};                          \
+      pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),       \
                             /*is_device*/ true);                               \
                                                                                \
       /* Check cplx::complex output from host */                               \
-      *cplx_out = cplx_in op cplx_in;                                          \
-      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+      cplx_out_acc[0] = cplx_in op cplx_in;                                    \
+      pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),       \
                             /*is_device*/ false);                              \
                                                                                \
-      sycl::free(cplx_out, Q);                                                 \
-                                                                               \
       return pass;                                                             \
     }                                                                          \
   };
@@ -86,13 +90,10 @@ TEST_BASIC_OPERATOR(div, /)
                                               static_cast<T>(init[i].im)};     \
       }                                                                        \
                                                                                \
-      sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
-      auto *cplx_out = sycl::malloc_shared<                                    \
-          sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1,   \
-                                                                          Q);  \
-                                                                               \
-      std_out = std_in;                                                        \
-      *cplx_out = cplx_in;                                                     \
+      sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_out{std_in};   \
+      sycl::buffer<                                                            \
+          sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>      \
+          cplx_out_buf{&cplx_in, sycl::range{1}};                              \
                                                                                \
       /* Get std::complex output */                                            \
       if (use_ref) {                                                           \
@@ -107,20 +108,27 @@ TEST_BASIC_OPERATOR(div, /)
         }                                                                      \
       }                                                                        \
                                                                                \
+      Q.submit([&](sycl::handler &cgh) {                                       \
+        sycl::accessor cplx_out{cplx_out_buf, cgh};                            \
+                                                                               \
+        cgh.single_task([=]() { cplx_out[0] op cplx_in; });                    \
+      });                                                                      \
+                                                                               \
       /* Check cplx::complex output from device */                             \
-      Q.single_task([=]() { *cplx_out op cplx_in; }).wait();                   \
-      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+      sycl::host_accessor cplx_out_acc{cplx_out_buf};                          \
+      pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),       \
                             /*is_device*/ true);                               \
                                                                                \
-      *cplx_out = cplx_in;                                                     \
+      for (std::size_t i = 0; i < DEFAULT_TEST_CASE_SIZE; ++i) {               \
+        cplx_in[i] = experimental::complex<T>{static_cast<T>(init[i].re),      \
+                                              static_cast<T>(init[i].im)};     \
+      }                                                                        \
                                                                                \
       /* Check cplx::complex output from host */                               \
-      *cplx_out op cplx_in;                                                    \
-      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+      cplx_out_acc[0] op cplx_in;                                              \
+      pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),       \
                             /*is_device*/ false);                              \
                                                                                \
-      sycl::free(cplx_out, Q);                                                 \
-                                                                               \
       return pass;                                                             \
     }                                                                          \
   };
@@ -154,9 +162,9 @@ TEST_ASSIGN_OPERATOR(assign_div, /=)
       }                                                                        \
                                                                                \
       sycl::marray<std::complex<X>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
-      auto *cplx_out = sycl::malloc_shared<                                    \
-          sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>(1,   \
-                                                                          Q);  \
+      sycl::buffer<                                                            \
+          sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>      \
+          cplx_out_buf{sycl::range{1}};                                        \
                                                                                \
       /* Get std::complex output */                                            \
       if (use_ref) {                                                           \
@@ -171,18 +179,22 @@ TEST_ASSIGN_OPERATOR(assign_div, /=)
         }                                                                      \
       }                                                                        \
                                                                                \
+      Q.submit([&](sycl::handler &cgh) {                                       \
+        sycl::accessor cplx_out{cplx_out_buf, cgh};                            \
+                                                                               \
+        cgh.single_task([=]() { cplx_out[0] = op cplx_in; });                  \
+      });                                                                      \
+                                                                               \
       /* Check cplx::complex output from device */                             \
-      Q.single_task([=]() { *cplx_out = op cplx_in; }).wait();                 \
-      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+      sycl::host_accessor cplx_out_acc{cplx_out_buf};                          \
+      pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),       \
                             /*is_device*/ true);                               \
                                                                                \
       /* Check cplx::complex output from host */                               \
-      *cplx_out = op cplx_in;                                                  \
-      pass &= check_results(*cplx_out, convert_marray<T>(std_out),             \
+      cplx_out_acc[0] = op cplx_in;                                            \
+      pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),       \
                             /*is_device*/ false);                              \
                                                                                \
-      sycl::free(cplx_out, Q);                                                 \
-                                                                               \
       return pass;                                                             \
     }                                                                          \
   };

From a3b4b0514e656cfc494cc355076854f824b627b9 Mon Sep 17 00:00:00 2001
From: Jefferson Le Quellec <jefferson.lequellec@codeplay.com>
Date: Fri, 10 May 2024 12:29:52 +0200
Subject: [PATCH 38/39] Apply clang-format manually

---
 .../experimental/complex/detail/marray.hpp     | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
index 1f7d38ddd05b8..1e3a7adb06f73 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
@@ -55,7 +55,7 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
       typename = std::enable_if_t<
           sycl::detail::AllSuitableArgTypes<value_type, ArgTN...>::value &&
           sycl::detail::GetMArrayArgsSize<ArgTN...>::value == NumElements>>
-  constexpr marray(const ArgTN &... Args)
+  constexpr marray(const ArgTN &...Args)
       : marray{
             sycl::detail::MArrayArgArrayCreator<value_type, ArgTN...>::Create(
                 Args...),
@@ -99,14 +99,14 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 #endif
 
 #define IMPL_ASSIGN_MARRAY_CPLX_OP(op)                                         \
-  friend marray &operator op(marray &lhs, const marray &rhs) {                 \
+  friend marray &operator op(marray & lhs, const marray & rhs) {               \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       lhs[i] op rhs[i];                                                        \
     }                                                                          \
     return lhs;                                                                \
   }                                                                            \
                                                                                \
-  friend marray &operator op(marray &lhs, const value_type &rhs) {             \
+  friend marray &operator op(marray & lhs, const value_type & rhs) {           \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       lhs[i] op rhs;                                                           \
     }                                                                          \
@@ -183,8 +183,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
 #endif
 
 #define IMPL_COMP_MARRAY_CPLX_OP(op)                                           \
-  friend marray<bool, NumElements> operator op(const marray &lhs,              \
-                                               const marray &rhs) {            \
+  friend marray<bool, NumElements> operator op(const marray & lhs,             \
+                                               const marray & rhs) {           \
     marray<bool, NumElements> rtn;                                             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = lhs[i] op rhs[i];                                               \
@@ -192,8 +192,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  friend marray<bool, NumElements> operator op(const marray &lhs,              \
-                                               const value_type &rhs) {        \
+  friend marray<bool, NumElements> operator op(const marray & lhs,             \
+                                               const value_type & rhs) {       \
     marray<bool, NumElements> rtn;                                             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = lhs[i] op rhs;                                                  \
@@ -201,8 +201,8 @@ class marray<sycl::ext::oneapi::experimental::complex<T>, NumElements> {
     return rtn;                                                                \
   }                                                                            \
                                                                                \
-  friend marray<bool, NumElements> operator op(const value_type &lhs,          \
-                                               const marray &rhs) {            \
+  friend marray<bool, NumElements> operator op(const value_type & lhs,         \
+                                               const marray & rhs) {           \
     marray<bool, NumElements> rtn;                                             \
     for (std::size_t i = 0; i < NumElements; ++i) {                            \
       rtn[i] = lhs op rhs[i];                                                  \

From 8a580801641c6d531956cff88efbb5dd09cdc403 Mon Sep 17 00:00:00 2001
From: Jefferson Le Quellec <jefferson.lequellec@codeplay.com>
Date: Mon, 20 May 2024 11:52:50 +0200
Subject: [PATCH 39/39] Refactor marray builtins

---
 .../complex/detail/marray_math.hpp            | 248 +++++++-----------
 sycl/test/extensions/complex/marray.cpp       |   2 +
 2 files changed, 95 insertions(+), 155 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp
index dccda84bfa96c..b9aaf793fe013 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp
@@ -19,169 +19,107 @@ namespace ext {
 namespace oneapi {
 namespace experimental {
 
-#ifdef MARRAY_CPLX_MATH_OP_ONE_PARAM
-#error "Multiple definition of MARRAY_CPLX_MATH_OP_ONE_PARAM"
+#ifdef ONE_ARG_MARRAY_TYPE
+#error "Multiple definition of ONE_ARG_MARRAY_TYPE"
 #endif
-
-#define MARRAY_CPLX_MATH_OP_ONE_PARAM(math_func, rtn_type, arg_type)           \
-  template <typename T, std::size_t NumElements>                               \
-  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
-      typename std::enable_if_t<is_genfloat<T>::value ||                       \
-                                    is_gencomplex<T>::value,                   \
-                                sycl::marray<rtn_type, NumElements>>           \
-      math_func(const sycl::marray<arg_type, NumElements> &x) {                \
-    sycl::marray<rtn_type, NumElements> rtn;                                   \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = math_func(x[i]);                                                \
-    }                                                                          \
-    return rtn;                                                                \
-  }
-
-MARRAY_CPLX_MATH_OP_ONE_PARAM(abs, T, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(acos, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(asin, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(atan, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(acosh, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(asinh, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(atanh, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(arg, T, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(conj, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(cos, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(cosh, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(exp, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(log, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(log10, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(norm, T, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(proj, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(proj, complex<T>, T);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(sin, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(sinh, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(sqrt, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(tan, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_ONE_PARAM(tanh, complex<T>, complex<T>);
-
-#undef MARRAY_CPLX_MATH_OP_ONE_PARAM
-
-#ifdef MARRAY_CPLX_MATH_OP_TWO_PARAM
-#error "Multiple definition of MARRAY_CPLX_MATH_OP_TWO_PARAM"
+#ifdef TWO_ARGS_MARRAY_TYPE
+#error "Multiple definition of TWO_ARGS_MARRAY_TYPE"
 #endif
 
-#define MARRAY_CPLX_MATH_OP_TWO_PARAM(math_func, rtn_type, arg_type1,          \
-                                      arg_type2)                               \
-  template <typename T, std::size_t NumElements>                               \
-  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
-      typename std::enable_if_t<is_genfloat<T>::value ||                       \
-                                    is_gencomplex<T>::value,                   \
-                                sycl::marray<rtn_type, NumElements>>           \
-      math_func(const sycl::marray<arg_type1, NumElements> &x,                 \
-                const sycl::marray<arg_type2, NumElements> &y) {               \
-    sycl::marray<rtn_type, NumElements> rtn;                                   \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = math_func(x[i], y[i]);                                          \
-    }                                                                          \
-    return rtn;                                                                \
-  }                                                                            \
-                                                                               \
-  template <typename T, std::size_t NumElements>                               \
-  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
-      typename std::enable_if_t<is_genfloat<T>::value ||                       \
-                                    is_gencomplex<T>::value,                   \
-                                sycl::marray<rtn_type, NumElements>>           \
-      math_func(const sycl::marray<arg_type1, NumElements> &x,                 \
-                const arg_type2 &y) {                                          \
-    sycl::marray<rtn_type, NumElements> rtn;                                   \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = math_func(x[i], y);                                             \
-    }                                                                          \
-    return rtn;                                                                \
-  }                                                                            \
-                                                                               \
-  template <typename T, std::size_t NumElements>                               \
-  _SYCL_EXT_CPLX_INLINE_VISIBILITY                                             \
-      typename std::enable_if_t<is_genfloat<T>::value ||                       \
-                                    is_gencomplex<T>::value,                   \
-                                sycl::marray<rtn_type, NumElements>>           \
-      math_func(const arg_type1 &x,                                            \
-                const sycl::marray<arg_type2, NumElements> &y) {               \
-    sycl::marray<rtn_type, NumElements> rtn;                                   \
-    for (std::size_t i = 0; i < NumElements; ++i) {                            \
-      rtn[i] = math_func(x, y[i]);                                             \
-    }                                                                          \
-    return rtn;                                                                \
-  }
-
-MARRAY_CPLX_MATH_OP_TWO_PARAM(pow, complex<T>, complex<T>, T);
-MARRAY_CPLX_MATH_OP_TWO_PARAM(pow, complex<T>, complex<T>, complex<T>);
-MARRAY_CPLX_MATH_OP_TWO_PARAM(pow, complex<T>, T, complex<T>);
-
-#undef MARRAY_CPLX_MATH_OP_TWO_PARAM
-
-// Special definition as polar requires default argument
-
-template <typename T, std::size_t NumElements>
-_SYCL_EXT_CPLX_INLINE_VISIBILITY
-    typename std::enable_if_t<is_genfloat<T>::value,
-                              sycl::marray<complex<T>, NumElements>>
-    polar(const sycl::marray<T, NumElements> &rho,
-          const sycl::marray<T, NumElements> &theta) {
-  sycl::marray<complex<T>, NumElements> rtn;
-  for (std::size_t i = 0; i < NumElements; ++i) {
-    rtn[i] = polar(rho[i], theta[i]);
-  }
-  return rtn;
-}
+#ifdef TWO_ARGS_POLAR_S1_MARRAY_TYPE
+#error "Multiple definition of TWO_ARGS_POLAR_S1_MARRAY_TYPE"
+#endif
+#ifdef TWO_ARGS_POLAR_S2_MARRAY_TYPE
+#error "Multiple definition of TWO_ARGS_POLAR_S2_MARRAY_TYPE"
+#endif
 
-template <typename T, std::size_t NumElements>
-_SYCL_EXT_CPLX_INLINE_VISIBILITY
-    typename std::enable_if_t<is_genfloat<T>::value,
-                              sycl::marray<complex<T>, NumElements>>
-    polar(const sycl::marray<T, NumElements> &rho, const T &theta = 0) {
-  sycl::marray<complex<T>, NumElements> rtn;
-  for (std::size_t i = 0; i < NumElements; ++i) {
-    rtn[i] = polar(rho[i], theta);
-  }
-  return rtn;
-}
+#ifdef TWO_ARGS_POW_S1_MARRAY_TYPE
+#error "Multiple definition of TWO_ARGS_POW_S1_MARRAY_TYPE"
+#endif
+#ifdef TWO_ARGS_POW_S2_MARRAY_TYPE
+#error "Multiple definition of TWO_ARGS_POW_S2_MARRAY_TYPE"
+#endif
 
-template <typename T, std::size_t NumElements>
-_SYCL_EXT_CPLX_INLINE_VISIBILITY
-    typename std::enable_if_t<is_genfloat<T>::value,
-                              sycl::marray<complex<T>, NumElements>>
-    polar(const T &rho, const sycl::marray<T, NumElements> &theta) {
-  sycl::marray<complex<T>, NumElements> rtn;
-  for (std::size_t i = 0; i < NumElements; ++i) {
-    rtn[i] = polar(rho, theta[i]);
-  }
-  return rtn;
-}
+#ifdef MARRAY_CPLX_MATH_OP
+#error "Multiple definition of MARRAY_CPLX_MATH_OP"
+#endif
 
-// real
-
-template <typename T, std::size_t NumElements>
-_SYCL_EXT_CPLX_INLINE_VISIBILITY
-    typename std::enable_if_t<is_genfloat<T>::value,
-                              sycl::marray<T, NumElements>>
-    real(const marray<complex<T>, NumElements> &z) {
-  sycl::marray<T, NumElements> rtn;
-  for (std::size_t i = 0; i < NumElements; ++i) {
-    rtn[i] = z[i].real();
-  }
-  return rtn;
+// clang-format off
+#define ONE_ARG_MARRAY_TYPE(TYPE) const sycl::marray<TYPE, NumElements> &x
+#define TWO_ARGS_MARRAY_TYPE(TYPE1, TYPE2) const sycl::marray<TYPE1, NumElements> &x, const sycl::marray<TYPE2, NumElements> &y
+
+#define TWO_ARGS_POLAR_S1_MARRAY_TYPE(TYPE1, TYPE2) const sycl::marray<TYPE1, NumElements> &x, const TYPE2 &y = 0
+#define TWO_ARGS_POLAR_S2_MARRAY_TYPE(TYPE1, TYPE2) const TYPE1 &x, const sycl::marray<TYPE2, NumElements> &y
+
+#define TWO_ARGS_POW_S1_MARRAY_TYPE(TYPE1, TYPE2) const sycl::marray<TYPE1, NumElements> &x, const TYPE2 &y
+#define TWO_ARGS_POW_S2_MARRAY_TYPE(TYPE1, TYPE2) const TYPE1 &x, const sycl::marray<TYPE2, NumElements> &y
+
+#define MARRAY_CPLX_MATH_OP(NUM_ARGS, RTN_TYPE, NAME, F, ...)                         \
+template<typename T, std::size_t NumElements>                                         \
+_SYCL_EXT_CPLX_INLINE_VISIBILITY                                                      \
+typename std::enable_if_t<is_genfloat<T>::value, sycl::marray<RTN_TYPE, NumElements>> \
+NAME(NUM_ARGS##_MARRAY_TYPE(__VA_ARGS__)) {                                           \
+  sycl::marray<RTN_TYPE, NumElements> rtn;                                            \
+  for (std::size_t i = 0; i < NumElements; ++i) {                                     \
+    rtn[i] = F;                                                                       \
+  }                                                                                   \
+  return rtn;                                                                         \
 }
 
-// imag
-
-template <typename T, std::size_t NumElements>
-_SYCL_EXT_CPLX_INLINE_VISIBILITY
-    typename std::enable_if_t<is_genfloat<T>::value,
-                              sycl::marray<T, NumElements>>
-    imag(const marray<complex<T>, NumElements> &z) {
-  sycl::marray<T, NumElements> rtn;
-  for (std::size_t i = 0; i < NumElements; ++i) {
-    rtn[i] = z[i].imag();
-  }
-  return rtn;
-}
+// MARRAY_CPLX_MATH_OP(NUMBER_OF_ARGUMENTS, RETURN_TYPE, FUNCTION_NAME, FUNCTION_LOGIC,    ARGUMENTS ...
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             T,           abs,           abs(x[i]),         complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             T,           arg,           arg(x[i]),         complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             T,           arg,           arg(x[i]),         T);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             T,           norm,          norm(x[i]),        complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             T,           norm,          norm(x[i]),        T);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  conj,          conj(x[i]),        complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  conj,          conj(x[i]),        T);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  proj,          proj(x[i]),        complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  proj,          proj(x[i]),        T);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  log,           log(x[i]),         complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  log10,         log10(x[i]),       complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  sqrt,          sqrt(x[i]),        complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  exp,           exp(x[i]),         complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  asinh,         asinh(x[i]),       complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  acosh,         acosh(x[i]),       complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  atanh,         atanh(x[i]),       complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  sinh,          sinh(x[i]),        complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  cosh,          cosh(x[i]),        complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  tanh,          tanh(x[i]),        complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  asin,          asin(x[i]),        complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  acos,          acos(x[i]),        complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  atan,          atan(x[i]),        complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  sin,           sin(x[i]),         complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  cos,           cos(x[i]),         complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             complex<T>,  tan,           tan(x[i]),         complex<T>);
+
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             T,           real,          x[i].real(),       complex<T>);
+MARRAY_CPLX_MATH_OP(   ONE_ARG,             T,           imag,          x[i].imag(),       complex<T>);
+
+MARRAY_CPLX_MATH_OP(   TWO_ARGS,            complex<T>,  polar,         polar(x[i], y[i]), T,          T);
+MARRAY_CPLX_MATH_OP(   TWO_ARGS_POLAR_S1,   complex<T>,  polar,         polar(x[i], y),    T,          T);
+MARRAY_CPLX_MATH_OP(   TWO_ARGS_POLAR_S2,   complex<T>,  polar,         polar(x, y[i]),    T,          T);
+
+MARRAY_CPLX_MATH_OP(   TWO_ARGS,            complex<T>,  pow,           pow(x[i], y[i]),   complex<T>, T);
+MARRAY_CPLX_MATH_OP(   TWO_ARGS,            complex<T>,  pow,           pow(x[i], y[i]),   complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP(   TWO_ARGS,            complex<T>,  pow,           pow(x[i], y[i]),   T,          complex<T>);
+
+MARRAY_CPLX_MATH_OP(   TWO_ARGS_POW_S1,     complex<T>,  pow,           pow(x[i], y),      complex<T>, T);
+MARRAY_CPLX_MATH_OP(   TWO_ARGS_POW_S1,     complex<T>,  pow,           pow(x[i], y),      complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP(   TWO_ARGS_POW_S1,     complex<T>,  pow,           pow(x[i], y),      T,          complex<T>);
+
+MARRAY_CPLX_MATH_OP(   TWO_ARGS_POW_S2,     complex<T>,  pow,           pow(x, y[i]),      complex<T>, T);
+MARRAY_CPLX_MATH_OP(   TWO_ARGS_POW_S2,     complex<T>,  pow,           pow(x, y[i]),      complex<T>, complex<T>);
+MARRAY_CPLX_MATH_OP(   TWO_ARGS_POW_S2,     complex<T>,  pow,           pow(x, y[i]),      T,          complex<T>);
+// clang-format on
+
+#undef ONE_ARG_MARRAY_TYPE
+#undef TWO_ARGS_MARRAY_TYPE
+#undef TWO_ARGS_POLAR_S1_MARRAY_TYPE
+#undef TWO_ARGS_POLAR_S2_MARRAY_TYPE
+#undef TWO_ARGS_POW_S1_MARRAY_TYPE
+#undef TWO_ARGS_POW_S2_MARRAY_TYPE
+#undef MARRAY_CPLX_MATH_OP
 
 } // namespace experimental
 } // namespace oneapi
diff --git a/sycl/test/extensions/complex/marray.cpp b/sycl/test/extensions/complex/marray.cpp
index 82b268f37c055..db1c6e54db201 100644
--- a/sycl/test/extensions/complex/marray.cpp
+++ b/sycl/test/extensions/complex/marray.cpp
@@ -36,6 +36,8 @@ void test_valid_types() {
   };
 
 TEST_MATH_FUNC_TYPE(abs)
+TEST_MATH_FUNC_TYPE(arg)
+TEST_MATH_FUNC_TYPE(norm)
 #undef TEST_MATH_FUNC_TYPE
 
 // Define math function tests - marray<complex<T>> -> marray<complex<T>>