Format

src/targets/gpu/kernels/include/migraphx/kernels/array.hpp

@@ -33,42 +33,42 @@
 namespace migraphx {
 
 // NOLINTNEXTLINE
-#define MIGRAPHX_DEVICE_ARRAY_OP(op, binary_op)                                    \
-    template <class U>                                                             \
-    constexpr array& operator op(const array<U, N>& x)                             \
-    {                                                                              \
-        array_for_each(*this, x)([](auto& sy, auto sx) { sy op sx; });                                           \
-        return *this;                                                              \
-    }                                                                              \
-    template <class U, MIGRAPHX_REQUIRES(is_convertible<U, T>{})>                  \
-    constexpr array& operator op(const U& x)                                       \
-    {                                                                              \
-        array_for_each(*this)([&](auto& sy) { sy op x; });                                           \
-        return *this;                                                              \
-    }                                                                              \
-    template <class U>                                                             \
-    friend constexpr auto operator binary_op(const array& x, const array<U, N>& y) \
-    {                                                                              \
-        array<decltype(T {} binary_op U{}), N> z{};                                \
-        array_for_each(z, x, y)([&](auto& sz, auto sx, auto sy) { sz = sx binary_op sy; });                                           \
-        return z;                                                                  \
-    }                                                                              \
-    template <class U, MIGRAPHX_REQUIRES(is_convertible<U, T>{})>                  \
-    friend constexpr auto operator binary_op(const array& x, const U& y)           \
-    {                                                                              \
-        array<decltype(T {} binary_op U{}), N> z{};                                \
-        array_for_each(z, x)([&](auto& sz, auto sx) { sz = sx binary_op y; });                                           \
-        return z;                                                                  \
-    }                                                                              \
-    template <class U, MIGRAPHX_REQUIRES(is_convertible<U, T>{})>                  \
-    friend constexpr auto operator binary_op(const U& x, const array& y)           \
-    {                                                                              \
-        array<decltype(T {} binary_op U{}), N> z{};                                \
-        array_for_each(z, y)([&](auto& sz, auto sy) { sz = x binary_op sy; });                                           \
-        return z;                                                                  \
+#define MIGRAPHX_DEVICE_ARRAY_OP(op, binary_op)                                             \
+    template <class U>                                                                      \
+    constexpr array& operator op(const array<U, N>& x)                                      \
+    {                                                                                       \
+        array_for_each(*this, x)([](auto& sy, auto sx) { sy op sx; });                      \
+        return *this;                                                                       \
+    }                                                                                       \
+    template <class U, MIGRAPHX_REQUIRES(is_convertible<U, T>{})>                           \
+    constexpr array& operator op(const U& x)                                                \
+    {                                                                                       \
+        array_for_each (*this)([&](auto& sy) { sy op x; });                                 \
+        return *this;                                                                       \
+    }                                                                                       \
+    template <class U>                                                                      \
+    friend constexpr auto operator binary_op(const array& x, const array<U, N>& y)          \
+    {                                                                                       \
+        array<decltype(T {} binary_op U{}), N> z{};                                         \
+        array_for_each(z, x, y)([&](auto& sz, auto sx, auto sy) { sz = sx binary_op sy; }); \
+        return z;                                                                           \
+    }                                                                                       \
+    template <class U, MIGRAPHX_REQUIRES(is_convertible<U, T>{})>                           \
+    friend constexpr auto operator binary_op(const array& x, const U& y)                    \
+    {                                                                                       \
+        array<decltype(T {} binary_op U{}), N> z{};                                         \
+        array_for_each(z, x)([&](auto& sz, auto sx) { sz = sx binary_op y; });              \
+        return z;                                                                           \
+    }                                                                                       \
+    template <class U, MIGRAPHX_REQUIRES(is_convertible<U, T>{})>                           \
+    friend constexpr auto operator binary_op(const U& x, const array& y)                    \
+    {                                                                                       \
+        array<decltype(T {} binary_op U{}), N> z{};                                         \
+        array_for_each(z, y)([&](auto& sz, auto sy) { sz = x binary_op sy; });              \
+        return z;                                                                           \
     }
 
-template<class T, class... Ts>
+template <class T, class... Ts>
 constexpr auto array_for_each(T& x, Ts&... xs)
 {
     return [&](auto f) {