[libcxx] implement <experimental/simd> operators and reduction.

[timshen]

Summary

This patch completes the implementation of simd<> and related operations.

[timshen]

Rebased.

[timshen]

Rebase.

[mclow.lists]

A few nits, a bit of things moving underneath you, but this looks good.
Need to add more stuff to the tests ;-)

libcxx/include/experimental/simd

1421

In the TS, hmin, hmax (and a bunch of others) are noexcept. This was added in P1110, in response to NB comments CH 30 and CH 33.

Need to fix that here, and add ASSERT_NOEXCEPT to a bunch of tests.

1482

We're going to need a lot of _LIBCPP_TYPE_VIS and other annotations. That can be a separate patch, though

1657

I don't think that auto buys you anything here. simd is fine, and no longer.

libcxx/test/std/experimental/simd/simd.horizontal/hmax.pass.cpp

23

Check the return types here with ASSERT_SAME_TYPE

libcxx/include/experimental/simd

 template <class _Tp>
 where_expression<bool, _Tp> where(bool, _Tp&) noexcept;
 
 template <class _Tp>
 const_where_expression<bool, const _Tp> where(bool, const _Tp&) noexcept;
 
 // reductions [simd.reductions]
 template <class _Tp, class _Abi, class _BinaryOp = std::plus<_Tp>>
-_Tp reduce(const simd<_Tp, _Abi>&, _BinaryOp = _BinaryOp());
+_Tp reduce(const simd<_Tp, _Abi>& __v, _BinaryOp __op = _BinaryOp()) {
+  _Tp __acc = __v[0];
+  for (size_t __i = 1; __i < __v.size(); __i++) {
+    __acc = __op(__acc, __v[__i]);
+  }
+  return __acc;
+}
 
 template <class _MaskType, class _SimdType, class _BinaryOp>
 typename _SimdType::value_type
 reduce(const const_where_expression<_MaskType, _SimdType>&,
        typename _SimdType::value_type neutral_element, _BinaryOp binary_op);
 
 template <class _MaskType, class _SimdType>
 typename _SimdType::value_type
reduce(const const_where_expression<_MaskType, _SimdType>&,
        bit_or<typename _SimdType::value_type> binary_op);
 
 template <class _MaskType, class _SimdType>
 typename _SimdType::value_type
 reduce(const const_where_expression<_MaskType, _SimdType>&,
        bit_xor<typename _SimdType::value_type> binary_op);
 
 template <class _Tp, class _Abi>
-_Tp hmin(const simd<_Tp, _Abi>&);
+_Tp hmin(const simd<_Tp, _Abi>& __v) {
+  _Tp __acc = __v[0];
+  for (size_t __i = 1; __i < __v.size(); __i++) {
+    __acc = __acc > __v[__i] ? __v[__i] : __acc;
+  }
+  return __acc;
+}
+
 template <class _MaskType, class _SimdType>
 typename _SimdType::value_type
 hmin(const const_where_expression<_MaskType, _SimdType>&);
+
 template <class _Tp, class _Abi>
-_Tp hmax(const simd<_Tp, _Abi>&);
+_Tp hmax(const simd<_Tp, _Abi>& __v) {
+  _Tp __acc = __v[0];
+  for (size_t __i = 1; __i < __v.size(); __i++) {
+    __acc = __acc < __v[__i] ? __v[__i] : __acc;
+  }
+  return __acc;
+}
+
 template <class _MaskType, class _SimdType>
 typename _SimdType::value_type
 hmax(const const_where_expression<_MaskType, _SimdType>&);
 
 // algorithms [simd.alg]
 template <class _Tp, class _Abi>
