From 38bed04d32f51d06d0d564d26359e831c75d566f Mon Sep 17 00:00:00 2001
From: Andrew Gozillon <andrew.gozillon@yahoo.com>
Date: Fri, 1 Feb 2019 18:49:46 -0800
Subject: [PATCH] [SYCL][NFC] id.hpp & range.hpp operator tidyup

This should be a NFC, refactoring the hardcoded operators in the range
and id classes into macros to generate them so that the classes are a
little more concise to read.

Signed-off-by: Andrew Gozillon <andrew.gozillon@yahoo.com>
---
 sycl/include/CL/sycl/id.hpp    | 547 +++++----------------------------
 sycl/include/CL/sycl/range.hpp | 542 ++++----------------------------
 2 files changed, 136 insertions(+), 953 deletions(-)

diff --git a/sycl/include/CL/sycl/id.hpp b/sycl/include/CL/sycl/id.hpp
index 326e0021f7898..d1e8ea125a721 100644
--- a/sycl/include/CL/sycl/id.hpp
+++ b/sycl/include/CL/sycl/id.hpp
@@ -75,486 +75,77 @@ template <int dimensions = 1> struct id : public detail::array<dimensions> {
   }
 
   // OP is: +, -, *, /, %, <<, >>, &, |, ^, &&, ||, <, >, <=, >=
