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/marray.hpp b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
new file mode 100644
index 0000000000000..1e3a7adb06f73
--- /dev/null
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray.hpp
@@ -0,0 +1,220 @@
+//===- 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/marray.hpp>
+#include <sycl/types.hpp>
+
+namespace sycl {
+inline namespace _V1 {
+
+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;
+  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]...} {}
+
+  // 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:
+  constexpr marray() : MData{} {};
+
+  explicit constexpr marray(const value_type &arg)
+      : marray{sycl::detail::RepeatValue<NumElements>(
+                   static_cast<MarrayDataT>(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; }
+
+  // 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; }
+
+  /// ASSIGNMENT OPERATORS
+
+#ifdef IMPL_ASSIGN_MARRAY_CPLX_OP
+#error "Multiple definition of IMPL_ASSIGN_MARRAY_CPLX_OP"
+#endif
+
+#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) {                            \
+      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;                                                                \
+  }
+
+  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] = op lhs[i];                                                      \
+    }                                                                          \
+    return rtn;                                                                \
+  }
+
+  IMPL_UNARY_MARRAY_CPLX_OP(+)
+  IMPL_UNARY_MARRAY_CPLX_OP(-)
+
+#undef IMPL_UNARY_MARRAY_CPLX_OP
+
+#ifdef IMPL_ARITH_MARRAY_CPLX_OP
+#error "Multiple definition of IMPL_ARITH_MARRAY_CPLX_OP"
+#endif
+
+#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) {                            \
+      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;                                                                \
+  }
+
+  IMPL_ARITH_MARRAY_CPLX_OP(+)
+  IMPL_ARITH_MARRAY_CPLX_OP(-)
+  IMPL_ARITH_MARRAY_CPLX_OP(*)
+  IMPL_ARITH_MARRAY_CPLX_OP(/)
+
+#undef IMPL_ARITH_MARRAY_CPLX_OP
+
+  /// COMPARAISON OPERATORS
+
+#ifdef IMPL_COMP_MARRAY_CPLX_OP
+#error "Multiple definition of IMPL_COMP_MARRAY_CPLX_OP"
+#endif
+
+#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];                                               \
+    }                                                                          \
+    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;                                                                \
+  }
+
+  IMPL_COMP_MARRAY_CPLX_OP(==)
+  IMPL_COMP_MARRAY_CPLX_OP(!=)
+
+#undef IMPL_COMP_MARRAY_CPLX_OP
+};
+
+} // 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..b9aaf793fe013
--- /dev/null
+++ b/sycl/include/sycl/ext/oneapi/experimental/complex/detail/marray_math.hpp
@@ -0,0 +1,129 @@
+//===- 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 ONE_ARG_MARRAY_TYPE
+#error "Multiple definition of ONE_ARG_MARRAY_TYPE"
+#endif
+#ifdef TWO_ARGS_MARRAY_TYPE
+#error "Multiple definition of TWO_ARGS_MARRAY_TYPE"
+#endif
+
+#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
+
+#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
+
+#ifdef MARRAY_CPLX_MATH_OP
+#error "Multiple definition of MARRAY_CPLX_MATH_OP"
+#endif
+
+// 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;                                                                         \
+}
+
+// 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
+} // namespace ext
+
+} // namespace _V1
+} // namespace sycl
diff --git a/sycl/include/sycl/marray.hpp b/sycl/include/sycl/marray.hpp
index bc45a45424312..2b4ff20a56569 100644
--- a/sycl/include/sycl/marray.hpp
+++ b/sycl/include/sycl/marray.hpp
@@ -40,6 +40,51 @@ 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>...> {};
+
+class FlattenMArrayArgHelper {
+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> FlattenMArray(const marray<T, N> &A) {
+    return MArrayToArray<DataT>(A, std::make_index_sequence<N>());
+  }
+  template <typename DataT, typename T>
+  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 FlattenMArrayArgHelper::FlattenMArray<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
@@ -59,47 +104,13 @@ 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.
+  // 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) {
     for (size_t i = 0; i < NumElements; ++i) {
@@ -121,10 +132,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 +153,6 @@ 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]; }
 
   marray &operator=(const marray<Type, NumElements> &Rhs) = default;
