Apply clang-tidy's current rules to xsimd

serge-sans-paille · serge-sans-paille · commit 7c698a015755 · 2026-04-20T11:52:20.000+02:00
diff --git a/include/xsimd/arch/xsimd_avx.hpp b/include/xsimd/arch/xsimd_avx.hpp
@@ -1526,7 +1526,7 @@ namespace xsimd
         {
             _mm256_stream_pd(mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>
         XSIMD_INLINE void store_stream(T* mem, batch<T, A> const& self, requires_arch<avx>) noexcept
         {
             _mm256_stream_si256((__m256i*)mem, self);
diff --git a/include/xsimd/arch/xsimd_avx2.hpp b/include/xsimd/arch/xsimd_avx2.hpp
@@ -231,7 +231,7 @@ namespace xsimd
         }
 
         // load_stream
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>
         XSIMD_INLINE batch<T, A> load_stream(T const* mem, convert<T>, requires_arch<avx2>) noexcept
         {
             return _mm256_stream_load_si256((__m256i const*)mem);
@@ -359,7 +359,7 @@ namespace xsimd
         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;
+            using uint_t = std::make_unsigned_t<T>;
 
             // AVX2 only supports 16-bit shifts with a uniform bitshift value,
             // otherwise emulate using 32-bit shifts.
diff --git a/include/xsimd/arch/xsimd_avx512f.hpp b/include/xsimd/arch/xsimd_avx512f.hpp
@@ -1514,7 +1514,7 @@ namespace xsimd
         }
 
         // load_stream
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>
         XSIMD_INLINE batch<T, A> load_stream(T const* mem, convert<T>, requires_arch<avx512f>) noexcept
         {
             return _mm512_stream_load_si512((__m512i*)mem);
@@ -2303,7 +2303,7 @@ namespace xsimd
         }
 
         // store_stream
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>
         XSIMD_INLINE void store_stream(T* mem, batch<T, A> const& self, requires_arch<avx512f>) noexcept
         {
             _mm512_stream_si512((__m512i*)mem, self);
@@ -2483,7 +2483,7 @@ namespace xsimd
             };
 
             template <class T, class A, T Idx0, T Idx1, T... Idx>
-            struct is_pair_of_contiguous_indices<T, A, Idx0, Idx1, Idx...> : std::conditional<(Idx0 % 2 == 0) && (Idx0 + 1 == Idx1), is_pair_of_contiguous_indices<T, A, Idx...>, std::false_type>::type
+            struct is_pair_of_contiguous_indices<T, A, Idx0, Idx1, Idx...> : std::conditional_t<(Idx0 % 2 == 0) && (Idx0 + 1 == Idx1), is_pair_of_contiguous_indices<T, A, Idx...>, std::false_type>
             {
             };
 
diff --git a/include/xsimd/arch/xsimd_sse2.hpp b/include/xsimd/arch/xsimd_sse2.hpp
@@ -345,7 +345,7 @@ namespace xsimd
         XSIMD_INLINE batch<T, A> bitwise_lshift(
             batch<T, A> const& self, batch_constant<T, A, Vs...> shifts, requires_arch<sse2> req) noexcept
         {
-            using uint_t = typename std::make_unsigned<T>::type;
+            using uint_t = std::make_unsigned_t<T>;
 
             XSIMD_IF_CONSTEXPR(utils::all_equals(shifts))
             {
@@ -1966,7 +1966,7 @@ namespace xsimd
         {
             _mm_stream_ps(mem, self);
         }
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>
         XSIMD_INLINE void store_stream(T* mem, batch<T, A> const& self, requires_arch<sse2>) noexcept
         {
             _mm_stream_si128((__m128i*)mem, self);
diff --git a/include/xsimd/arch/xsimd_sse4_1.hpp b/include/xsimd/arch/xsimd_sse4_1.hpp
@@ -229,7 +229,7 @@ namespace xsimd
         }
 
         // load_stream
-        template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
+        template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>
         XSIMD_INLINE batch<T, A> load_stream(T const* mem, convert<T>, requires_arch<sse4_1>) noexcept
         {
             return _mm_stream_load_si128((__m128i*)mem);
diff --git a/include/xsimd/config/xsimd_arch.hpp b/include/xsimd/config/xsimd_arch.hpp
@@ -51,8 +51,8 @@ namespace xsimd
 
         template <class T, class Ty, class... Tys>
         struct contains<T, Ty, Tys...>
-            : std::conditional<std::is_same<Ty, T>::value, std::true_type,
-                               contains<T, Tys...>>::type
+            : std::conditional_t<std::is_same<Ty, T>::value, std::true_type,
+                               contains<T, Tys...>>
         {
         };
 
diff --git a/include/xsimd/config/xsimd_cpu_features_x86.hpp b/include/xsimd/config/xsimd_cpu_features_x86.hpp
@@ -138,55 +138,55 @@ namespace xsimd
                 enum class type {};
             };
 
-            using eax_or_empty = typename std::conditional<std::is_void<eax>::value, typename m_empty_reg<0>::type, eax>::type;
-            using ebx_or_empty = typename std::conditional<std::is_void<ebx>::value, typename m_empty_reg<1>::type, ebx>::type;
-            using ecx_or_empty = typename std::conditional<std::is_void<ecx>::value, typename m_empty_reg<2>::type, ecx>::type;
-            using edx_or_empty = typename std::conditional<std::is_void<edx>::value, typename m_empty_reg<3>::type, edx>::type;
+            using eax_or_empty = std::conditional_t<std::is_void<eax>::value, typename m_empty_reg<0>::type, eax>;
+            using ebx_or_empty = std::conditional_t<std::is_void<ebx>::value, typename m_empty_reg<1>::type, ebx>;
+            using ecx_or_empty = std::conditional_t<std::is_void<ecx>::value, typename m_empty_reg<2>::type, ecx>;
+            using edx_or_empty = std::conditional_t<std::is_void<edx>::value, typename m_empty_reg<3>::type, edx>;
 
         public:
-            template <eax_or_empty... bits, typename T = eax, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <eax_or_empty... bits, typename T = eax, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr bool all_bits_set() const noexcept
             {
                 return x86_reg32_bitset<eax>::template all_bits_set<bits...>();
             }
 
-            template <eax_or_empty start, eax_or_empty end, typename T = eax, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <eax_or_empty start, eax_or_empty end, typename T = eax, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr x86_reg32_t get_range() const noexcept
             {
                 return x86_reg32_bitset<eax>::template get_range<start, end>();
             }
 
-            template <ebx_or_empty... bits, typename T = ebx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <ebx_or_empty... bits, typename T = ebx, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr bool all_bits_set() const noexcept
             {
                 return x86_reg32_bitset<ebx>::template all_bits_set<bits...>();
             }
 
-            template <ebx_or_empty start, ebx_or_empty end, typename T = ebx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <ebx_or_empty start, ebx_or_empty end, typename T = ebx, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr x86_reg32_t get_range() const noexcept
             {
                 return x86_reg32_bitset<ebx>::template get_range<start, end>();
             }
 
-            template <ecx_or_empty... bits, typename T = ecx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <ecx_or_empty... bits, typename T = ecx, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr bool all_bits_set() const noexcept
             {
                 return x86_reg32_bitset<ecx>::template all_bits_set<bits...>();
             }
 
-            template <ecx_or_empty start, ecx_or_empty end, typename T = ecx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <ecx_or_empty start, ecx_or_empty end, typename T = ecx, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr x86_reg32_t get_range() const noexcept
             {
                 return x86_reg32_bitset<ecx>::template get_range<start, end>();
             }
 
-            template <edx_or_empty... bits, typename T = edx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <edx_or_empty... bits, typename T = edx, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr bool all_bits_set() const noexcept
             {
                 return x86_reg32_bitset<edx>::template all_bits_set<bits...>();
             }
 
-            template <edx_or_empty start, edx_or_empty end, typename T = edx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>
+            template <edx_or_empty start, edx_or_empty end, typename T = edx, std::enable_if_t<!std::is_void<T>::value, int> = 0>
             constexpr x86_reg32_t get_range() const noexcept
             {
                 return x86_reg32_bitset<edx>::template get_range<start, end>();
diff --git a/test/test_xsimd_api.cpp b/test/test_xsimd_api.cpp
@@ -366,7 +366,7 @@ struct xsimd_api_integral_types_functions
 
     /* Test when T is a batch_constant only, not a scalar. */
     template <typename U = T>
-    void test_bitwise_lshift_multiple(T const& vals, typename std::enable_if<!std::is_integral<U>::value, int>::type = 0)
+    void test_bitwise_lshift_multiple(T const& vals, std::enable_if_t<!std::is_integral<U>::value, int> = 0)
     {
 #ifndef XSIMD_NO_SUPPORTED_ARCHITECTURE
         constexpr auto Max = static_cast<value_type>(std::numeric_limits<value_type>::digits);
@@ -389,7 +389,7 @@ struct xsimd_api_integral_types_functions
 
     /* Test multiple does not make sense when T is scalar. */
     template <typename U = T>
-    void test_bitwise_lshift_multiple(T const&, typename std::enable_if<std::is_integral<U>::value, int>::type = 0)
+    void test_bitwise_lshift_multiple(T const&, std::enable_if_t<std::is_integral<U>::value, int> = 0)
     {
     }
 

Original file line number	Diff line number	Diff line change
`@@ -1526,7 +1526,7 @@ namespace xsimd`
`1526`	`1526`	`{`
`1527`	`1527`	`_mm256_stream_pd(mem, self);`
`1528`	`1528`	`}`
`1529`		`- template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
	`1529`	`+ template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>`
`1530`	`1530`	`XSIMD_INLINE void store_stream(T* mem, batch<T, A> const& self, requires_arch<avx>) noexcept`
`1531`	`1531`	`{`
`1532`	`1532`	`_mm256_stream_si256((__m256i*)mem, self);`
Original file line number	Diff line number	Diff line change
`@@ -231,7 +231,7 @@ namespace xsimd`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`// load_stream`
`234`		`- template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
	`234`	`+ template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>`
`235`	`235`	`XSIMD_INLINE batch<T, A> load_stream(T const* mem, convert<T>, requires_arch<avx2>) noexcept`
`236`	`236`	`{`
`237`	`237`	`return _mm256_stream_load_si256((__m256i const*)mem);`
`@@ -359,7 +359,7 @@ namespace xsimd`
`359`	`359`	`XSIMD_INLINE batch<T, A> bitwise_lshift(`
`360`	`360`	`batch<T, A> const& self, batch_constant<T, A, Vs...> shifts, requires_arch<avx2> req) noexcept`
`361`	`361`	`{`
`362`		`- using uint_t = typename std::make_unsigned<T>::type;`
	`362`	`+ using uint_t = std::make_unsigned_t<T>;`
`363`	`363`
`364`	`364`	`// AVX2 only supports 16-bit shifts with a uniform bitshift value,`
`365`	`365`	`// otherwise emulate using 32-bit shifts.`
Original file line number	Diff line number	Diff line change
`@@ -1514,7 +1514,7 @@ namespace xsimd`
`1514`	`1514`	`}`
`1515`	`1515`
`1516`	`1516`	`// load_stream`
`1517`		`- template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
	`1517`	`+ template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>`
`1518`	`1518`	`XSIMD_INLINE batch<T, A> load_stream(T const* mem, convert<T>, requires_arch<avx512f>) noexcept`
`1519`	`1519`	`{`
`1520`	`1520`	`return _mm512_stream_load_si512((__m512i*)mem);`
`@@ -2303,7 +2303,7 @@ namespace xsimd`
`2303`	`2303`	`}`
`2304`	`2304`
`2305`	`2305`	`// store_stream`
`2306`		`- template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
	`2306`	`+ template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>`
`2307`	`2307`	`XSIMD_INLINE void store_stream(T* mem, batch<T, A> const& self, requires_arch<avx512f>) noexcept`
`2308`	`2308`	`{`
`2309`	`2309`	`_mm512_stream_si512((__m512i*)mem, self);`
`@@ -2483,7 +2483,7 @@ namespace xsimd`
`2483`	`2483`	`};`
`2484`	`2484`
`2485`	`2485`	`template <class T, class A, T Idx0, T Idx1, T... Idx>`
`2486`		`- struct is_pair_of_contiguous_indices<T, A, Idx0, Idx1, Idx...> : std::conditional<(Idx0 % 2 == 0) && (Idx0 + 1 == Idx1), is_pair_of_contiguous_indices<T, A, Idx...>, std::false_type>::type`
	`2486`	`+ struct is_pair_of_contiguous_indices<T, A, Idx0, Idx1, Idx...> : std::conditional_t<(Idx0 % 2 == 0) && (Idx0 + 1 == Idx1), is_pair_of_contiguous_indices<T, A, Idx...>, std::false_type>`
`2487`	`2487`	`{`
`2488`	`2488`	`};`
`2489`	`2489`
Original file line number	Diff line number	Diff line change
`@@ -345,7 +345,7 @@ namespace xsimd`
`345`	`345`	`XSIMD_INLINE batch<T, A> bitwise_lshift(`
`346`	`346`	`batch<T, A> const& self, batch_constant<T, A, Vs...> shifts, requires_arch<sse2> req) noexcept`
`347`	`347`	`{`
`348`		`- using uint_t = typename std::make_unsigned<T>::type;`
	`348`	`+ using uint_t = std::make_unsigned_t<T>;`
`349`	`349`
`350`	`350`	`XSIMD_IF_CONSTEXPR(utils::all_equals(shifts))`
`351`	`351`	`{`
`@@ -1966,7 +1966,7 @@ namespace xsimd`
`1966`	`1966`	`{`
`1967`	`1967`	`_mm_stream_ps(mem, self);`
`1968`	`1968`	`}`
`1969`		`- template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
	`1969`	`+ template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>`
`1970`	`1970`	`XSIMD_INLINE void store_stream(T* mem, batch<T, A> const& self, requires_arch<sse2>) noexcept`
`1971`	`1971`	`{`
`1972`	`1972`	`_mm_stream_si128((__m128i*)mem, self);`
Original file line number	Diff line number	Diff line change
`@@ -229,7 +229,7 @@ namespace xsimd`
`229`	`229`	`}`
`230`	`230`
`231`	`231`	`// load_stream`
`232`		`- template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>`
	`232`	`+ template <class A, class T, class = std::enable_if_t<std::is_integral<T>::value, void>>`
`233`	`233`	`XSIMD_INLINE batch<T, A> load_stream(T const* mem, convert<T>, requires_arch<sse4_1>) noexcept`
`234`	`234`	`{`
`235`	`235`	`return _mm_stream_load_si128((__m128i*)mem);`
Original file line number	Diff line number	Diff line change
`@@ -51,8 +51,8 @@ namespace xsimd`
`51`	`51`
`52`	`52`	`template <class T, class Ty, class... Tys>`
`53`	`53`	`struct contains<T, Ty, Tys...>`
`54`		`- : std::conditional<std::is_same<Ty, T>::value, std::true_type,`
`55`		`- contains<T, Tys...>>::type`
	`54`	`+ : std::conditional_t<std::is_same<Ty, T>::value, std::true_type,`
	`55`	`+ contains<T, Tys...>>`
`56`	`56`	`{`
`57`	`57`	`};`
`58`	`58`
Original file line number	Diff line number	Diff line change
`@@ -138,55 +138,55 @@ namespace xsimd`
`138`	`138`	`enum class type {};`
`139`	`139`	`};`
`140`	`140`
`141`		`- using eax_or_empty = typename std::conditional<std::is_void<eax>::value, typename m_empty_reg<0>::type, eax>::type;`
`142`		`- using ebx_or_empty = typename std::conditional<std::is_void<ebx>::value, typename m_empty_reg<1>::type, ebx>::type;`
`143`		`- using ecx_or_empty = typename std::conditional<std::is_void<ecx>::value, typename m_empty_reg<2>::type, ecx>::type;`
`144`		`- using edx_or_empty = typename std::conditional<std::is_void<edx>::value, typename m_empty_reg<3>::type, edx>::type;`
	`141`	`+ using eax_or_empty = std::conditional_t<std::is_void<eax>::value, typename m_empty_reg<0>::type, eax>;`
	`142`	`+ using ebx_or_empty = std::conditional_t<std::is_void<ebx>::value, typename m_empty_reg<1>::type, ebx>;`
	`143`	`+ using ecx_or_empty = std::conditional_t<std::is_void<ecx>::value, typename m_empty_reg<2>::type, ecx>;`
	`144`	`+ using edx_or_empty = std::conditional_t<std::is_void<edx>::value, typename m_empty_reg<3>::type, edx>;`
`145`	`145`
`146`	`146`	`public:`
`147`		`- template <eax_or_empty... bits, typename T = eax, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>`
	`147`	`+ template <eax_or_empty... bits, typename T = eax, std::enable_if_t<!std::is_void<T>::value, int> = 0>`
`148`	`148`	`constexpr bool all_bits_set() const noexcept`
`149`	`149`	`{`
`150`	`150`	`return x86_reg32_bitset<eax>::template all_bits_set<bits...>();`
`151`	`151`	`}`
`152`	`152`
`153`		`- template <eax_or_empty start, eax_or_empty end, typename T = eax, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>`
	`153`	`+ template <eax_or_empty start, eax_or_empty end, typename T = eax, std::enable_if_t<!std::is_void<T>::value, int> = 0>`
`154`	`154`	`constexpr x86_reg32_t get_range() const noexcept`
`155`	`155`	`{`
`156`	`156`	`return x86_reg32_bitset<eax>::template get_range<start, end>();`
`157`	`157`	`}`
`158`	`158`
`159`		`- template <ebx_or_empty... bits, typename T = ebx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>`
	`159`	`+ template <ebx_or_empty... bits, typename T = ebx, std::enable_if_t<!std::is_void<T>::value, int> = 0>`
`160`	`160`	`constexpr bool all_bits_set() const noexcept`
`161`	`161`	`{`
`162`	`162`	`return x86_reg32_bitset<ebx>::template all_bits_set<bits...>();`
`163`	`163`	`}`
`164`	`164`
`165`		`- template <ebx_or_empty start, ebx_or_empty end, typename T = ebx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>`
	`165`	`+ template <ebx_or_empty start, ebx_or_empty end, typename T = ebx, std::enable_if_t<!std::is_void<T>::value, int> = 0>`
`166`	`166`	`constexpr x86_reg32_t get_range() const noexcept`
`167`	`167`	`{`
`168`	`168`	`return x86_reg32_bitset<ebx>::template get_range<start, end>();`
`169`	`169`	`}`
`170`	`170`
`171`		`- template <ecx_or_empty... bits, typename T = ecx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>`
	`171`	`+ template <ecx_or_empty... bits, typename T = ecx, std::enable_if_t<!std::is_void<T>::value, int> = 0>`
`172`	`172`	`constexpr bool all_bits_set() const noexcept`
`173`	`173`	`{`
`174`	`174`	`return x86_reg32_bitset<ecx>::template all_bits_set<bits...>();`
`175`	`175`	`}`
`176`	`176`
`177`		`- template <ecx_or_empty start, ecx_or_empty end, typename T = ecx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>`
	`177`	`+ template <ecx_or_empty start, ecx_or_empty end, typename T = ecx, std::enable_if_t<!std::is_void<T>::value, int> = 0>`
`178`	`178`	`constexpr x86_reg32_t get_range() const noexcept`
`179`	`179`	`{`
`180`	`180`	`return x86_reg32_bitset<ecx>::template get_range<start, end>();`
`181`	`181`	`}`
`182`	`182`
`183`		`- template <edx_or_empty... bits, typename T = edx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>`
	`183`	`+ template <edx_or_empty... bits, typename T = edx, std::enable_if_t<!std::is_void<T>::value, int> = 0>`
`184`	`184`	`constexpr bool all_bits_set() const noexcept`
`185`	`185`	`{`
`186`	`186`	`return x86_reg32_bitset<edx>::template all_bits_set<bits...>();`
`187`	`187`	`}`
`188`	`188`
`189`		`- template <edx_or_empty start, edx_or_empty end, typename T = edx, typename std::enable_if<!std::is_void<T>::value, int>::type = 0>`
	`189`	`+ template <edx_or_empty start, edx_or_empty end, typename T = edx, std::enable_if_t<!std::is_void<T>::value, int> = 0>`
`190`	`190`	`constexpr x86_reg32_t get_range() const noexcept`
`191`	`191`	`{`
`192`	`192`	`return x86_reg32_bitset<edx>::template get_range<start, end>();`
Original file line number	Diff line number	Diff line change
`@@ -366,7 +366,7 @@ struct xsimd_api_integral_types_functions`
`366`	`366`
`367`	`367`	`/* Test when T is a batch_constant only, not a scalar. */`
`368`	`368`	`template <typename U = T>`
`369`		`- void test_bitwise_lshift_multiple(T const& vals, typename std::enable_if<!std::is_integral<U>::value, int>::type = 0)`
	`369`	`+ void test_bitwise_lshift_multiple(T const& vals, std::enable_if_t<!std::is_integral<U>::value, int> = 0)`
`370`	`370`	`{`
`371`	`371`	`#ifndef XSIMD_NO_SUPPORTED_ARCHITECTURE`
`372`	`372`	`constexpr auto Max = static_cast<value_type>(std::numeric_limits<value_type>::digits);`
`@@ -389,7 +389,7 @@ struct xsimd_api_integral_types_functions`
`389`	`389`
`390`	`390`	`/* Test multiple does not make sense when T is scalar. */`
`391`	`391`	`template <typename U = T>`
`392`		`- void test_bitwise_lshift_multiple(T const&, typename std::enable_if<std::is_integral<U>::value, int>::type = 0)`
	`392`	`+ void test_bitwise_lshift_multiple(T const&, std::enable_if_t<std::is_integral<U>::value, int> = 0)`
`393`	`393`	`{`
`394`	`394`	`}`
`395`	`395`