-  id<dimensions> operator+(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] + rhs.common_array[i];
-    }
-    return result;
-  }
-  id<dimensions> operator-(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] - rhs.common_array[i];
-    }
-    return result;
-  }
-  id<dimensions> operator*(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] * rhs.common_array[i];
-    }
-    return result;
-  }
-  id<dimensions> operator/(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] / rhs.common_array[i];
-    }
-    return result;
-  }
-  id<dimensions> operator%(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] % rhs.common_array[i];
-    }
-    return result;
-  }
-  id<dimensions> operator<<(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] << rhs.common_array[i];
-    }
-    return result;
-  }
-  id<dimensions> operator>>(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] >> rhs.common_array[i];
-    }
-    return result;
-  }
-  id<dimensions> operator&(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] & rhs.common_array[i];
-    }
-    return result;
-  }
-  id<dimensions> operator|(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] | rhs.common_array[i];
-    }
-    return result;
-  }
-  id<dimensions> operator^(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] ^ rhs.common_array[i];
-    }
-    return result;
-  }
-  id<dimensions> operator&&(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] && rhs.common_array[i];
-    }
-    return result;
-  }
-  id<dimensions> operator||(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] || rhs.common_array[i];
-    }
-    return result;
-  }
-  id<dimensions> operator<(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] < rhs.common_array[i];
-    }
-    return result;
-  }
-  id<dimensions> operator>(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] > rhs.common_array[i];
-    }
-    return result;
-  }
-  id<dimensions> operator<=(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] <= rhs.common_array[i];
-    }
-    return result;
-  }
-  id<dimensions> operator>=(const id<dimensions> &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] >= rhs.common_array[i];
-    }
-    return result;
-  }
-
-  // OP is: +, -, *, /, %, <<, >>, &, |, ^, &&, ||, <, >, <=, >=
-  id<dimensions> operator+(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] + rhs;
-    }
-    return result;
-  }
-  id<dimensions> operator-(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] - rhs;
-    }
-    return result;
-  }
-  id<dimensions> operator*(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] * rhs;
-    }
-    return result;
-  }
-  id<dimensions> operator/(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] / rhs;
-    }
-    return result;
-  }
-  id<dimensions> operator%(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] % rhs;
-    }
-    return result;
-  }
-  id<dimensions> operator<<(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] << rhs;
-    }
-    return result;
-  }
-  id<dimensions> operator>>(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] >> rhs;
-    }
-    return result;
-  }
-  id<dimensions> operator&(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] & rhs;
-    }
-    return result;
-  }
-  id<dimensions> operator|(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] | rhs;
-    }
-    return result;
-  }
-  id<dimensions> operator^(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] ^ rhs;
-    }
-    return result;
-  }
-  id<dimensions> operator&&(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] && rhs;
-    }
-    return result;
-  }
-  id<dimensions> operator||(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] || rhs;
-    }
-    return result;
-  }
-  id<dimensions> operator<(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] < rhs;
-    }
-    return result;
-  }
-  id<dimensions> operator>(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] > rhs;
-    }
-    return result;
-  }
-  id<dimensions> operator<=(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] <= rhs;
-    }
-    return result;
-  }
-  id<dimensions> operator>=(const size_t &rhs) const {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] >= rhs;
-    }
-    return result;
-  }
-
-  // OP is: +=, -=, *=, /=, %=, <<=, >>=, &=, |=, ^=
-  id<dimensions> &operator+=(const id<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] += rhs[i];
-    }
-    return *this;
-  }
-  id<dimensions> &operator-=(const id<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] -= rhs.common_array[i];
-    }
-    return *this;
-  }
-  id<dimensions> &operator*=(const id<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] *= rhs.common_array[i];
-    }
-    return *this;
-  }
-  id<dimensions> &operator/=(const id<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] /= rhs.common_array[i];
-    }
-    return *this;
-  }
-  id<dimensions> &operator%=(const id<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] %= rhs.common_array[i];
-    }
-    return *this;
-  }
-  id<dimensions> &operator<<=(const id<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] <<= rhs.common_array[i];
-    }
-    return *this;
-  }
-  id<dimensions> &operator>>=(const id<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] >>= rhs.common_array[i];
-    }
-    return *this;
-  }
-  id<dimensions> &operator&=(const id<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] &= rhs.common_array[i];
-    }
-    return *this;
-  }
-  id<dimensions> &operator|=(const id<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] |= rhs.common_array[i];
-    }
-    return *this;
-  }
-  id<dimensions> &operator^=(const id<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] ^= rhs.common_array[i];
-    }
-    return *this;
-  }
+  #define __SYCL_GEN_OPT(op)                                                   \
+    id<dimensions> operator op(const id<dimensions> &rhs) const {              \
+      id<dimensions> result;                                                   \
+      for (int i = 0; i < dimensions; ++i) {                                   \
+        result.common_array[i] = this->common_array[i] op rhs.common_array[i]; \
+      }                                                                        \
+      return result;                                                           \
+    }                                                                          \
+    id<dimensions> operator op(const size_t &rhs) const {                      \
+      id<dimensions> result;                                                   \
+      for (int i = 0; i < dimensions; ++i) {                                   \
+        result.common_array[i] = this->common_array[i] op rhs;                 \
+      }                                                                        \
+      return result;                                                           \
+    }                                                                          \
+    friend id<dimensions> operator op(const size_t &lhs,                       \
+                                      const id<dimensions> &rhs) {             \
+      id<dimensions> result;                                                   \
+      for (int i = 0; i < dimensions; ++i) {                                   \
+        result.common_array[i] = lhs op rhs.common_array[i];                   \
+      }                                                                        \
+      return result;                                                           \
+    }                                                                          \
+
+
+  __SYCL_GEN_OPT(+)
+  __SYCL_GEN_OPT(-)
+  __SYCL_GEN_OPT(*)
+  __SYCL_GEN_OPT(/)
+  __SYCL_GEN_OPT(%)
+  __SYCL_GEN_OPT(<<)
+  __SYCL_GEN_OPT(>>)
+  __SYCL_GEN_OPT(&)
+  __SYCL_GEN_OPT(|)
+  __SYCL_GEN_OPT(^)
+  __SYCL_GEN_OPT(&&)
+  __SYCL_GEN_OPT(||)
+  __SYCL_GEN_OPT(<)
+  __SYCL_GEN_OPT(>)
+  __SYCL_GEN_OPT(<=)
+  __SYCL_GEN_OPT(>=)
+
+  #undef __SYCL_GEN_OPT
 
   // OP is: +=, -=, *=, /=, %=, <<=, >>=, &=, |=, ^=
