Fixing API

DiamonDinoia · DiamonDinoia · commit 17a568e5db73 · 2025-09-02T12:09:55.000-04:00
diff --git a/docs/source/api/bitwise_operators_index.rst b/docs/source/api/bitwise_operators_index.rst
@@ -40,9 +40,9 @@ Bitwise operators
 +---------------------------------------+----------------------------------------------------+
 | :cpp:func:`bitwise_andnot`            | per slot bitwise and not                           |
 +---------------------------------------+----------------------------------------------------+
-| :cpp:func:`bitwise_lshift`            | per slot bitwise and                               |
+| :cpp:func:`bitwise_lshift`            | per slot bitwise left shift                        |
 +---------------------------------------+----------------------------------------------------+
-| :cpp:func:`bitwise_rshift`            | per slot bitwise and not                           |
+| :cpp:func:`bitwise_rshift`            | per slot bitwise right shift                       |
 +---------------------------------------+----------------------------------------------------+
 | :cpp:func:`rotr`                      | per slot rotate right                              |
 +---------------------------------------+----------------------------------------------------+
diff --git a/include/xsimd/arch/common/xsimd_common_arithmetic.hpp b/include/xsimd/arch/common/xsimd_common_arithmetic.hpp
@@ -34,9 +34,10 @@ namespace xsimd
                                  { return x << y; },
                                  self, other);
         }
-        template <int shift, class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
+        template <size_t shift, class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, requires_arch<common>) noexcept
         {
+            static_assert(shift < std::numeric_limits<T>::digits, "shift must be less than the number of bits in T");
             return bitwise_lshift(self, shift, A {});
         }
 
@@ -48,9 +49,10 @@ namespace xsimd
                                  { return x >> y; },
                                  self, other);
         }
-        template <int shift, class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
+        template <size_t shift, class A, class T, class /*=typename std::enable_if<std::is_integral<T>::value, void>::type*/>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, requires_arch<common>) noexcept
         {
+            static_assert(shift < std::numeric_limits<T>::digits, "shift must be less than the number of bits in T");
             return bitwise_rshift(self, shift, A {});
         }
 
@@ -193,9 +195,10 @@ namespace xsimd
             constexpr auto N = std::numeric_limits<T>::digits;
             return (self << other) | (self >> (N - other));
         }
-        template <int count, class A, class T>
+        template <size_t count, class A, class T>
         XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, requires_arch<common>) noexcept
         {
+            static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");
             constexpr auto N = std::numeric_limits<T>::digits;
             return bitwise_lshift<count>(self) | bitwise_rshift<N - count>(self);
         }
@@ -207,9 +210,10 @@ namespace xsimd
             constexpr auto N = std::numeric_limits<T>::digits;
             return (self >> other) | (self << (N - other));
         }
-        template <int count, class A, class T>
+        template <size_t count, class A, class T>
         XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, requires_arch<common>) noexcept
         {
+            static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");
             constexpr auto N = std::numeric_limits<T>::digits;
             return bitwise_rshift<count>(self) | bitwise_lshift<N - count>(self);
         }
diff --git a/include/xsimd/arch/xsimd_avx2.hpp b/include/xsimd/arch/xsimd_avx2.hpp
@@ -17,6 +17,8 @@
 
 #include "../types/xsimd_avx2_register.hpp"
 
+#include <limits>
+
 namespace xsimd
 {
 
@@ -172,9 +174,10 @@ namespace xsimd
             }
         }
 
-        template <int shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <size_t shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, requires_arch<avx2>) noexcept
         {
+            static_assert(shift < std::numeric_limits<T>::digits, "Shift amount must be less than the number of value bits in the type");
             XSIMD_IF_CONSTEXPR(sizeof(T) == 2)
             {
                 return _mm256_slli_epi16(self, shift);
@@ -269,9 +272,10 @@ namespace xsimd
             }
         }
 
