Implement slides for NEON

Author: amyspark

Diff for: include/xsimd/arch/xsimd_neon.hpp

@@ -2427,6 +2427,72 @@ namespace xsimd
         {
             return !(arg == arg);
         }
+
+        // slide_left
+        namespace detail
+        {
+            template <size_t N>
+            struct slider_left
+            {
+                template <class A, class T>
+                inline batch<T, A> operator()(batch<T, A> const& x, requires_arch<neon>) noexcept
+                {
+                    const auto left = vdupq_n_u8(0);
+                    const auto right = bitwise_cast<batch<uint8_t, A>>(x).data;
+                    const batch<uint8_t, A> res(vextq_u8(left, right, 16 - N));
+                    return bitwise_cast<batch<T, A>>(res);
+                }
+            };
+
+            template <>
+            struct slider_left<0>
+            {
+                template <class A, class T>
+                inline batch<T, A> operator()(batch<T, A> const& x, requires_arch<neon>) noexcept
+                {
+                    return x;
+                }
+            };
+        } // namespace detail
+
+        template <size_t N, class A, class T>
+        inline batch<T, A> slide_left(batch<T, A> const& x, requires_arch<neon>) noexcept
+        {
+            return detail::slider_left<N> {}(x, A {});
+        }
+
+        // slide_right
+        namespace detail
+        {
+            template <size_t N>
+            struct slider_right
+            {
+                template <class A, class T>
+                inline batch<T, A> operator()(batch<T, A> const& x, requires_arch<neon>) noexcept
+                {
+                    const auto left = bitwise_cast<batch<uint8_t, A>>(x).data;
+                    const auto right = vdupq_n_u8(0);
+                    const batch<uint8_t, A> res(vextq_u8(left, right, N));
+                    return bitwise_cast<batch<T, A>>(res);
+                }
+            };
+
+            template <>
+            struct slider_right<16>
+            {
+                template <class A, class T>
+                inline batch<T, A> operator()(batch<T, A> const&, requires_arch<neon>) noexcept
+                {
+                    return batch<T, A> {};
+                }
+            };
+        } // namespace detail
+
+        template <size_t N, class A, class T>
+        inline batch<T, A> slide_right(batch<T, A> const& x, requires_arch<neon>) noexcept
+        {
+            return detail::slider_right<N> {}(x, A {});
+        }
     }
 
     template <class batch_type, typename batch_type::value_type... Values>

Diff for: include/xsimd/types/xsimd_api.hpp

@@ -1664,8 +1664,6 @@ namespace xsimd
         return kernel::sincos<A>(x, A {});
     }
 
-#if XSIMD_WITH_SSE2
-
     /**
      * @ingroup batch_data_transfer
      *
@@ -1700,8 +1698,6 @@ namespace xsimd
         return kernel::slide_right<N, A>(x, A {});
     }
 
-#endif
-
     /**
      * @ingroup batch_math
      *

Diff for: test/test_shuffle.cpp

@@ -166,8 +166,6 @@ namespace
     };
 }
 
-#if XSIMD_WITH_SSE2
-
 template <class B>
 class slide_test : public testing::Test, init_slide_base<typename B::value_type, B::size>
 {
@@ -262,4 +260,3 @@ TYPED_TEST(slide_test, slide_right)
     this->slide_right();
 }
 #endif
-#endif