-  id<dimensions> &operator+=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] += rhs;
-    }
-    return *this;
-  }
-  id<dimensions> &operator-=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] -= rhs;
-    }
-    return *this;
-  }
-  id<dimensions> &operator*=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] *= rhs;
-    }
-    return *this;
-  }
-  id<dimensions> &operator/=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] /= rhs;
-    }
-    return *this;
-  }
-  id<dimensions> &operator%=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] %= rhs;
-    }
-    return *this;
-  }
-  id<dimensions> &operator<<=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] <<= rhs;
-    }
-    return *this;
-  }
-  id<dimensions> &operator>>=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] >>= rhs;
-    }
-    return *this;
-  }
-  id<dimensions> &operator&=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] &= rhs;
-    }
-    return *this;
-  }
-  id<dimensions> &operator|=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] |= rhs;
-    }
-    return *this;
-  }
-  id<dimensions> &operator^=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] ^= rhs;
-    }
-    return *this;
-  }
-
-  // OP is: +, -, *, /, %, <<, >>, &, |, ^, <, >, <=, >=, &&, ||
-  friend id<dimensions> operator+(const size_t &lhs,
-                                  const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs + rhs.common_array[i];
-    }
-    return result;
-  }
-  friend id<dimensions> operator-(const size_t &lhs,
-                                  const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs - rhs.common_array[i];
-    }
-    return result;
-  }
-  friend id<dimensions> operator*(const size_t &lhs,
-                                  const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs * rhs.common_array[i];
-    }
-    return result;
-  }
-  friend id<dimensions> operator/(const size_t &lhs,
-                                  const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs / rhs.common_array[i];
-    }
-    return result;
-  }
-  friend id<dimensions> operator%(const size_t &lhs,
-                                  const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs % rhs.common_array[i];
-    }
-    return result;
-  }
-  friend id<dimensions> operator<<(const size_t &lhs,
-                                   const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs << rhs.common_array[i];
-    }
-    return result;
-  }
-  friend id<dimensions> operator>>(const size_t &lhs,
-                                   const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs >> rhs.common_array[i];
-    }
-    return result;
-  }
-  friend id<dimensions> operator&(const size_t &lhs,
-                                  const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs & rhs.common_array[i];
-    }
-    return result;
-  }
-  friend id<dimensions> operator|(const size_t &lhs,
-                                  const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs | rhs.common_array[i];
-    }
-    return result;
-  }
-  friend id<dimensions> operator^(const size_t &lhs,
-                                  const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs ^ rhs.common_array[i];
-    }
-    return result;
-  }
-  friend id<dimensions> operator<(const size_t &lhs,
-                                  const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs < rhs.common_array[i];
-    }
-    return result;
-  }
-  friend id<dimensions> operator>(const size_t &lhs,
-                                  const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs > rhs.common_array[i];
-    }
-    return result;
-  }
-  friend id<dimensions> operator<=(const size_t &lhs,
-                                   const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs <= rhs.common_array[i];
-    }
-    return result;
-  }
-  friend id<dimensions> operator>=(const size_t &lhs,
-                                   const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs >= rhs.common_array[i];
-    }
-    return result;
-  }
-  friend id<dimensions> operator&&(const size_t &lhs,
-                                   const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs && rhs.common_array[i];
-    }
-    return result;
-  }
-  friend id<dimensions> operator||(const size_t &lhs,
-                                   const id<dimensions> &rhs) {
-    id<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs || rhs.common_array[i];
-    }
-    return result;
-  }
+  #define __SYCL_GEN_OPT(op)                                                   \
+    id<dimensions> &operator op(const id<dimensions> &rhs) {                   \
+      for (int i = 0; i < dimensions; ++i) {                                   \
+        this->common_array[i] op rhs.common_array[i];                          \
+      }                                                                        \
+      return *this;                                                            \
+    }                                                                          \
+    id<dimensions> &operator op(const size_t &rhs) {                           \
+      for (int i = 0; i < dimensions; ++i) {                                   \
+        this->common_array[i] op rhs;                                          \
+      }                                                                        \
+      return *this;                                                            \
+    }                                                                          \
+
+  __SYCL_GEN_OPT(+=)
+  __SYCL_GEN_OPT(-=)
+  __SYCL_GEN_OPT(*=)
+  __SYCL_GEN_OPT(/=)
+  __SYCL_GEN_OPT(%=)
+  __SYCL_GEN_OPT(<<=)
+  __SYCL_GEN_OPT(>>=)
+  __SYCL_GEN_OPT(&=)
+  __SYCL_GEN_OPT(|=)
+  __SYCL_GEN_OPT(^=)
+
+  #undef __SYCL_GEN_OPT
 };
 
 namespace detail {
diff --git a/sycl/include/CL/sycl/range.hpp b/sycl/include/CL/sycl/range.hpp
index 6d7f4919f66e6..80e601196ff08 100644
--- a/sycl/include/CL/sycl/range.hpp
+++ b/sycl/include/CL/sycl/range.hpp
@@ -59,486 +59,78 @@ class range : public detail::array<dimensions> {
   range() = default;
 
   // OP is: +, -, *, /, %, <<, >>, &, |, ^, &&, ||, <, >, <=, >=
-  range<dimensions> operator+(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] + rhs.common_array[i];
-    }
-    return result;
-  }
-  range<dimensions> operator-(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] - rhs.common_array[i];
-    }
-    return result;
-  }
-  range<dimensions> operator*(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] * rhs.common_array[i];
-    }
-    return result;
-  }
-  range<dimensions> operator/(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] / rhs.common_array[i];
-    }
-    return result;
-  }
-  range<dimensions> operator%(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] % rhs.common_array[i];
-    }
-    return result;
-  }
-  range<dimensions> operator<<(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] << rhs.common_array[i];
-    }
-    return result;
-  }
-  range<dimensions> operator>>(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] >> rhs.common_array[i];
-    }
-    return result;
-  }
-  range<dimensions> operator&(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] & rhs.common_array[i];
-    }
-    return result;
-  }
-  range<dimensions> operator|(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] | rhs.common_array[i];
-    }
-    return result;
-  }
-  range<dimensions> operator^(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] ^ rhs.common_array[i];
-    }
-    return result;
-  }
-  range<dimensions> operator&&(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] && rhs.common_array[i];
-    }
-    return result;
-  }
-  range<dimensions> operator||(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] || rhs.common_array[i];
-    }
-    return result;
-  }
-  range<dimensions> operator<(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] < rhs.common_array[i];
-    }
-    return result;
-  }
-  range<dimensions> operator>(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] > rhs.common_array[i];
-    }
-    return result;
-  }
-  range<dimensions> operator<=(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] <= rhs.common_array[i];
-    }
-    return result;
-  }
-  range<dimensions> operator>=(const range<dimensions> &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] >= rhs.common_array[i];
-    }
-    return result;
-  }
+  #define __SYCL_GEN_OPT(op)                                                   \
+    range<dimensions> operator op(const range<dimensions> &rhs) const {        \
+      range<dimensions> result;                                                \
+      for (int i = 0; i < dimensions; ++i) {                                   \
+        result.common_array[i] = this->common_array[i] op rhs.common_array[i]; \
+      }                                                                        \
+      return result;                                                           \
+    }                                                                          \
+    range<dimensions> operator op(const size_t &rhs) const {                   \
+      range<dimensions> result;                                                \
+      for (int i = 0; i < dimensions; ++i) {                                   \
+        result.common_array[i] = this->common_array[i] op rhs;                 \
+      }                                                                        \
+      return result;                                                           \
+    }                                                                          \
+    friend range<dimensions> operator op(const size_t &lhs,                    \
+                                       const range<dimensions> &rhs) {         \
+      range<dimensions> result;                                                \
+      for (int i = 0; i < dimensions; ++i) {                                   \
+        result.common_array[i] = lhs op rhs.common_array[i];                   \
+      }                                                                        \
+      return result;                                                           \
+    }                                                                          \
 
