Add bitwise-shift batch constant api

Author: AntoinePrv

include/xsimd/types/xsimd_api.hpp

@@ -353,6 +353,41 @@ namespace xsimd
         return kernel::bitwise_cast<A>(x, batch<T_out, A> {}, A {});
     }
 
+    namespace detail
+    {
+        // Detection for kernel overloads accepting ``batch_constant`` in ``bitwise_lshift``
+        // directly (or in a parent register function).
+        // The ``batch_constant`` overload is a rare but useful optimization.
+        // Running the detection here is less error prone than to add a fallback to all
+        // architectures.
+
+        template <class A, class B, class C, class = void>
+        struct has_bitwise_lshift_batch_const : std::false_type
+        {
+        };
+
+        template <class A, class B, class C>
+        struct has_bitwise_lshift_batch_const<A, B, C,
+                                              void_t<decltype(kernel::bitwise_lshift<A>(std::declval<B>(), std::declval<C>(), A {}))>>
+            : std::true_type
+        {
+        };
+
+        template <class A, class T, T... Values>
+        XSIMD_INLINE batch<T, A> bitwise_lshift_batch_const(batch<T, A> const& x, batch_constant<T, A, Values...> shift, std::true_type) noexcept
+        {
+            // Optimized ``batch_constant`` implementation
+            return kernel::bitwise_lshift<A>(x, shift, A {});
+        }
+
+        template <class A, class T, T... Values>
+        XSIMD_INLINE batch<T, A> bitwise_lshift_batch_const(batch<T, A> const& x, batch_constant<T, A, Values...> shift, std::false_type) noexcept
+        {
+            // Fallback to regular run-time implementation
+            return kernel::bitwise_lshift<A>(x, shift.as_batch(), A {});
+        }
+    }
+
     /**
      * @ingroup batch_bitwise
      *
@@ -367,17 +402,24 @@ namespace xsimd
         detail::static_check_supported_config<T, A>();
         return kernel::bitwise_lshift<A>(x, shift, A {});
     }
+    template <size_t shift, class T, class A>
+    XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& x) noexcept
+    {
+        detail::static_check_supported_config<T, A>();
+        return kernel::bitwise_lshift<shift, A>(x, A {});
+    }
     template <class T, class A>
     XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& x, batch<T, A> const& shift) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return kernel::bitwise_lshift<A>(x, shift, A {});
     }
-    template <size_t shift, class T, class A>
-    XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& x) noexcept
+    template <class T, class A, T... Values>
+    XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& x, batch_constant<T, A, Values...> shift) noexcept
     {
         detail::static_check_supported_config<T, A>();
-        return kernel::bitwise_lshift<shift, A>(x, A {});
+        using has_batch_const_impl = detail::has_bitwise_lshift_batch_const<A, decltype(x), decltype(shift)>;
+        return detail::bitwise_lshift_batch_const<A>(x, shift, has_batch_const_impl {});
     }
 
     /**

test/test_xsimd_api.cpp

@@ -351,7 +351,7 @@ struct xsimd_api_integral_types_functions
 {
     using value_type = typename scalar_type<T>::type;
 
-    void test_bitwise_lshift()
+    void test_bitwise_lshift_single()
     {
         constexpr int shift = 3;
         value_type val0(12);
@@ -364,6 +364,33 @@ struct xsimd_api_integral_types_functions
         CHECK_EQ(extract(cr), r);
     }
 
+    template <typename U = T>
+    void test_bitwise_lshift_multiple(typename std::enable_if<!std::is_integral<U>::value, int>::type = 0)
+    {
+#ifndef XSIMD_NO_SUPPORTED_ARCHITECTURE
+        constexpr auto Max = static_cast<value_type>(std::numeric_limits<value_type>::digits);
+        constexpr auto max_batch = xsimd::make_batch_constant<value_type, Max>();
+        constexpr auto shifts = xsimd::make_iota_batch_constant<value_type>() % max_batch;
+
+        auto shifted = xsimd::bitwise_lshift(T(1), shifts.as_batch());
+        for (std::size_t i = 0; i < shifts.size; ++i)
+        {
+            CHECK_EQ(shifted.get(i), 1 << shifts.get(i));
+        }
+
+        auto shifted_cst = xsimd::bitwise_lshift(T(1), shifts);
+        for (std::size_t i = 0; i < shifts.size; ++i)
+        {
+            CHECK_EQ(shifted_cst.get(i), 1 << shifts.get(i));
+        }
+#endif
+    }
+
+    template <typename U = T>
+    void test_bitwise_lshift_multiple(typename std::enable_if<std::is_integral<U>::value, int>::type = 0)
+    {
+    }
+
     void test_bitwise_rshift()
     {
         constexpr int shift = 3;
@@ -426,9 +453,14 @@ TEST_CASE_TEMPLATE("[xsimd api | integral types functions]", B, INTEGRAL_TYPES)
 {
     xsimd_api_integral_types_functions<B> Test;
 
-    SUBCASE("bitwise_lshift")
+    SUBCASE("test_bitwise_lshift_single")
+    {
+        Test.test_bitwise_lshift_single();
+    }
+
+    SUBCASE("bitwise_lshift_multiple")
     {
-        Test.test_bitwise_lshift();
+        Test.test_bitwise_lshift_multiple();
     }
 
     SUBCASE("bitwise_rshift")
@@ -502,17 +534,9 @@ struct xsimd_api_float_types_functions
     }
     void test_atan2()
     {
-        {
-            value_type val0(0);
-            value_type val1(1);
-            CHECK_EQ(extract(xsimd::atan2(T(val0), T(val1))), std::atan2(val0, val1));
-        }
-
-        {
-            value_type val0(1);
-            value_type val1(0);
-            CHECK_EQ(extract(xsimd::atan2(T(val0), T(val1))), std::atan2(val0, val1));
-        }
+        value_type val0(0);
+        value_type val1(1);
+        CHECK_EQ(extract(xsimd::atan2(T(val0), T(val1))), std::atan2(val0, val1));
     }
     void test_atanh()
     {