Improve code quality

Author: AntoinePrv

include/xsimd/arch/utils/shifts.hpp

@@ -16,6 +16,7 @@
 #include "../../config/xsimd_inline.hpp"
 #include "../../types/xsimd_batch.hpp"
 #include "../../types/xsimd_batch_constant.hpp"
+#include "../../types/xsimd_traits.hpp"
 
 namespace xsimd
 {
@@ -45,24 +46,17 @@ namespace xsimd
                 return static_cast<I>((I { 1 } << bit_index) - I { 1 });
             }
 
-            template <class T, class A, T... Vs>
-            constexpr bool all_equals(batch_constant<T, A, Vs...> c)
+            template <class T, class A, T V0, T... Vs>
+            constexpr bool all_equals(batch_constant<T, A, V0, Vs...> c)
             {
-                static_assert(sizeof...(Vs) > 0, "There must be at least one value");
-
-                bool out = true;
-                for (std::size_t k = 0; k < sizeof...(Vs); ++k)
-                {
-                    out &= c.get(k) == c.get(0);
-                }
-                return out;
+                return (c == std::integral_constant<T, V0> {}).all();
             }
 
-            template <class T, class T2, class A, T... Vs>
+            template <class T, class A, T... Vs>
             XSIMD_INLINE batch<T, A> bitwise_lshift_as_twice_larger(
                 batch<T, A> const& self, batch_constant<T, A, Vs...>) noexcept
             {
-                static_assert(sizeof(T2) == 2 * sizeof(T), "One size must be twice the other");
+                using T2 = widen_t<T>;
 
                 const auto self2 = bitwise_cast<T2>(self);
 

include/xsimd/arch/xsimd_avx2.hpp

@@ -333,9 +333,12 @@ namespace xsimd
             }
         }
 
-        // bitwise_lshift with constant bitshifts, for 16-bit elements.
-        // Missing implementations are dispacthed to the `batch` overload in xsimd_api.
-        template <class T, class A, T... Vs, detail::enable_sized_integral_t<T, 2> = 0>
+        // bitwise_lshift multiple (constant) specific implementations.
+        // Missing implementations are dispatched to the `batch` overload in xsimd_api.
+        // The 1 byte constant implementation calls the 2 bytes constant version, the 2 bytes
+        // constant version calls into the 4 bytes version which resolves to the dynamic one above.
+        template <class T, class A, T... Vs,
+                  std::enable_if_t<std::is_integral<T>::value && (sizeof(T) <= 2), int> = 0>
         XSIMD_INLINE batch<T, A> bitwise_lshift(
             batch<T, A> const& self, batch_constant<T, A, Vs...> shifts, requires_arch<avx2> req) noexcept
         {
@@ -348,24 +351,7 @@ namespace xsimd
                 return bitwise_lshift<shifts.get(0), A>(self, req);
             }
             return bitwise_cast<T>(
-                utils::bitwise_lshift_as_twice_larger<uint_t, uint32_t>(
-                    bitwise_cast<uint_t>(self),
-                    batch_constant<uint_t, A, static_cast<uint_t>(Vs)...> {}));
-        }
-
-        // bitwise_lshift with constant bitshifts, for 8-bit elements.
-        template <class T, class A, T... Vs, detail::enable_sized_integral_t<T, 1> = 0>
-        XSIMD_INLINE batch<T, A> bitwise_lshift(
-            batch<T, A> const& self, batch_constant<T, A, Vs...> shifts, requires_arch<avx2> req) noexcept
-        {
-            using uint_t = typename std::make_unsigned<T>::type;
-
-            XSIMD_IF_CONSTEXPR(utils::all_equals(shifts))
-            {
-                return bitwise_lshift<shifts.get(0), A>(self, req);
-            }
-            return bitwise_cast<T>(
-                utils::bitwise_lshift_as_twice_larger<uint_t, uint16_t>(
+                utils::bitwise_lshift_as_twice_larger<uint_t>(
                     bitwise_cast<uint_t>(self),
                     batch_constant<uint_t, A, static_cast<uint_t>(Vs)...> {}));
         }

include/xsimd/arch/xsimd_sse2.hpp

@@ -352,7 +352,7 @@ namespace xsimd
                 return bitwise_lshift<shifts.get(0), A>(self, req);
             }
             return bitwise_cast<T>(
-                utils::bitwise_lshift_as_twice_larger<uint_t, uint16_t>(
+                utils::bitwise_lshift_as_twice_larger<uint_t>(
                     bitwise_cast<uint_t>(self),
                     batch_constant<uint_t, A, static_cast<uint_t>(Vs)...> {}));
         }

include/xsimd/types/xsimd_api.hpp

@@ -361,30 +361,32 @@ namespace xsimd
         // 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>
+        template <class Arch, class Batch, class BatchConstant, 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 {}))>>
+        template <class Arch, class Batch, class BatchConstant>
+        struct has_bitwise_lshift_batch_const<
+            Arch, Batch, BatchConstant,
+            void_t<decltype(kernel::bitwise_lshift<Arch>(
+                std::declval<Batch>(), std::declval<BatchConstant>(), Arch {}))>>
             : 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
+        template <class Arch, class T, T... Values>
+        XSIMD_INLINE batch<T, Arch> bitwise_lshift_batch_const(batch<T, Arch> const& x, batch_constant<T, Arch, Values...> shift, std::true_type) noexcept
         {
             // Optimized ``batch_constant`` implementation
-            return kernel::bitwise_lshift<A>(x, shift, A {});
+            return kernel::bitwise_lshift<Arch>(x, shift, Arch {});
         }
 
-        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
+        template <class Arch, class T, T... Values>
+        XSIMD_INLINE batch<T, Arch> bitwise_lshift_batch_const(batch<T, Arch> const& x, batch_constant<T, Arch, Values...> shift, std::false_type) noexcept
         {
             // Fallback to regular run-time implementation
-            return kernel::bitwise_lshift<A>(x, shift.as_batch(), A {});
+            return kernel::bitwise_lshift<Arch>(x, shift.as_batch(), Arch {});
         }
     }
 

include/xsimd/types/xsimd_traits.hpp

@@ -12,6 +12,7 @@
 #ifndef XSIMD_TRAITS_HPP
 #define XSIMD_TRAITS_HPP
 
+#include <cstdint>
 #include <type_traits>
 
 #include "xsimd_batch.hpp"
@@ -421,6 +422,21 @@ namespace xsimd
             using type = uint16_t;
         };
         template <>
+        struct widen<int32_t>
+        {
+            using type = int64_t;
+        };
+        template <>
+        struct widen<int16_t>
+        {
+            using type = int32_t;
+        };
+        template <>
+        struct widen<int8_t>
+        {
+            using type = int16_t;
+        };
+        template <>
         struct widen<float>
         {
             using type = double;