-  // OP is: +, -, *, /, %, <<, >>, &, |, ^, &&, ||, <, >, <=, >=
-  range<dimensions> operator+(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] + rhs;
-    }
-    return result;
-  }
-  range<dimensions> operator-(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] - rhs;
-    }
-    return result;
-  }
-  range<dimensions> operator*(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] * rhs;
-    }
-    return result;
-  }
-  range<dimensions> operator/(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] / rhs;
-    }
-    return result;
-  }
-  range<dimensions> operator%(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] % rhs;
-    }
-    return result;
-  }
-  range<dimensions> operator<<(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] << rhs;
-    }
-    return result;
-  }
-  range<dimensions> operator>>(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] >> rhs;
-    }
-    return result;
-  }
-  range<dimensions> operator&(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] & rhs;
-    }
-    return result;
-  }
-  range<dimensions> operator|(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] | rhs;
-    }
-    return result;
-  }
-  range<dimensions> operator^(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] ^ rhs;
-    }
-    return result;
-  }
-  range<dimensions> operator&&(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] && rhs;
-    }
-    return result;
-  }
-  range<dimensions> operator||(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] || rhs;
-    }
-    return result;
-  }
-  range<dimensions> operator<(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] < rhs;
-    }
-    return result;
-  }
-  range<dimensions> operator>(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] > rhs;
-    }
-    return result;
-  }
-  range<dimensions> operator<=(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] <= rhs;
-    }
-    return result;
-  }
-  range<dimensions> operator>=(const size_t &rhs) const {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = this->common_array[i] >= rhs;
-    }
-    return result;
-  }
+  __SYCL_GEN_OPT(+)
+  __SYCL_GEN_OPT(-)
+  __SYCL_GEN_OPT(*)
+  __SYCL_GEN_OPT(/)
+  __SYCL_GEN_OPT(%)
+  __SYCL_GEN_OPT(<<)
+  __SYCL_GEN_OPT(>>)
+  __SYCL_GEN_OPT(&)
+  __SYCL_GEN_OPT(|)
+  __SYCL_GEN_OPT(^)
+  __SYCL_GEN_OPT(&&)
+  __SYCL_GEN_OPT(||)
+  __SYCL_GEN_OPT(<)
+  __SYCL_GEN_OPT(>)
+  __SYCL_GEN_OPT(<=)
+  __SYCL_GEN_OPT(>=)
 