-simd<_Tp, _Abi> min(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept;
+simd<_Tp, _Abi> min(const simd<_Tp, _Abi>& __a,
+                    const simd<_Tp, _Abi>& __b) noexcept {
+  simd<_Tp, _Abi> __v;
+  for (size_t __i = 0; __i < __v.size(); __i++) {
+    __v[__i] = std::min(__a[__i], __b[__i]);
+  }
+  return __v;
+}
 
 template <class _Tp, class _Abi>
-simd<_Tp, _Abi> max(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept;
+simd<_Tp, _Abi> max(const simd<_Tp, _Abi>& __a,
+                    const simd<_Tp, _Abi>& __b) noexcept {
+  simd<_Tp, _Abi> __v;
+  for (size_t __i = 0; __i < __v.size(); __i++) {
+    __v[__i] = std::max(__a[__i], __b[__i]);
+  }
+  return __v;
+}
 
 template <class _Tp, class _Abi>
 std::pair<simd<_Tp, _Abi>, simd<_Tp, _Abi>>
-minmax(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept;
+minmax(const simd<_Tp, _Abi>& __a, const simd<_Tp, _Abi>& __b) noexcept {
+  return std::make_pair(min(__a, __b), max(__a, __b));
+}
 
 template <class _Tp, class _Abi>
-simd<_Tp, _Abi> clamp(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&,
-                      const simd<_Tp, _Abi>&);
+simd<_Tp, _Abi> clamp(const simd<_Tp, _Abi>& __v, const simd<_Tp, _Abi>& __lo,
+                      const simd<_Tp, _Abi>& __hi) {
+  return min(max(__v, __lo), __hi);
+}
 
 // [simd.whereexpr]
 // TODO implement where expressions.
 template <class _MaskType, class _Tp>
 class const_where_expression {
 public:
   const_where_expression(const const_where_expression&) = delete;
   const_where_expression& operator=(const const_where_expression&) = delete;
   typename remove_const<_Tp>::type operator-() const&&;
   template <class _Up, class _Flags>
   void copy_to(_Up*, _Flags) const&&;
 };
 
public:
   void operator++(int);
   void operator--();
   void operator--(int);
   template <class _Up, class _Flags>
   void copy_from(const _Up*, _Flags);
 };
 
 // [simd.class]
-// TODO: implement simd
 template <class _Tp, class _Abi>
 class simd {
 public:
   using value_type = _Tp;
   using reference = __simd_reference<_Tp, _Tp, _Abi>;
   using mask_type = simd_mask<_Tp, _Abi>;
   using abi_type = _Abi;
 
public:
   }
 
   // scalar access [simd.subscr]
   reference operator[](size_t __i) { return reference(&__s_, __i); }
 
   value_type operator[](size_t __i) const { return __s_.__get(__i); }
 
   // unary operators [simd.unary]
-  simd& operator++();
-  simd operator++(int);
-  simd& operator--();
-  simd operator--(int);
+  simd& operator++() {
+    *this += simd(1);
+    return *this;
+  }
+
+  simd operator++(int) {
+    auto __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  simd& operator--() {
+    *this -= simd(1);
+    return *this;
+  }
+
+  simd operator--(int) {
+    auto __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
   mask_type operator!() const;
-  simd operator~() const;
-  simd operator+() const;
-  simd operator-() const;
+
+  simd operator~() const {
+    simd __v;
+    for (size_t __i = 0; __i < size(); __i++) {
+      __v[__i] = ~(*this)[__i];
+    }
+    return __v;
+  }
+
+  simd operator+() const { return *this; }
+
+  simd operator-() const { return simd(0) - *this; }
 
   // binary operators [simd.binary]
-  friend simd operator+(const simd&, const simd&);
-  friend simd operator-(const simd&, const simd&);
-  friend simd operator*(const simd&, const simd&);
-  friend simd operator/(const simd&, const simd&);
-  friend simd operator%(const simd&, const simd&);
-  friend simd operator&(const simd&, const simd&);
-  friend simd operator|(const simd&, const simd&);
-  friend simd operator^(const simd&, const simd&);
-  friend simd operator<<(const simd&, const simd&);
-  friend simd operator>>(const simd&, const simd&);
-  friend simd operator<<(const simd&, int);
-  friend simd operator>>(const simd&, int);
+  // TODO: regarding NOTE 9, the implementationn chooses not to SFINAE,
+  // but causes a hard error when the operator can't work on _Tp.
+  friend simd operator+(const simd& __a, const simd& __b) {
+    simd __v;
+    for (size_t __i = 0; __i < __v.size(); __i++) {
+      __v[__i] = __a[__i] + __b[__i];
+    }
+    return __v;
+  }
 
-  // compound assignment [simd.cassign]
-  friend simd& operator+=(simd&, const simd&);
-  friend simd& operator-=(simd&, const simd&);
-  friend simd& operator*=(simd&, const simd&);
-  friend simd& operator/=(simd&, const simd&);
-  friend simd& operator%=(simd&, const simd&);
+  friend simd operator-(const simd& __a, const simd& __b) {
+    simd __v;
+    for (size_t __i = 0; __i < __v.size(); __i++) {
+      __v[__i] = __a[__i] - __b[__i];
+    }
+    return __v;
+  }
 
-  friend simd& operator&=(simd&, const simd&);
-  friend simd& operator|=(simd&, const simd&);
-  friend simd& operator^=(simd&, const simd&);
-  friend simd& operator<<=(simd&, const simd&);
-  friend simd& operator>>=(simd&, const simd&);
-  friend simd& operator<<=(simd&, int);
-  friend simd& operator>>=(simd&, int);
+  friend simd operator*(const simd& __a, const simd& __b) {
+    simd __v;
+    for (size_t __i = 0; __i < __v.size(); __i++) {
+      __v[__i] = __a[__i] * __b[__i];
+    }
+    return __v;
+  }
+
+  friend simd operator/(const simd& __a, const simd& __b) {
+    simd __v;
+    for (size_t __i = 0; __i < __v.size(); __i++) {
+      __v[__i] = __a[__i] / __b[__i];
+    }
+    return __v;
+  }
+
+  friend simd operator%(const simd& __a, const simd& __b) {
+    simd __v;
+    for (size_t __i = 0; __i < __v.size(); __i++) {
+      __v[__i] = __a[__i] % __b[__i];
+    }
+    return __v;
+  }
+
+  friend simd operator&(const simd& __a, const simd& __b) {
+    simd __v;
+    for (size_t __i = 0; __i < __v.size(); __i++) {
+      __v[__i] = __a[__i] & __b[__i];
+    }
+    return __v;
+  }
+
+  friend simd operator|(const simd& __a, const simd& __b) {
+    simd __v;
+    for (size_t __i = 0; __i < __v.size(); __i++) {
+      __v[__i] = __a[__i] | __b[__i];
+    }
+    return __v;
+  }
+
+  friend simd operator^(const simd& __a, const simd& __b) {
+    simd __v;
+    for (size_t __i = 0; __i < __v.size(); __i++) {
+      __v[__i] = __a[__i] ^ __b[__i];
+    }
+    return __v;
+  }
+
+  friend simd operator<<(const simd& __a, const simd& __b) {
+    simd __v;
+    for (size_t __i = 0; __i < __v.size(); __i++) {
+      __v[__i] = __a[__i] << __b[__i];
+    }
+    return __v;
+  }
+
+  friend simd operator>>(const simd& __a, const simd& __b) {
+    simd __v;
+    for (size_t __i = 0; __i < __v.size(); __i++) {
+      __v[__i] = __a[__i] >> __b[__i];
+    }
+    return __v;
+  }
+
+  friend simd operator<<(const simd& __a, int __offset) {
+    return __a << simd(__offset);
+  }
+
+  friend simd operator>>(const simd& __a, int __offset) {
+    return __a >> simd(__offset);
+  }
+
+  friend simd& operator+=(simd& __a, const simd& __b) {
+    return __a = __a + __b;
+  }
+
+  friend simd& operator-=(simd& __a, const simd& __b) {
+    return __a = __a - __b;
+  }
+
+  friend simd& operator*=(simd& __a, const simd& __b) {
+    return __a = __a * __b;
+  }
+
+  friend simd& operator/=(simd& __a, const simd& __b) {
+    return __a = __a / __b;
+  }
+
+  friend simd& operator%=(simd& __a, const simd& __b) {
+    return __a = __a % __b;
+  }
+
+  friend simd& operator&=(simd& __a, const simd& __b) {
+    return __a = __a & __b;
+  }
+
+  friend simd& operator|=(simd& __a, const simd& __b) {
+    return __a = __a | __b;
+  }
+
+  friend simd& operator^=(simd& __a, const simd& __b) {
+    return __a = __a ^ __b;
+  }
+
+  friend simd& operator<<=(simd& __a, const simd& __b) {
+    return __a = __a << __b;
+  }
+
+  friend simd& operator>>=(simd& __a, const simd& __b) {
+    return __a = __a >> __b;
+  }
+
+  friend simd& operator<<=(simd& __a, int __offset) {
+    return __a = __a << __offset;
+  }
+
+  friend simd& operator>>=(simd& __a, int __offset) {
+    return __a = __a >> __offset;
+  }
 
   // compares [simd.comparison]
   friend mask_type operator==(const simd&, const simd&);
   friend mask_type operator!=(const simd&, const simd&);
   friend mask_type operator>=(const simd&, const simd&);
   friend mask_type operator<=(const simd&, const simd&);
   friend mask_type operator>(const simd&, const simd&);
   friend mask_type operator<(const simd&, const simd&);

libcxx/test/std/experimental/simd/simd.horizontal/hmax.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// template <class T, class Abi> T hmax(const simd<T, Abi>&);
+// template <class M, class V> T hmax(const const_where_expression<M, V>&);
+
+#include <experimental/simd>
+#include <cassert>
+#include <cstdint>
+
+using namespace std::experimental::parallelism_v2;
+
+void test_hmax() {
+  {
+    int a[] = {2, 5, -4, 6};
+    assert(hmax(fixed_size_simd<int, 4>(a, element_aligned_tag())) == 6);
+  }
+  {
+    int a[] = {6, 2, 5, -4};
+    assert(hmax(fixed_size_simd<int, 4>(a, element_aligned_tag())) == 6);
+  }
+  {
+    int a[] = {-4, 6, 2, 5};
+    assert(hmax(fixed_size_simd<int, 4>(a, element_aligned_tag())) == 6);
+  }
+  {
+    int a[] = {5, -4, 6, 2};
+    assert(hmax(fixed_size_simd<int, 4>(a, element_aligned_tag())) == 6);
+  }
+}
+
+int main() { test_hmax(); }

libcxx/test/std/experimental/simd/simd.horizontal/hmin.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// template <class T, class Abi> T hmin(const simd<T, Abi>&);
+// template <class M, class V> T hmin(const const_where_expression<M, V>&);
+
+#include <experimental/simd>
+#include <cassert>
+#include <cstdint>
+
+using namespace std::experimental::parallelism_v2;
+
+void test_hmin() {
+  {
+    int a[] = {2, 5, -4, 6};
+    assert(hmin(fixed_size_simd<int, 4>(a, element_aligned_tag())) == -4);
+  }
+  {
+    int a[] = {6, 2, 5, -4};
+    assert(hmin(fixed_size_simd<int, 4>(a, element_aligned_tag())) == -4);
+  }
+  {
+    int a[] = {-4, 6, 2, 5};
+    assert(hmin(fixed_size_simd<int, 4>(a, element_aligned_tag())) == -4);
+  }
+  {
+    int a[] = {5, -4, 6, 2};
+    assert(hmin(fixed_size_simd<int, 4>(a, element_aligned_tag())) == -4);
+  }
+}
+
+int main() { test_hmin(); }

libcxx/test/std/experimental/simd/simd.horizontal/reduce.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// // reductions [simd.reductions]
+// template <class T, class Abi, class BinaryOperation = std::plus<>>
+// T reduce(const simd<T, Abi>&, BinaryOperation = BinaryOperation());
+//
+// template <class M, class V, class BinaryOperation>
+// typename V::value_type reduce(const const_where_expression<M, V>& x,
+// typename V::value_type neutral_element, BinaryOperation binary_op);
+//
+// template <class M, class V>
+// typename V::value_type reduce(const const_where_expression<M, V>& x, plus<> binary_op = plus<>());
+//
+// template <class M, class V>
+// typename V::value_type reduce(const const_where_expression<M, V>& x, multiplies<> binary_op);
+//
+// template <class M, class V>
+// typename V::value_type reduce(const const_where_expression<M, V>& x, bit_and<> binary_op);
+//
+// template <class M, class V>
+// typename V::value_type reduce(const const_where_expression<M, V>& x, bit_or<> binary_op);
+//
+// template <class M, class V>
+// typename V::value_type reduce(const const_where_expression<M, V>& x, bit_xor<> binary_op);
+
+#include <cassert>
+#include <cstdint>
+#include <experimental/simd>
+
+using namespace std::experimental::parallelism_v2;
+
+inline int factorial(int n) { return n == 1 ? 1 : n * factorial(n - 1); }
+
+void test_reduce() {
+  int n = (int)native_simd<int>::size();
+  assert(reduce(native_simd<int>([](int i) { return i; })) == n * (n - 1) / 2);
+  assert(reduce(native_simd<int>([](int i) { return i; }), std::plus<int>()) ==
+         n * (n - 1) / 2);
+  assert(reduce(native_simd<int>([](int i) { return i + 1; }),
+                std::multiplies<int>()) == factorial(n));
+}
+
+int main() { test_reduce(); }

libcxx/test/std/experimental/simd/simd.elementwise/clamp.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// template <class T, class Abi>
+// simd<T, Abi>
+// clamp(const simd<T, Abi>& v, const simd<T, Abi>& lo, const simd<T, Abi>& hi);
+
+#include <cassert>
+#include <cstdint>
+#include <algorithm>
+#include <experimental/simd>
+
+using namespace std::experimental::parallelism_v2;
+
+template <typename T, typename Abi>
+bool equal(simd<T, Abi> a, simd<T, Abi> b) {
+  for (size_t i = 0; i < a.size(); i++) {
+    if (a[i] != b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void test_clamp() {
+  auto actual = clamp(fixed_size_simd<int, 16>([](int i) { return i - 8; }),
+                      fixed_size_simd<int, 16>([](int) { return 0; }),
+                      fixed_size_simd<int, 16>([](int) { return 5; }));
+
+  int expected[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 5, 5};
+
+  assert(
+      equal(fixed_size_simd<int, 16>(expected, element_aligned_tag()), actual));
+}
+
+int main() { test_clamp(); }

libcxx/test/std/experimental/simd/simd.elementwise/max.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// template <class T, class Abi>
+// simd<T, Abi>
+// max(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;
+
+#include <cassert>
+#include <cstdint>
+#include <algorithm>
+#include <experimental/simd>
+
+using namespace std::experimental::parallelism_v2;
+
+template <typename T, typename Abi>
+bool equal(simd<T, Abi> a, simd<T, Abi> b) {
+  for (size_t i = 0; i < a.size(); i++) {
+    if (a[i] != b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void test_max() {
+  int n = (int)native_simd<int>::size();
+  assert(
+      equal(max(native_simd<int>([](int i) { return i; }),
+                native_simd<int>([n](int i) { return n - 1 - i; })),
+            native_simd<int>([n](int i) { return std::max(i, n - 1 - i); })));
+}
+
+int main() { test_max(); }

libcxx/test/std/experimental/simd/simd.elementwise/min.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// template <class T, class Abi>
+// simd<T, Abi>
+// min(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;
+
+#include <cassert>
+#include <cstdint>
+#include <algorithm>
+#include <experimental/simd>
+
+using namespace std::experimental::parallelism_v2;
+
+template <typename T, typename Abi>
+bool equal(simd<T, Abi> a, simd<T, Abi> b) {
+  for (size_t i = 0; i < a.size(); i++) {
+    if (a[i] != b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void test_min() {
+  int n = (int)native_simd<int>::size();
+  assert(
+      equal(min(native_simd<int>([](int i) { return i; }),
+                native_simd<int>([n](int i) { return n - 1 - i; })),
+            native_simd<int>([n](int i) { return std::min(i, n - 1 - i); })));
+}
+
+int main() { test_min(); }

libcxx/test/std/experimental/simd/simd.elementwise/minmax.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// template <class T, class Abi>
+// std::pair<simd<T, Abi>, simd<T, Abi>>
+// minmax(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;
+
+#include <cassert>
+#include <cstdint>
+#include <algorithm>
+#include <experimental/simd>
+
+using namespace std::experimental::parallelism_v2;
+
+template <typename T, typename Abi>
+bool equal(simd<T, Abi> a, simd<T, Abi> b) {
+  for (size_t i = 0; i < a.size(); i++) {
+    if (a[i] != b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void test_minmax() {
+  int n = (int)native_simd<int>::size();
+  native_simd<int> mi, mx;
+  std::tie(mi, mx) = minmax(native_simd<int>([](int i) { return i; }),
+                            native_simd<int>([n](int i) { return n - 1 - i; })),
+               assert(equal(mi, native_simd<int>([n](int i) {
+                              return std::min(i, n - 1 - i);
+                            })));
+  assert(equal(
+      mx, native_simd<int>([n](int i) { return std::max(i, n - 1 - i); })));
+}
+
+int main() { test_minmax(); }

libcxx/test/std/experimental/simd/simd.elementwise/operators.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03
+
+// <experimental/simd>
+//
+// // unary operators [simd.unary]
+// simd& operator++();
+// simd operator++(int);
+// simd& operator--();
+// simd operator--(int);
+// mask_type operator!() const;
+// simd operator~() const; // see below
+// simd operator+() const;
+// simd operator-() const;
+//
+// // binary operators [simd.binary]
+// friend simd operator+ (const simd&, const simd&);
+// friend simd operator- (const simd&, const simd&);
+// friend simd operator* (const simd&, const simd&);
+// friend simd operator/ (const simd&, const simd&);
+// friend simd operator% (const simd&, const simd&);
+// friend simd operator& (const simd&, const simd&);
+// friend simd operator| (const simd&, const simd&);
+// friend simd operator^ (const simd&, const simd&);
+// friend simd operator<<(const simd&, const simd&);
+// friend simd operator>>(const simd&, const simd&);
+// friend simd operator<<(const simd&, int);
+// friend simd operator>>(const simd&, int);
+//
+// // compound assignment [simd.cassign]
+// friend simd& operator+= (simd&, const simd&);
+// friend simd& operator-= (simd&, const simd&);
+// friend simd& operator*= (simd&, const simd&);
+// friend simd& operator/= (simd&, const simd&);
+// friend simd& operator%= (simd&, const simd&);
+//
+// friend simd& operator&= (simd&, const simd&);
+// friend simd& operator|= (simd&, const simd&);
+// friend simd& operator^= (simd&, const simd&);
+// friend simd& operator<<=(simd&, const simd&);
+// friend simd& operator>>=(simd&, const simd&);
+// friend simd& operator<<=(simd&, int);
+// friend simd& operator>>=(simd&, int);
+
+#include <cassert>
+#include <cstdint>
+#include <experimental/simd>
+
+using namespace std::experimental::parallelism_v2;
+
+template <typename T, typename Abi>
+bool equal(simd<T, Abi> a, simd<T, Abi> b) {
+  for (size_t i = 0; i < a.size(); i++) {
+    if (a[i] != b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void test_pure_operators() {
+  {
+    native_simd<int> a(42), b(4);
+
+    assert(equal(~a, native_simd<int>(~42)));
+    assert(equal(+a, a));
+    assert(equal(-a, native_simd<int>(-42)));
+    assert(equal(a + b, native_simd<int>(42 + 4)));
+    assert(equal(a - b, native_simd<int>(42 - 4)));
+    assert(equal(a * b, native_simd<int>(42 * 4)));
+    assert(equal(a / b, native_simd<int>(42 / 4)));
+    assert(equal(a % b, native_simd<int>(42 % 4)));
+    assert(equal(a & b, native_simd<int>(42 & 4)));
+    assert(equal(a | b, native_simd<int>(42 | 4)));
+    assert(equal(a ^ b, native_simd<int>(42 ^ 4)));
+    assert(equal(a << b, native_simd<int>(42 << 4)));
+    assert(equal(a >> b, native_simd<int>(42 >> 4)));
+    assert(equal(a << 4, native_simd<int>(42 << 4)));
+    assert(equal(a >> 4, native_simd<int>(42 >> 4)));
+  }
+  {
+    native_simd<int> a([](int i) { return 2 * i + 1; }),
+        b([](int i) { return i + 1; });
+
+    assert(equal(~a, native_simd<int>([](int i) { return ~(2 * i + 1); })));
+    assert(equal(+a, a));
+    assert(equal(-a, native_simd<int>([](int i) { return -(2 * i + 1); })));
+    assert(equal(a + b, native_simd<int>([](int i) { return 3 * i + 2; })));
+    assert(equal(a - b, native_simd<int>([](int i) { return i; })));
+    assert(equal(
+        a * b, native_simd<int>([](int i) { return (2 * i + 1) * (i + 1); })));
+    assert(equal(
+        a / b, native_simd<int>([](int i) { return (2 * i + 1) / (i + 1); })));
+    assert(equal(
+        a % b, native_simd<int>([](int i) { return (2 * i + 1) % (i + 1); })));
+    assert(equal(
+        a & b, native_simd<int>([](int i) { return (2 * i + 1) & (i + 1); })));
+    assert(equal(
+        a | b, native_simd<int>([](int i) { return (2 * i + 1) | (i + 1); })));
+    assert(equal(
+        a ^ b, native_simd<int>([](int i) { return (2 * i + 1) ^ (i + 1); })));
+  }
+}
+
+void test_mutating_opreators() {
+  native_simd<int> b(4);
+  {
+    native_simd<int> a(42);
+    assert(equal(++a, native_simd<int>(43)));
+    assert(equal(a, native_simd<int>(43)));
+  }
+  {
+    native_simd<int> a(42);
+    assert(equal(a++, native_simd<int>(42)));
+    assert(equal(a, native_simd<int>(43)));
+  }
+  {
+    native_simd<int> a(42);
+    assert(equal(--a, native_simd<int>(41)));
+    assert(equal(a, native_simd<int>(41)));
+  }
+  {
+    native_simd<int> a(42);
+    assert(equal(a--, native_simd<int>(42)));
+    assert(equal(a, native_simd<int>(41)));
+  }
+  {
+    native_simd<int> a(42);
+    assert(equal(a += b, native_simd<int>(42 + 4)));
+    assert(equal(a, native_simd<int>(42 + 4)));
+  }
+  {
+    native_simd<int> a(42);
+    assert(equal(a -= b, native_simd<int>(42 - 4)));
+    assert(equal(a, native_simd<int>(42 - 4)));
+  }
+  {
+    native_simd<int> a(42);
+    assert(equal(a *= b, native_simd<int>(42 * 4)));
+    assert(equal(a, native_simd<int>(42 * 4)));
+  }
+  {
+    native_simd<int> a(42);
+    assert(equal(a /= b, native_simd<int>(42 / 4)));
+    assert(equal(a, native_simd<int>(42 / 4)));
+  }
+  {
+    native_simd<int> a(42);
+    assert(equal(a %= b, native_simd<int>(42 % 4)));
+    assert(equal(a, native_simd<int>(42 % 4)));
+  }
+  {
+    native_simd<int> a(42);
+    assert(equal(a &= b, native_simd<int>(42 & 4)));
+    assert(equal(a, native_simd<int>(42 & 4)));
+  }
+  {
+    native_simd<int> a(42);
+    assert(equal(a |= b, native_simd<int>(42 | 4)));
+    assert(equal(a, native_simd<int>(42 | 4)));
+  }
+  {
+    native_simd<int> a(42);
+    assert(equal(a ^= b, native_simd<int>(42 ^ 4)));
+    assert(equal(a, native_simd<int>(42 ^ 4)));
+  }
+  {
+    native_simd<int> a(42);
+    assert(equal(a <<= b, native_simd<int>(42 << 4)));
+    assert(equal(a, native_simd<int>(42 << 4)));
+  }
+  {
+    native_simd<int> a(42);
+    assert(equal(a >>= b, native_simd<int>(42 >> 4)));
+    assert(equal(a, native_simd<int>(42 >> 4)));
+  }
+  {
+    native_simd<int> a(42);
+    assert(equal(a <<= 4, native_simd<int>(42 << 4)));
+    assert(equal(a, native_simd<int>(42 << 4)));
+  }
+  {
+    native_simd<int> a(42);
+    assert(equal(a >>= 4, native_simd<int>(42 >> 4)));
+    assert(equal(a, native_simd<int>(42 >> 4)));
+  }
+}
+
+int main() {
+  test_pure_operators();
+  test_mutating_opreators();
+}