-        template <int shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <size_t shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, requires_arch<avx2>) noexcept
         {
+            static_assert(shift < std::numeric_limits<T>::digits, "Shift amount must be less than the number of value bits in the type");
             if (std::is_signed<T>::value)
             {
                 XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
diff --git a/include/xsimd/arch/xsimd_avx512f.hpp b/include/xsimd/arch/xsimd_avx512f.hpp
@@ -585,9 +585,10 @@ namespace xsimd
         {
             return rotl(self, batch<T, A>(other), A {});
         }
-        template <int count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <size_t count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, requires_arch<avx512f>) noexcept
         {
+            static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");
             XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
             {
                 return _mm512_rol_epi32(self, count);
@@ -631,9 +632,10 @@ namespace xsimd
             return rotr(self, batch<T, A>(other), A {});
         }
 
-        template <int count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <size_t count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, requires_arch<avx512f>) noexcept
         {
+            static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");
             XSIMD_IF_CONSTEXPR(sizeof(T) < 4)
             {
                 return detail::fwd_to_avx([](__m256i s) noexcept
diff --git a/include/xsimd/arch/xsimd_avx512vbmi2.hpp b/include/xsimd/arch/xsimd_avx512vbmi2.hpp
@@ -82,9 +82,10 @@ namespace xsimd
             }
         }
 
-        template <int count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <size_t count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, requires_arch<avx512vbmi2>) noexcept
         {
+            static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");
             XSIMD_IF_CONSTEXPR(sizeof(T) == 2)
             {
                 return _mm512_shldi_epi16(self, self, count);
@@ -109,9 +110,10 @@ namespace xsimd
             }
         }
 
-        template <int count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <size_t count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, requires_arch<avx512vbmi2>) noexcept
         {
+            static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");
             XSIMD_IF_CONSTEXPR(sizeof(T) == 2)
             {
                 return _mm512_shrdi_epi16(self, self, count);
diff --git a/include/xsimd/arch/xsimd_common_fwd.hpp b/include/xsimd/arch/xsimd_common_fwd.hpp
@@ -26,11 +26,11 @@ namespace xsimd
         XSIMD_INLINE batch<T, A> abs(batch<T, A> const& self, requires_arch<common>) noexcept;
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept;
-        template <int shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <size_t shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, requires_arch<common>) noexcept;
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept;
-        template <int shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <size_t shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, requires_arch<common>) noexcept;
         template <class A, class T>
         XSIMD_INLINE batch_bool<T, A> gt(batch<T, A> const& self, batch<T, A> const& other, requires_arch<common>) noexcept;
@@ -44,11 +44,11 @@ namespace xsimd
         XSIMD_INLINE T hadd(batch<T, A> const& self, requires_arch<common>) noexcept;
         template <class A, class T, class STy>
         XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, STy other, requires_arch<common>) noexcept;
-        template <int count, class A, class T>
+        template <size_t count, class A, class T>
         XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, requires_arch<common>) noexcept;
         template <class A, class T, class STy>
         XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, STy other, requires_arch<common>) noexcept;
-        template <int count, class A, class T>
+        template <size_t count, class A, class T>
         XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, requires_arch<common>) noexcept;
         // Forward declarations for pack-level helpers
         namespace detail
diff --git a/include/xsimd/arch/xsimd_scalar.hpp b/include/xsimd/arch/xsimd_scalar.hpp
@@ -300,10 +300,11 @@ namespace xsimd
         return x << shift;
     }
 
-    template <int shift, class T>
+    template <size_t shift, class T>
     XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type
     bitwise_lshift(T x) noexcept
     {
+        static_assert(shift < std::numeric_limits<T>::digits, "shift must be less than the number of bits in T");
         return x << shift;
     }
 
@@ -313,10 +314,11 @@ namespace xsimd
     {
         return x >> shift;
     }
-    template <int shift, class T>
+    template <size_t shift, class T>
     XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type
     bitwise_rshift(T x) noexcept
     {
+        static_assert(shift < std::numeric_limits<T>::digits, "shift must be less than the number of bits in T");
         return x >> shift;
     }
 
@@ -463,10 +465,11 @@ namespace xsimd
         constexpr auto N = std::numeric_limits<T0>::digits;
         return (x << shift) | (x >> (N - shift));
     }
-    template <int count, class T>
+    template <size_t count, class T>
     XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type
     rotl(T x) noexcept
     {
+        static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");
         constexpr auto N = std::numeric_limits<T>::digits;
         return (x << count) | (x >> (N - count));
     }
@@ -478,10 +481,11 @@ namespace xsimd
         constexpr auto N = std::numeric_limits<T0>::digits;
         return (x >> shift) | (x << (N - shift));
     }
-    template <int count, class T>
+    template <size_t count, class T>
     XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type
     rotr(T x) noexcept
     {
+        static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");
         constexpr auto N = std::numeric_limits<T>::digits;
         return (x >> count) | (x << (N - count));
     }
diff --git a/include/xsimd/types/xsimd_api.hpp b/include/xsimd/types/xsimd_api.hpp
@@ -373,7 +373,7 @@ namespace xsimd
         detail::static_check_supported_config<T, A>();
         return kernel::bitwise_lshift<A>(x, shift, A {});
     }