-  // OP is: +=, -=, *=, /=, %=, <<=, >>=, &=, |=, ^=
-  range<dimensions> &operator+=(const range<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] += rhs[i];
-    }
-    return *this;
-  }
-  range<dimensions> &operator-=(const range<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] -= rhs.common_array[i];
-    }
-    return *this;
-  }
-  range<dimensions> &operator*=(const range<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] *= rhs.common_array[i];
-    }
-    return *this;
-  }
-  range<dimensions> &operator/=(const range<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] /= rhs.common_array[i];
-    }
-    return *this;
-  }
-  range<dimensions> &operator%=(const range<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] %= rhs.common_array[i];
-    }
-    return *this;
-  }
-  range<dimensions> &operator<<=(const range<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] <<= rhs.common_array[i];
-    }
-    return *this;
-  }
-  range<dimensions> &operator>>=(const range<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] >>= rhs.common_array[i];
-    }
-    return *this;
-  }
-  range<dimensions> &operator&=(const range<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] &= rhs.common_array[i];
-    }
-    return *this;
-  }
-  range<dimensions> &operator|=(const range<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] |= rhs.common_array[i];
-    }
-    return *this;
-  }
-  range<dimensions> &operator^=(const range<dimensions> &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] ^= rhs.common_array[i];
-    }
-    return *this;
-  }
+  #undef __SYCL_GEN_OPT
 
   // OP is: +=, -=, *=, /=, %=, <<=, >>=, &=, |=, ^=