diff --git a/sycl/test-e2e/Complex/sycl_complex_helper.hpp b/sycl/test-e2e/Complex/sycl_complex_helper.hpp
index a57f736f5244e..d90e50e215724 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;
+}
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..f1ba3326ff5ad
--- /dev/null
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_getters_test.cpp
@@ -0,0 +1,104 @@
+// RUN: %{build} -o %t.out
+// RUN: %{run} %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)};
+    }
+
+    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 */
+    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_acc[0] = sycl::ext::oneapi::experimental::real(cplx_in);
+    pass &= check_results(cplx_out_acc[0], std_in, /*is_device*/ false);
+
+    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])};
+    }
+
+    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 */
+    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_acc[0] = sycl::ext::oneapi::experimental::imag(cplx_in);
+    pass &= check_results(cplx_out_acc[0], std_in, /*is_device*/ false);
+
+    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;
+}
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..cab43cfaeef47
--- /dev/null
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_math_test.cpp
@@ -0,0 +1,515 @@
+// RUN: %{build} -o %t.out
+// RUN: %{run} %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<X>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
+      sycl::buffer<                                                            \
+          sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>      \
+          cplx_out_buf{sycl::range{1}};                                        \
+                                                                               \
+      /* 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]);                              \
+        }                                                                      \
+      }                                                                        \
+                                                                               \
+      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 */                             \
+      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_acc[0] = experimental::func_name(cplx_in);                      \
+      pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),       \
+                            /*is_device*/ false);                              \
+                                                                               \
+      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{};                       \
+      sycl::buffer<sycl::marray<T, DEFAULT_TEST_CASE_SIZE>> cplx_out_buf{      \
+          sycl::range{1}};                                                     \
+                                                                               \
+      /* 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]);                              \
+        }                                                                      \
+      }                                                                        \
+                                                                               \
+      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 */                             \
+      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_acc[0] = experimental::func_name(cplx_in);                      \
+      pass &= check_results(cplx_out_acc[0], std_out, /*is_device*/ false);    \
+                                                                               \
+      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{};
+    sycl::buffer<sycl::marray<experimental::complex<T>, POLAR_TEST_CASE_SIZE>>
+        cplx_out_buf{sycl::range{1}};
+
+    /* 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]);
+      }
+    }
+
+    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 */
+    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_acc[0] = experimental::polar(rho, theta);
+    pass &= check_results(cplx_out_acc[0], std_out, /*is_device*/ false);
+
+    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<X>, DEFAULT_TEST_CASE_SIZE> std_out{};
+    sycl::buffer<sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>
+        cplx_out_buf{sycl::range{1}};
+
+    /* 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]);
+      }
+    }
+
+    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 */
+    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_acc[0] = experimental::pow(cplx_in, cplx_in);
+    pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),
+                          /*is_device*/ false);
+
+    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<X>, DEFAULT_TEST_CASE_SIZE> std_out{};
+    sycl::buffer<sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>
+        cplx_out_buf{sycl::range{1}};
+
+    /* 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());
+      }
+    }
+
+    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 */
+    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_acc[0] = experimental::pow(
+        cplx_in, sycl::ext::oneapi::experimental::real(cplx_in));
+    pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),
+                          /*is_device*/ false);
+
+    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<X>, DEFAULT_TEST_CASE_SIZE> std_out{};
+    sycl::buffer<sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>
+        cplx_out_buf{sycl::range{1}};
+
+    /* 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]);
+      }
+    }
+
+    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 */
+    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_acc[0] = experimental::pow(
+        sycl::ext::oneapi::experimental::real(cplx_in), cplx_in);
+    pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),
+                          /*is_device*/ false);
+
+    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;
+}
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..6db6709c2e903
--- /dev/null
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_operator_test.cpp
@@ -0,0 +1,269 @@
+// RUN: %{build} -o %t.out
+// RUN: %{run} %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<X>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
+      sycl::buffer<                                                            \
+          sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>      \
+          cplx_out_buf{sycl::range{1}};                                        \
+                                                                               \
+      /* 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];                                 \
+        }                                                                      \
+      }                                                                        \
+                                                                               \
+      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 */                             \
+      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_acc[0] = cplx_in op cplx_in;                                    \
+      pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),       \
+                            /*is_device*/ false);                              \
+                                                                               \
+      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<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) {                                                           \
+        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];                                             \
+        }                                                                      \
+      }                                                                        \
+                                                                               \
+      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 */                             \
+      sycl::host_accessor cplx_out_acc{cplx_out_buf};                          \
+      pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),       \
+                            /*is_device*/ true);                               \
+                                                                               \
+      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_acc[0] op cplx_in;                                              \
+      pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),       \
+                            /*is_device*/ false);                              \
+                                                                               \
+      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<X>, DEFAULT_TEST_CASE_SIZE> std_out{};         \
+      sycl::buffer<                                                            \
+          sycl::marray<experimental::complex<T>, DEFAULT_TEST_CASE_SIZE>>      \
+          cplx_out_buf{sycl::range{1}};                                        \
+                                                                               \
+      /* 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];                                           \
+        }                                                                      \
+      }                                                                        \
+                                                                               \
+      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 */                             \
+      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_acc[0] = op cplx_in;                                            \
+      pass &= check_results(cplx_out_acc[0], convert_marray<T>(std_out),       \
+                            /*is_device*/ false);                              \
+                                                                               \
+      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;
+}
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..e914631ea0419
--- /dev/null
+++ b/sycl/test-e2e/Complex/sycl_complex_marray_test_cases.hpp
@@ -0,0 +1,320 @@
+#include <iostream>
+#include <tuple>
+#include <vector>
+
+#include "sycl_complex_helper.hpp"
+
+#define DEFAULT_TEST_CASE_SIZE 45
+#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, 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>(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";
diff --git a/sycl/test/extensions/complex/complex.cpp b/sycl/test/extensions/complex/complex.cpp
index de39f9f8472cd..48ef0b5d291eb 100644
--- a/sycl/test/extensions/complex/complex.cpp
+++ b/sycl/test/extensions/complex/complex.cpp
@@ -35,7 +35,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() {
@@ -101,7 +101,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>();
diff --git a/sycl/test/extensions/complex/marray.cpp b/sycl/test/extensions/complex/marray.cpp
new file mode 100644
index 0000000000000..db1c6e54db201
--- /dev/null
+++ b/sycl/test/extensions/complex/marray.cpp
@@ -0,0 +1,279 @@
+// RUN: %clangxx -fsycl -fsyntax-only %s
+
+#define SYCL_EXT_ONEAPI_COMPLEX
+
+#include <sycl/ext/oneapi/experimental/complex/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)
+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>>
+#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;
+  }
+};
+
+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{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{cplx};
+    constexpr sycl::marray<Complex, 2> c{cplx, cplx};
+    constexpr sycl::marray<Complex, 4> d{c, c};
+  }
+}
+
+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>();
+
+  // Check constructors
+  check_constructors<sycl::half>();
+  check_constructors<float>();
+  check_constructors<double>();
+
+  return 0;
+}