-    template <int shift, class T, class 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>();
@@ -458,7 +458,7 @@ namespace xsimd
         detail::static_check_supported_config<T, A>();
         return kernel::bitwise_rshift<A>(x, shift, A {});
     }
-    template <int shift, class T, class A>
+    template <size_t shift, class T, class A>
     XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& x) noexcept
     {
         detail::static_check_supported_config<T, A>();
@@ -1978,7 +1978,7 @@ namespace xsimd
         detail::static_check_supported_config<T, A>();
         return kernel::rotl<A>(x, shift, A {});
     }
-    template <int count, class T, class A>
+    template <size_t count, class T, class A>
     XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& x) noexcept
     {
         detail::static_check_supported_config<T, A>();
@@ -2006,7 +2006,7 @@ namespace xsimd
         detail::static_check_supported_config<T, A>();
         return kernel::rotr<A>(x, shift, A {});
     }
-    template <int count, class T, class A>
+    template <size_t count, class T, class A>
     XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& x) noexcept
     {
         detail::static_check_supported_config<T, A>();

Original file line number	Diff line number	Diff line change
`@@ -34,9 +34,10 @@ namespace xsimd`
`34`	`34`	`{ return x << y; },`
`35`	`35`	`self, other);`
`36`	`36`	`}`
`37`		`- template <int shift, class A, class T, class /=typename std::enable_if<std::is_integral<T>::value, void>::type/>`
	`37`	`+ template <size_t shift, class A, class T, class /=typename std::enable_if<std::is_integral<T>::value, void>::type/>`
`38`	`38`	`XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, requires_arch<common>) noexcept`
`39`	`39`	`{`
	`40`	`+ static_assert(shift < std::numeric_limits<T>::digits, "shift must be less than the number of bits in T");`
`40`	`41`	`return bitwise_lshift(self, shift, A {});`
`41`	`42`	`}`
`42`	`43`
`@@ -48,9 +49,10 @@ namespace xsimd`
`48`	`49`	`{ return x >> y; },`
`49`	`50`	`self, other);`
`50`	`51`	`}`
`51`		`- template <int shift, class A, class T, class /=typename std::enable_if<std::is_integral<T>::value, void>::type/>`
	`52`	`+ template <size_t shift, class A, class T, class /=typename std::enable_if<std::is_integral<T>::value, void>::type/>`
`52`	`53`	`XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, requires_arch<common>) noexcept`
`53`	`54`	`{`
	`55`	`+ static_assert(shift < std::numeric_limits<T>::digits, "shift must be less than the number of bits in T");`
`54`	`56`	`return bitwise_rshift(self, shift, A {});`
`55`	`57`	`}`
`56`	`58`
`@@ -193,9 +195,10 @@ namespace xsimd`
`193`	`195`	`constexpr auto N = std::numeric_limits<T>::digits;`
`194`	`196`	`return (self << other) \| (self >> (N - other));`
`195`	`197`	`}`
`196`		`- template <int count, class A, class T>`
	`198`	`+ template <size_t count, class A, class T>`
`197`	`199`	`XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, requires_arch<common>) noexcept`
`198`	`200`	`{`
	`201`	`+ static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");`
`199`	`202`	`constexpr auto N = std::numeric_limits<T>::digits;`
`200`	`203`	`return bitwise_lshift<count>(self) \| bitwise_rshift<N - count>(self);`
`201`	`204`	`}`
`@@ -207,9 +210,10 @@ namespace xsimd`
`207`	`210`	`constexpr auto N = std::numeric_limits<T>::digits;`
`208`	`211`	`return (self >> other) \| (self << (N - other));`
`209`	`212`	`}`
`210`		`- template <int count, class A, class T>`
	`213`	`+ template <size_t count, class A, class T>`
`211`	`214`	`XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, requires_arch<common>) noexcept`
`212`	`215`	`{`
	`216`	`+ static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");`
`213`	`217`	`constexpr auto N = std::numeric_limits<T>::digits;`
`214`	`218`	`return bitwise_rshift<count>(self) \| bitwise_lshift<N - count>(self);`
`215`	`219`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,8 @@`
`17`	`17`
`18`	`18`	`#include "../types/xsimd_avx2_register.hpp"`
`19`	`19`
	`20`	`+#include <limits>`
	`21`	`+`
`20`	`22`	`namespace xsimd`
`21`	`23`	`{`
`22`	`24`
`@@ -172,9 +174,10 @@ namespace xsimd`
`172`	`174`	`}`
`173`	`175`	`}`
`174`	`176`
`175`		`- template <int shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
	`177`	`+ template <size_t shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
`176`	`178`	`XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& self, requires_arch<avx2>) noexcept`
`177`	`179`	`{`
	`180`	`+ static_assert(shift < std::numeric_limits<T>::digits, "Shift amount must be less than the number of value bits in the type");`
`178`	`181`	`XSIMD_IF_CONSTEXPR(sizeof(T) == 2)`
`179`	`182`	`{`
`180`	`183`	`return _mm256_slli_epi16(self, shift);`
`@@ -269,9 +272,10 @@ namespace xsimd`
`269`	`272`	`}`
`270`	`273`	`}`
`271`	`274`
`272`		`- template <int shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
	`275`	`+ template <size_t shift, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
`273`	`276`	`XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& self, requires_arch<avx2>) noexcept`
`274`	`277`	`{`
	`278`	`+ static_assert(shift < std::numeric_limits<T>::digits, "Shift amount must be less than the number of value bits in the type");`
`275`	`279`	`if (std::is_signed<T>::value)`
`276`	`280`	`{`
`277`	`281`	`XSIMD_IF_CONSTEXPR(sizeof(T) == 1)`
Original file line number	Diff line number	Diff line change
`@@ -585,9 +585,10 @@ namespace xsimd`
`585`	`585`	`{`
`586`	`586`	`return rotl(self, batch<T, A>(other), A {});`
`587`	`587`	`}`
`588`		`- template <int count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
	`588`	`+ template <size_t count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
`589`	`589`	`XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, requires_arch<avx512f>) noexcept`
`590`	`590`	`{`
	`591`	`+ static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");`
`591`	`592`	`XSIMD_IF_CONSTEXPR(sizeof(T) == 4)`
`592`	`593`	`{`
`593`	`594`	`return _mm512_rol_epi32(self, count);`
`@@ -631,9 +632,10 @@ namespace xsimd`
`631`	`632`	`return rotr(self, batch<T, A>(other), A {});`
`632`	`633`	`}`
`633`	`634`
`634`		`- template <int count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
	`635`	`+ template <size_t count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
`635`	`636`	`XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, requires_arch<avx512f>) noexcept`
`636`	`637`	`{`
	`638`	`+ static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");`
`637`	`639`	`XSIMD_IF_CONSTEXPR(sizeof(T) < 4)`
`638`	`640`	`{`
`639`	`641`	`return detail::fwd_to_avx([](__m256i s) noexcept`
Original file line number	Diff line number	Diff line change
`@@ -82,9 +82,10 @@ namespace xsimd`
`82`	`82`	`}`
`83`	`83`	`}`
`84`	`84`
`85`		`- template <int count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
	`85`	`+ template <size_t count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
`86`	`86`	`XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& self, requires_arch<avx512vbmi2>) noexcept`
`87`	`87`	`{`
	`88`	`+ static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");`
`88`	`89`	`XSIMD_IF_CONSTEXPR(sizeof(T) == 2)`
`89`	`90`	`{`
`90`	`91`	`return _mm512_shldi_epi16(self, self, count);`
`@@ -109,9 +110,10 @@ namespace xsimd`
`109`	`110`	`}`
`110`	`111`	`}`
`111`	`112`
`112`		`- template <int count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
	`113`	`+ template <size_t count, class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
`113`	`114`	`XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& self, requires_arch<avx512vbmi2>) noexcept`
`114`	`115`	`{`
	`116`	`+ static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");`
`115`	`117`	`XSIMD_IF_CONSTEXPR(sizeof(T) == 2)`
`116`	`118`	`{`
`117`	`119`	`return _mm512_shrdi_epi16(self, self, count);`
Original file line number	Diff line number	Diff line change
`@@ -300,10 +300,11 @@ namespace xsimd`
`300`	`300`	`return x << shift;`
`301`	`301`	`}`
`302`	`302`
`303`		`- template <int shift, class T>`
	`303`	`+ template <size_t shift, class T>`
`304`	`304`	`XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type`
`305`	`305`	`bitwise_lshift(T x) noexcept`
`306`	`306`	`{`
	`307`	`+ static_assert(shift < std::numeric_limits<T>::digits, "shift must be less than the number of bits in T");`
`307`	`308`	`return x << shift;`
`308`	`309`	`}`
`309`	`310`
`@@ -313,10 +314,11 @@ namespace xsimd`
`313`	`314`	`{`
`314`	`315`	`return x >> shift;`
`315`	`316`	`}`
`316`		`- template <int shift, class T>`
	`317`	`+ template <size_t shift, class T>`
`317`	`318`	`XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type`
`318`	`319`	`bitwise_rshift(T x) noexcept`
`319`	`320`	`{`
	`321`	`+ static_assert(shift < std::numeric_limits<T>::digits, "shift must be less than the number of bits in T");`
`320`	`322`	`return x >> shift;`
`321`	`323`	`}`
`322`	`324`
`@@ -463,10 +465,11 @@ namespace xsimd`
`463`	`465`	`constexpr auto N = std::numeric_limits<T0>::digits;`
`464`	`466`	`return (x << shift) \| (x >> (N - shift));`
`465`	`467`	`}`
`466`		`- template <int count, class T>`
	`468`	`+ template <size_t count, class T>`
`467`	`469`	`XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type`
`468`	`470`	`rotl(T x) noexcept`
`469`	`471`	`{`
	`472`	`+ static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");`
`470`	`473`	`constexpr auto N = std::numeric_limits<T>::digits;`
`471`	`474`	`return (x << count) \| (x >> (N - count));`
`472`	`475`	`}`
`@@ -478,10 +481,11 @@ namespace xsimd`
`478`	`481`	`constexpr auto N = std::numeric_limits<T0>::digits;`
`479`	`482`	`return (x >> shift) \| (x << (N - shift));`
`480`	`483`	`}`
`481`		`- template <int count, class T>`
	`484`	`+ template <size_t count, class T>`
`482`	`485`	`XSIMD_INLINE typename std::enable_if<std::is_integral<T>::value, T>::type`
`483`	`486`	`rotr(T x) noexcept`
`484`	`487`	`{`
	`488`	`+ static_assert(count < std::numeric_limits<T>::digits, "count must be less than the number of bits in T");`
`485`	`489`	`constexpr auto N = std::numeric_limits<T>::digits;`
`486`	`490`	`return (x >> count) \| (x << (N - count));`
`487`	`491`	`}`
Original file line number	Diff line number	Diff line change
`@@ -373,7 +373,7 @@ namespace xsimd`
`373`	`373`	`detail::static_check_supported_config<T, A>();`
`374`	`374`	`return kernel::bitwise_lshift<A>(x, shift, A {});`
`375`	`375`	`}`
`376`		`- template <int shift, class T, class A>`
	`376`	`+ template <size_t shift, class T, class A>`
`377`	`377`	`XSIMD_INLINE batch<T, A> bitwise_lshift(batch<T, A> const& x) noexcept`
`378`	`378`	`{`
`379`	`379`	`detail::static_check_supported_config<T, A>();`
`@@ -458,7 +458,7 @@ namespace xsimd`
`458`	`458`	`detail::static_check_supported_config<T, A>();`
`459`	`459`	`return kernel::bitwise_rshift<A>(x, shift, A {});`
`460`	`460`	`}`
`461`		`- template <int shift, class T, class A>`
	`461`	`+ template <size_t shift, class T, class A>`
`462`	`462`	`XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& x) noexcept`
`463`	`463`	`{`
`464`	`464`	`detail::static_check_supported_config<T, A>();`
`@@ -1978,7 +1978,7 @@ namespace xsimd`
`1978`	`1978`	`detail::static_check_supported_config<T, A>();`
`1979`	`1979`	`return kernel::rotl<A>(x, shift, A {});`
`1980`	`1980`	`}`
`1981`		`- template <int count, class T, class A>`
	`1981`	`+ template <size_t count, class T, class A>`
`1982`	`1982`	`XSIMD_INLINE batch<T, A> rotl(batch<T, A> const& x) noexcept`
`1983`	`1983`	`{`
`1984`	`1984`	`detail::static_check_supported_config<T, A>();`
`@@ -2006,7 +2006,7 @@ namespace xsimd`
`2006`	`2006`	`detail::static_check_supported_config<T, A>();`
`2007`	`2007`	`return kernel::rotr<A>(x, shift, A {});`
`2008`	`2008`	`}`
`2009`		`- template <int count, class T, class A>`
	`2009`	`+ template <size_t count, class T, class A>`
`2010`	`2010`	`XSIMD_INLINE batch<T, A> rotr(batch<T, A> const& x) noexcept`
`2011`	`2011`	`{`
`2012`	`2012`	`detail::static_check_supported_config<T, A>();`