-  range<dimensions> &operator+=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] += rhs;
-    }
-    return *this;
-  }
-  range<dimensions> &operator-=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] -= rhs;
-    }
-    return *this;
-  }
-  range<dimensions> &operator*=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] *= rhs;
-    }
-    return *this;
-  }
-  range<dimensions> &operator/=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] /= rhs;
-    }
-    return *this;
-  }
-  range<dimensions> &operator%=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] %= rhs;
-    }
-    return *this;
-  }
-  range<dimensions> &operator<<=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] <<= rhs;
-    }
-    return *this;
-  }
-  range<dimensions> &operator>>=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] >>= rhs;
-    }
-    return *this;
-  }
-  range<dimensions> &operator&=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] &= rhs;
-    }
-    return *this;
-  }
-  range<dimensions> &operator|=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] |= rhs;
-    }
-    return *this;
-  }
-  range<dimensions> &operator^=(const size_t &rhs) {
-    for (int i = 0; i < dimensions; ++i) {
-      this->common_array[i] ^= rhs;
-    }
-    return *this;
-  }
+  #define __SYCL_GEN_OPT(op)                                                   \
+    range<dimensions> &operator op(const range<dimensions> &rhs) {             \
+      for (int i = 0; i < dimensions; ++i) {                                   \
+        this->common_array[i] op rhs[i];                                       \
+      }                                                                        \
+      return *this;                                                            \
+    }                                                                          \
+    range<dimensions> &operator op(const size_t &rhs) {                        \
+      for (int i = 0; i < dimensions; ++i) {                                   \
+        this->common_array[i] op rhs;                                          \
+      }                                                                        \
+      return *this;                                                            \
+    }                                                                          \
+
+
+  __SYCL_GEN_OPT(+=)
+  __SYCL_GEN_OPT(-=)
+  __SYCL_GEN_OPT(*=)
+  __SYCL_GEN_OPT(/=)
+  __SYCL_GEN_OPT(%=)
+  __SYCL_GEN_OPT(<<=)
+  __SYCL_GEN_OPT(>>=)
+  __SYCL_GEN_OPT(&=)
+  __SYCL_GEN_OPT(|=)
+  __SYCL_GEN_OPT(^=)
+
+  #undef __SYCL_GEN_OPT
 
-  // OP is: +, -, *, /, %, <<, >>, &, |, ^, <, >, <=, >=, &&, ||
-  friend range<dimensions> operator+(const size_t &lhs,
-                                     const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs + rhs.common_array[i];
-    }
-    return result;
-  }
-  friend range<dimensions> operator-(const size_t &lhs,
-                                     const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs - rhs.common_array[i];
-    }
-    return result;
-  }
-  friend range<dimensions> operator*(const size_t &lhs,
-                                     const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs * rhs.common_array[i];
-    }
-    return result;
-  }
-  friend range<dimensions> operator/(const size_t &lhs,
-                                     const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs / rhs.common_array[i];
-    }
-    return result;
-  }
-  friend range<dimensions> operator%(const size_t &lhs,
-                                     const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs % rhs.common_array[i];
-    }
-    return result;
-  }
-  friend range<dimensions> operator<<(const size_t &lhs,
-                                      const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs << rhs.common_array[i];
-    }
-    return result;
-  }
-  friend range<dimensions> operator>>(const size_t &lhs,
-                                      const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs >> rhs.common_array[i];
-    }
-    return result;
-  }
-  friend range<dimensions> operator&(const size_t &lhs,
-                                     const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs & rhs.common_array[i];
-    }
-    return result;
-  }
-  friend range<dimensions> operator|(const size_t &lhs,
-                                     const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs | rhs.common_array[i];
-    }
-    return result;
-  }
-  friend range<dimensions> operator^(const size_t &lhs,
-                                     const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs ^ rhs.common_array[i];
-    }
-    return result;
-  }
-  friend range<dimensions> operator<(const size_t &lhs,
-                                     const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs < rhs.common_array[i];
-    }
-    return result;
-  }
-  friend range<dimensions> operator>(const size_t &lhs,
-                                     const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs > rhs.common_array[i];
-    }
-    return result;
-  }
-  friend range<dimensions> operator<=(const size_t &lhs,
-                                      const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs <= rhs.common_array[i];
-    }
-    return result;
-  }
-  friend range<dimensions> operator>=(const size_t &lhs,
-                                      const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs >= rhs.common_array[i];
-    }
-    return result;
-  }
-  friend range<dimensions> operator&&(const size_t &lhs,
-                                      const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs && rhs.common_array[i];
-    }
-    return result;
-  }
-  friend range<dimensions> operator||(const size_t &lhs,
-                                      const range<dimensions> &rhs) {
-    range<dimensions> result;
-    for (int i = 0; i < dimensions; ++i) {
-      result.common_array[i] = lhs || rhs.common_array[i];
-    }
-    return result;
-  }
 };
 } // namespace sycl
 } // namespace cl