Move to C++14: Use type laias for standard types

serge-sans-paille · serge-sans-paille · commit 3ac351f94475 · 2025-12-02T12:50:10.000+01:00
diff --git a/include/xsimd/arch/common/xsimd_common_math.hpp b/include/xsimd/arch/common/xsimd_common_math.hpp
@@ -60,7 +60,7 @@ namespace xsimd
                 // Inspired by
                 // https://stackoverflow.com/questions/5697500/take-the-average-of-two-signed-numbers-in-c
                 auto t = (x & y) + ((x ^ y) >> 1);
-                auto t_u = bitwise_cast<typename std::make_unsigned<T>::type>(t);
+                auto t_u = bitwise_cast<std::make_unsigned_t<T>>(t);
                 auto avg = t + (bitwise_cast<T>(t_u >> (8 * sizeof(T) - 1)) & (x ^ y));
                 return avg;
             }
diff --git a/include/xsimd/arch/xsimd_avx.hpp b/include/xsimd/arch/xsimd_avx.hpp
@@ -367,7 +367,7 @@ namespace xsimd
         {
             return _mm256_castsi256_pd(self);
         }
-        template <class A, class T, class Tp, class = std::enable_if_t<std::is_integral<typename std::common_type<T, Tp>::type>::value>>
+        template <class A, class T, class Tp, class = std::enable_if_t<std::is_integral<std::common_type_t<T, Tp>>::value>>
         XSIMD_INLINE batch<Tp, A> bitwise_cast(batch<T, A> const& self, batch<Tp, A> const&, requires_arch<avx>) noexcept
         {
             return batch<Tp, A>(self.data);
diff --git a/include/xsimd/arch/xsimd_avx2.hpp b/include/xsimd/arch/xsimd_avx2.hpp
@@ -143,7 +143,7 @@ namespace xsimd
         load_masked(T const* mem, batch_bool_constant<T, A, Values...> mask, convert<T>, Mode, requires_arch<avx2>) noexcept
         {
             static_assert(sizeof(T) == 4 || sizeof(T) == 8, "load_masked supports only 32/64-bit integers on AVX2");
-            using int_t = typename std::conditional<sizeof(T) == 4, int32_t, long long>::type;
+            using int_t = std::conditional_t<sizeof(T) == 4, int32_t, long long>;
             // Use the raw register-level maskload helpers for the remaining cases.
             return detail::maskload(reinterpret_cast<const int_t*>(mem), mask.as_batch());
         }
diff --git a/include/xsimd/arch/xsimd_avx512dq.hpp b/include/xsimd/arch/xsimd_avx512dq.hpp
@@ -236,8 +236,9 @@ namespace xsimd
             XSIMD_IF_CONSTEXPR(dup_lo || dup_hi)
             {
                 const batch<float, avx2> half = _mm512_extractf32x8_ps(self, dup_lo ? 0 : 1);
-                constexpr typename std::conditional<dup_lo, batch_constant<uint32_t, avx2, V0 % 8, V1 % 8, V2 % 8, V3 % 8, V4 % 8, V5 % 8, V6 % 8, V7 % 8>,
-                                                    batch_constant<uint32_t, avx2, V8 % 8, V9 % 8, V10 % 8, V11 % 8, V12 % 8, V13 % 8, V14 % 8, V15 % 8>>::type half_mask {};
+                constexpr std::conditional_t<dup_lo, batch_constant<uint32_t, avx2, V0 % 8, V1 % 8, V2 % 8, V3 % 8, V4 % 8, V5 % 8, V6 % 8, V7 % 8>,
+                                             batch_constant<uint32_t, avx2, V8 % 8, V9 % 8, V10 % 8, V11 % 8, V12 % 8, V13 % 8, V14 % 8, V15 % 8>>
+                    half_mask {};
                 auto permuted = swizzle(half, half_mask, avx2 {});
                 // merge the two slices into an AVX512F register:
                 return _mm512_broadcast_f32x8(permuted); // duplicates the 256-bit perm into both halves
diff --git a/include/xsimd/arch/xsimd_avx512f.hpp b/include/xsimd/arch/xsimd_avx512f.hpp
@@ -816,7 +816,7 @@ namespace xsimd
         {
             return _mm512_castsi512_pd(self);
         }
-        template <class A, class T, class Tp, class = std::enable_if_t<std::is_integral<typename std::common_type<T, Tp>::type>::value>>
+        template <class A, class T, class Tp, class = std::enable_if_t<std::is_integral<std::common_type<T, Tp>>::value>>
         XSIMD_INLINE batch<Tp, A> bitwise_cast(batch<T, A> const& self, batch<Tp, A> const&, requires_arch<avx512f>) noexcept
         {
             return batch<Tp, A>(self.data);
@@ -2405,8 +2405,9 @@ namespace xsimd
             XSIMD_IF_CONSTEXPR(dup_lo || dup_hi)
             {
                 const batch<double, avx2> half = _mm512_extractf64x4_pd(self, dup_lo ? 0 : 1);
-                constexpr typename std::conditional<dup_lo, batch_constant<uint64_t, avx2, V0 % 4, V1 % 4, V2 % 4, V3 % 4>,
-                                                    batch_constant<uint64_t, avx2, V4 % 4, V5 % 4, V6 % 4, V7 % 4>>::type half_mask {};
+                constexpr std::conditional_t<dup_lo, batch_constant<uint64_t, avx2, V0 % 4, V1 % 4, V2 % 4, V3 % 4>,
+                                             batch_constant<uint64_t, avx2, V4 % 4, V5 % 4, V6 % 4, V7 % 4>>
+                    half_mask {};
                 return _mm512_broadcast_f64x4(swizzle(half, half_mask, avx2 {}));
             }
             // General case
diff --git a/include/xsimd/arch/xsimd_scalar.hpp b/include/xsimd/arch/xsimd_scalar.hpp
@@ -148,15 +148,15 @@ namespace xsimd
 #endif
 
     template <class T, class Tp>
-    XSIMD_INLINE typename std::common_type<T, Tp>::type add(T const& x, Tp const& y) noexcept
+    XSIMD_INLINE std::common_type_t<T, Tp> add(T const& x, Tp const& y) noexcept
     {
         return x + y;
     }
 
     template <class T, class Tp>
-    XSIMD_INLINE typename std::common_type<T, Tp>::type avg(T const& x, Tp const& y) noexcept
+    XSIMD_INLINE std::common_type_t<T, Tp> avg(T const& x, Tp const& y) noexcept
     {
-        using common_type = typename std::common_type<T, Tp>::type;
+        using common_type = std::common_type_t<T, Tp>;
         if (std::is_floating_point<common_type>::value)
             return (x + y) / 2;
         else if (std::is_unsigned<common_type>::value)
@@ -168,16 +168,16 @@ namespace xsimd
             // Inspired by
             // https://stackoverflow.com/questions/5697500/take-the-average-of-two-signed-numbers-in-c
             auto t = (x & y) + ((x ^ y) >> 1);
-            auto t_u = static_cast<typename std::make_unsigned<common_type>::type>(t);
+            auto t_u = static_cast<std::make_unsigned_t<common_type>>(t);
             auto avg = t + (static_cast<T>(t_u >> (8 * sizeof(T) - 1)) & (x ^ y));
             return avg;
         }
     }
 
     template <class T, class Tp>
-    XSIMD_INLINE typename std::common_type<T, Tp>::type avgr(T const& x, Tp const& y) noexcept
+    XSIMD_INLINE std::common_type_t<T, Tp> avgr(T const& x, Tp const& y) noexcept
     {
-        using common_type = typename std::common_type<T, Tp>::type;
+        using common_type = std::common_type_t<T, Tp>;
         if (std::is_floating_point<common_type>::value)
             return avg(x, y);
         else
@@ -379,7 +379,7 @@ namespace xsimd
     }
 
     template <class T, class Tp>
-    XSIMD_INLINE typename std::common_type<T, Tp>::type div(T const& x, Tp const& y) noexcept
+    XSIMD_INLINE std::common_type_t<T, Tp> div(T const& x, Tp const& y) noexcept
     {
         return x / y;
     }
@@ -391,7 +391,7 @@ namespace xsimd
     }
 
     template <class T, class Tp>
-    XSIMD_INLINE typename std::common_type<T, Tp>::type mul(T const& x, Tp const& y) noexcept
+    XSIMD_INLINE std::common_type_t<T, Tp> mul(T const& x, Tp const& y) noexcept
     {
         return x * y;
     }
@@ -880,7 +880,7 @@ namespace xsimd
     }
 
     template <class T, class Tp>
-    XSIMD_INLINE typename std::common_type<T, Tp>::type sub(T const& x, Tp const& y) noexcept
+    XSIMD_INLINE std::common_type_t<T, Tp> sub(T const& x, Tp const& y) noexcept
     {
         return x - y;
     }
@@ -921,7 +921,7 @@ namespace xsimd
 
     // numpy defines minimum operator on complex using lexical comparison
     template <class T0, class T1>
-    XSIMD_INLINE std::complex<typename std::common_type<T0, T1>::type>
+    XSIMD_INLINE std::complex<std::common_type_t<T0, T1>>
     min(std::complex<T0> const& self, std::complex<T1> const& other) noexcept
     {
         return (self.real() < other.real()) ? (self) : (self.real() == other.real() ? (self.imag() < other.imag() ? self : other) : other);
@@ -935,7 +935,7 @@ namespace xsimd
 
     // numpy defines maximum operator on complex using lexical comparison
     template <class T0, class T1>
-    XSIMD_INLINE std::complex<typename std::common_type<T0, T1>::type>
+    XSIMD_INLINE std::complex<std::common_type_t<T0, T1>>
     max(std::complex<T0> const& self, std::complex<T1> const& other) noexcept
     {
         return (self.real() > other.real()) ? (self) : (self.real() == other.real() ? (self.imag() > other.imag() ? self : other) : other);
diff --git a/include/xsimd/arch/xsimd_sse2.hpp b/include/xsimd/arch/xsimd_sse2.hpp
@@ -551,7 +551,7 @@ namespace xsimd
         {
             return _mm_castsi128_ps(self);
         }
-        template <class A, class T, class Tp, class = std::enable_if_t<std::is_integral<typename std::common_type<T, Tp>::type>::value>>
+        template <class A, class T, class Tp, class = std::enable_if_t<std::is_integral<std::common_type_t<T, Tp>>::value>>
         XSIMD_INLINE batch<Tp, A> bitwise_cast(batch<T, A> const& self, batch<Tp, A> const&, requires_arch<sse2>) noexcept
         {
             return batch<Tp, A>(self.data);
diff --git a/include/xsimd/arch/xsimd_sve.hpp b/include/xsimd/arch/xsimd_sve.hpp
@@ -87,11 +87,11 @@ namespace xsimd
         namespace detail
         {
             // "char" is not allowed in SVE load/store operations
-            using sve_fix_char_t_impl = typename std::conditional<std::is_signed<char>::value, int8_t, uint8_t>::type;
+            using sve_fix_char_t_impl = std::conditional_t<std::is_signed<char>::value, int8_t, uint8_t>;
 
             template <class T>
-            using sve_fix_char_t = typename std::conditional<std::is_same<char, typename std::decay<T>::type>::value,
-                                                             sve_fix_char_t_impl, T>::type;
+            using sve_fix_char_t = std::conditional_t<std::is_same<char, std::decay_t<T>>::value,
+                                                      sve_fix_char_t_impl, T>;
         }
 
         template <class A, class T, detail::sve_enable_all_t<T> = 0>
@@ -150,7 +150,7 @@ namespace xsimd
         template <class A, class T, detail::sve_enable_floating_point_t<T> = 0>
         XSIMD_INLINE void store_complex_aligned(std::complex<T>* dst, batch<std::complex<T>, A> const& src, requires_arch<sve>) noexcept
         {
-            using v2type = typename std::conditional<(sizeof(T) == 4), svfloat32x2_t, svfloat64x2_t>::type;
+            using v2type = std::conditional_t<(sizeof(T) == 4), svfloat32x2_t, svfloat64x2_t>;
             v2type tmp {};
             tmp = svset2(tmp, 0, src.real());
             tmp = svset2(tmp, 1, src.imag());
diff --git a/include/xsimd/config/xsimd_arch.hpp b/include/xsimd/config/xsimd_arch.hpp
@@ -133,8 +133,8 @@ namespace xsimd
         template <class L, class Arch, class... Archs>
         struct supported_helper<L, arch_list<Arch, Archs...>>
             : supported_helper<
-                  typename std::conditional<Arch::supported(),
-                                            typename L::template add<Arch>, L>::type,
+                  std::conditional_t<Arch::supported(),
+                                     typename L::template add<Arch>, L>,
                   arch_list<Archs...>>
         {
         };
diff --git a/include/xsimd/memory/xsimd_aligned_allocator.hpp b/include/xsimd/memory/xsimd_aligned_allocator.hpp
@@ -341,9 +341,9 @@ namespace xsimd
     }
 
     template <class T, class A = default_arch>
-    using default_allocator = typename std::conditional<A::requires_alignment(),
-                                                        aligned_allocator<T, A::alignment()>,
-                                                        std::allocator<T>>::type;
+    using default_allocator = std::conditional_t<A::requires_alignment(),
+                                                 aligned_allocator<T, A::alignment()>,
+                                                 std::allocator<T>>;
 }
 
 #endif
diff --git a/include/xsimd/types/xsimd_api.hpp b/include/xsimd/types/xsimd_api.hpp
@@ -524,9 +524,9 @@ namespace xsimd
     {
         detail::static_check_supported_config<From, A>();
         using batch_value_type = typename simd_return_type<From, To, A>::value_type;
-        using value_type = typename std::conditional<std::is_same<From, bool>::value,
-                                                     bool,
-                                                     batch_value_type>::type;
+        using value_type = std::conditional_t<std::is_same<From, bool>::value,
+                                              bool,
+                                              batch_value_type>;
         return simd_return_type<From, To, A>(value_type(v));
     }
 
diff --git a/include/xsimd/types/xsimd_avx512f_register.hpp b/include/xsimd/types/xsimd_avx512f_register.hpp
@@ -42,9 +42,9 @@ namespace xsimd
         template <class T>
         struct simd_avx512_bool_register
         {
-            using register_type = typename std::conditional<
-                (sizeof(T) < 4), std::conditional<(sizeof(T) == 1), __mmask64, __mmask32>,
-                std::conditional<(sizeof(T) == 4), __mmask16, __mmask8>>::type::type;
+            using register_type = std::conditional_t<
+                (sizeof(T) < 4), std::conditional_t<(sizeof(T) == 1), __mmask64, __mmask32>,
+                std::conditional_t<(sizeof(T) == 4), __mmask16, __mmask8>>;
             register_type data;
             simd_avx512_bool_register() = default;
             simd_avx512_bool_register(register_type r) { data = r; }
diff --git a/include/xsimd/types/xsimd_batch.hpp b/include/xsimd/types/xsimd_batch.hpp
@@ -1576,10 +1576,10 @@ namespace xsimd
         template <typename T, std::size_t N, class Arch, class... Archs>
         struct sized_batch<T, N, xsimd::arch_list<Arch, Archs...>>
         {
-            using type = typename std::conditional<
+            using type = std::conditional_t<
                 batch_trait<T, Arch>::size == N,
                 typename batch_trait<T, Arch>::type,
-                typename sized_batch<T, N, xsimd::arch_list<Archs...>>::type>::type;
+                typename sized_batch<T, N, xsimd::arch_list<Archs...>>::type>;
         };
     }
 
diff --git a/include/xsimd/types/xsimd_neon_register.hpp b/include/xsimd/types/xsimd_neon_register.hpp
@@ -78,13 +78,13 @@ namespace xsimd
             using unsigned_neon_vector_type = typename neon_vector_type_impl<8 * sizeof(T)>::unsigned_type;
 
             template <class T>
-            using neon_vector_type = typename std::conditional<std::is_signed<T>::value,
-                                                               signed_neon_vector_type<T>,
-                                                               unsigned_neon_vector_type<T>>::type;
+            using neon_vector_type = std::conditional_t<std::is_signed<T>::value,
+                                                        signed_neon_vector_type<T>,
+                                                        unsigned_neon_vector_type<T>>;
 
-            using char_neon_vector_type = typename std::conditional<std::is_signed<char>::value,
-                                                                    signed_neon_vector_type<char>,
-                                                                    unsigned_neon_vector_type<char>>::type;
+            using char_neon_vector_type = std::conditional_t<std::is_signed<char>::value,
+                                                             signed_neon_vector_type<char>,
+                                                             unsigned_neon_vector_type<char>>;
         }
 
         XSIMD_DECLARE_SIMD_REGISTER(signed char, neon, detail::neon_vector_type<signed char>);
diff --git a/include/xsimd/types/xsimd_register.hpp b/include/xsimd/types/xsimd_register.hpp
@@ -83,7 +83,7 @@ namespace xsimd
     {
         template <class A>
         // makes requires_arch equal to A const&, using type_traits functions
-        using requires_arch = typename std::add_lvalue_reference<typename std::add_const<A>::type>::type;
+        using requires_arch = std::add_lvalue_reference_t<std::add_const_t<A>>;
         template <class T>
         struct convert
         {
diff --git a/include/xsimd/types/xsimd_rvv_register.hpp b/include/xsimd/types/xsimd_rvv_register.hpp
@@ -298,11 +298,11 @@ namespace xsimd
             // It's difficult dealing with both char and whichever *int8_t type
             // is compatible with char, so just avoid it altogether.
             //
-            using rvv_char_t = typename std::conditional<std::is_signed<char>::value, int8_t, uint8_t>::type;
+            using rvv_char_t = std::conditional_t<std::is_signed<char>::value, int8_t, uint8_t>;
             template <class T>
-            using rvv_fix_char_t = typename std::conditional<
-                std::is_same<char, typename std::decay<T>::type>::value,
-                rvv_char_t, T>::type;
+            using rvv_fix_char_t = std::conditional_t<
+                std::is_same<char, std::decay_t<T>>::value,
+                rvv_char_t, T>;
 
             // An explicit constructor isn't really explicit enough to allow
             // implicit bit-casting operations between incompatible types, so
@@ -342,7 +342,7 @@ namespace xsimd
                 operator register_type() const noexcept { return value.get(); }
             };
             template <class T, size_t Width = XSIMD_RVV_BITS>
-            using rvv_reg_t = typename std::conditional<!std::is_void<T>::value, rvv_reg<rvv_fix_char_t<T>, Width>, void>::type;
+            using rvv_reg_t = std::conditional_t<!std::is_void<T>::value, rvv_reg<rvv_fix_char_t<T>, Width>, void>;
 
             // And some more of the same stuff for bool types, which have
             // similar problems and similar workarounds.
@@ -450,14 +450,14 @@ namespace xsimd
             using floating_point_rvv_vector_type = typename rvv_vector_type_impl<8 * sizeof(T)>::floating_point_type;
 
             template <class T>
-            using signed_int_or_floating_point_rvv_vector_type = typename std::conditional<std::is_floating_point<T>::value,
-                                                                                           floating_point_rvv_vector_type<T>,
-                                                                                           signed_int_rvv_vector_type<T>>::type;
+            using signed_int_or_floating_point_rvv_vector_type = std::conditional_t<std::is_floating_point<T>::value,
+                                                                                    floating_point_rvv_vector_type<T>,
+                                                                                    signed_int_rvv_vector_type<T>>;
 
             template <class T>
-            using rvv_vector_type = typename std::conditional<std::is_signed<T>::value,
-                                                              signed_int_or_floating_point_rvv_vector_type<T>,
-                                                              unsigned_int_rvv_vector_type<T>>::type;
+            using rvv_vector_type = std::conditional_t<std::is_signed<T>::value,
+                                                       signed_int_or_floating_point_rvv_vector_type<T>,
+                                                       unsigned_int_rvv_vector_type<T>>;
         } // namespace detail
 
         XSIMD_DECLARE_SIMD_REGISTER(bool, rvv, detail::rvv_vector_type<unsigned char>);
diff --git a/include/xsimd/types/xsimd_sve_register.hpp b/include/xsimd/types/xsimd_sve_register.hpp
@@ -108,14 +108,14 @@ namespace xsimd
             using floating_point_sve_vector_type = typename sve_vector_type_impl<8 * sizeof(T)>::floating_point_type;
 
             template <class T>
-            using signed_int_or_floating_point_sve_vector_type = typename std::conditional<std::is_floating_point<T>::value,
-                                                                                           floating_point_sve_vector_type<T>,
-                                                                                           signed_int_sve_vector_type<T>>::type;
+            using signed_int_or_floating_point_sve_vector_type = std::conditional_t<std::is_floating_point<T>::value,
+                                                                                    floating_point_sve_vector_type<T>,
+                                                                                    signed_int_sve_vector_type<T>>;
 
             template <class T>
-            using sve_vector_type = typename std::conditional<std::is_signed<T>::value,
-                                                              signed_int_or_floating_point_sve_vector_type<T>,
-                                                              unsigned_int_sve_vector_type<T>>::type;
+            using sve_vector_type = std::conditional_t<std::is_signed<T>::value,
+                                                       signed_int_or_floating_point_sve_vector_type<T>,
+                                                       unsigned_int_sve_vector_type<T>>;
         } // namespace detail
 
         XSIMD_DECLARE_SIMD_REGISTER(signed char, sve, detail::sve_vector_type<signed char>);
diff --git a/include/xsimd/types/xsimd_traits.hpp b/include/xsimd/types/xsimd_traits.hpp
@@ -402,7 +402,7 @@ namespace xsimd
         template <typename T>
         struct widen
         {
-            using type = typename std::make_signed<typename widen<typename std::make_unsigned<T>::type>::type>::type;
+            using type = std::make_signed_t<typename widen<std::make_unsigned_t<T>>::type>;
         };
 
         template <>
diff --git a/test/test_batch_int.cpp b/test/test_batch_int.cpp
@@ -203,7 +203,7 @@ struct batch_int_test
 
     batch_int_test()
     {
-        using signed_value_type = typename std::make_signed<value_type>::type;
+        using signed_value_type = std::make_signed_t<value_type>;
         for (size_t i = 0; i < size; ++i)
         {
             bool negative_lhs = std::is_signed<value_type>::value && (i % 2 == 1);
diff --git a/test/test_conversion.cpp b/test/test_conversion.cpp
diff --git a/test/test_xsimd_api.cpp b/test/test_xsimd_api.cpp

Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ namespace xsimd`
`60`	`60`	`// Inspired by`
`61`	`61`	`// https://stackoverflow.com/questions/5697500/take-the-average-of-two-signed-numbers-in-c`
`62`	`62`	`auto t = (x & y) + ((x ^ y) >> 1);`
`63`		`- auto t_u = bitwise_cast<typename std::make_unsigned<T>::type>(t);`
	`63`	`+ auto t_u = bitwise_cast<std::make_unsigned_t<T>>(t);`
`64`	`64`	`auto avg = t + (bitwise_cast<T>(t_u >> (8 * sizeof(T) - 1)) & (x ^ y));`
`65`	`65`	`return avg;`
`66`	`66`	`}`
Original file line number	Diff line number	Diff line change
`@@ -367,7 +367,7 @@ namespace xsimd`
`367`	`367`	`{`
`368`	`368`	`return _mm256_castsi256_pd(self);`
`369`	`369`	`}`
`370`		`- template <class A, class T, class Tp, class = std::enable_if_t<std::is_integral<typename std::common_type<T, Tp>::type>::value>>`
	`370`	`+ template <class A, class T, class Tp, class = std::enable_if_t<std::is_integral<std::common_type_t<T, Tp>>::value>>`
`371`	`371`	`XSIMD_INLINE batch<Tp, A> bitwise_cast(batch<T, A> const& self, batch<Tp, A> const&, requires_arch<avx>) noexcept`
`372`	`372`	`{`
`373`	`373`	`return batch<Tp, A>(self.data);`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ namespace xsimd`
`143`	`143`	`load_masked(T const* mem, batch_bool_constant<T, A, Values...> mask, convert<T>, Mode, requires_arch<avx2>) noexcept`
`144`	`144`	`{`
`145`	`145`	`static_assert(sizeof(T) == 4 \|\| sizeof(T) == 8, "load_masked supports only 32/64-bit integers on AVX2");`
`146`		`- using int_t = typename std::conditional<sizeof(T) == 4, int32_t, long long>::type;`
	`146`	`+ using int_t = std::conditional_t<sizeof(T) == 4, int32_t, long long>;`
`147`	`147`	`// Use the raw register-level maskload helpers for the remaining cases.`
`148`	`148`	`return detail::maskload(reinterpret_cast<const int_t*>(mem), mask.as_batch());`
`149`	`149`	`}`
Original file line number	Diff line number	Diff line change
`@@ -816,7 +816,7 @@ namespace xsimd`
`816`	`816`	`{`
`817`	`817`	`return _mm512_castsi512_pd(self);`
`818`	`818`	`}`
`819`		`- template <class A, class T, class Tp, class = std::enable_if_t<std::is_integral<typename std::common_type<T, Tp>::type>::value>>`
	`819`	`+ template <class A, class T, class Tp, class = std::enable_if_t<std::is_integral<std::common_type<T, Tp>>::value>>`
`820`	`820`	`XSIMD_INLINE batch<Tp, A> bitwise_cast(batch<T, A> const& self, batch<Tp, A> const&, requires_arch<avx512f>) noexcept`
`821`	`821`	`{`
`822`	`822`	`return batch<Tp, A>(self.data);`
`@@ -2405,8 +2405,9 @@ namespace xsimd`
`2405`	`2405`	`XSIMD_IF_CONSTEXPR(dup_lo \|\| dup_hi)`
`2406`	`2406`	`{`
`2407`	`2407`	`const batch<double, avx2> half = _mm512_extractf64x4_pd(self, dup_lo ? 0 : 1);`
`2408`		`- constexpr typename std::conditional<dup_lo, batch_constant<uint64_t, avx2, V0 % 4, V1 % 4, V2 % 4, V3 % 4>,`
`2409`		`- batch_constant<uint64_t, avx2, V4 % 4, V5 % 4, V6 % 4, V7 % 4>>::type half_mask {};`
	`2408`	`+ constexpr std::conditional_t<dup_lo, batch_constant<uint64_t, avx2, V0 % 4, V1 % 4, V2 % 4, V3 % 4>,`
	`2409`	`+ batch_constant<uint64_t, avx2, V4 % 4, V5 % 4, V6 % 4, V7 % 4>>`
	`2410`	`+ half_mask {};`
`2410`	`2411`	`return _mm512_broadcast_f64x4(swizzle(half, half_mask, avx2 {}));`
`2411`	`2412`	`}`
`2412`	`2413`	`// General case`
Original file line number	Diff line number	Diff line change
`@@ -148,15 +148,15 @@ namespace xsimd`
`148`	`148`	`#endif`
`149`	`149`
`150`	`150`	`template <class T, class Tp>`
`151`		`- XSIMD_INLINE typename std::common_type<T, Tp>::type add(T const& x, Tp const& y) noexcept`
	`151`	`+ XSIMD_INLINE std::common_type_t<T, Tp> add(T const& x, Tp const& y) noexcept`
`152`	`152`	`{`
`153`	`153`	`return x + y;`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`template <class T, class Tp>`
`157`		`- XSIMD_INLINE typename std::common_type<T, Tp>::type avg(T const& x, Tp const& y) noexcept`
	`157`	`+ XSIMD_INLINE std::common_type_t<T, Tp> avg(T const& x, Tp const& y) noexcept`
`158`	`158`	`{`
`159`		`- using common_type = typename std::common_type<T, Tp>::type;`
	`159`	`+ using common_type = std::common_type_t<T, Tp>;`
`160`	`160`	`if (std::is_floating_point<common_type>::value)`
`161`	`161`	`return (x + y) / 2;`
`162`	`162`	`else if (std::is_unsigned<common_type>::value)`
`@@ -168,16 +168,16 @@ namespace xsimd`
`168`	`168`	`// Inspired by`
`169`	`169`	`// https://stackoverflow.com/questions/5697500/take-the-average-of-two-signed-numbers-in-c`
`170`	`170`	`auto t = (x & y) + ((x ^ y) >> 1);`
`171`		`- auto t_u = static_cast<typename std::make_unsigned<common_type>::type>(t);`
	`171`	`+ auto t_u = static_cast<std::make_unsigned_t<common_type>>(t);`
`172`	`172`	`auto avg = t + (static_cast<T>(t_u >> (8 * sizeof(T) - 1)) & (x ^ y));`
`173`	`173`	`return avg;`
`174`	`174`	`}`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`template <class T, class Tp>`
`178`		`- XSIMD_INLINE typename std::common_type<T, Tp>::type avgr(T const& x, Tp const& y) noexcept`
	`178`	`+ XSIMD_INLINE std::common_type_t<T, Tp> avgr(T const& x, Tp const& y) noexcept`
`179`	`179`	`{`
`180`		`- using common_type = typename std::common_type<T, Tp>::type;`
	`180`	`+ using common_type = std::common_type_t<T, Tp>;`
`181`	`181`	`if (std::is_floating_point<common_type>::value)`
`182`	`182`	`return avg(x, y);`
`183`	`183`	`else`
`@@ -379,7 +379,7 @@ namespace xsimd`
`379`	`379`	`}`
`380`	`380`
`381`	`381`	`template <class T, class Tp>`
`382`		`- XSIMD_INLINE typename std::common_type<T, Tp>::type div(T const& x, Tp const& y) noexcept`
	`382`	`+ XSIMD_INLINE std::common_type_t<T, Tp> div(T const& x, Tp const& y) noexcept`
`383`	`383`	`{`
`384`	`384`	`return x / y;`
`385`	`385`	`}`
`@@ -391,7 +391,7 @@ namespace xsimd`
`391`	`391`	`}`
`392`	`392`
`393`	`393`	`template <class T, class Tp>`
`394`		`- XSIMD_INLINE typename std::common_type<T, Tp>::type mul(T const& x, Tp const& y) noexcept`
	`394`	`+ XSIMD_INLINE std::common_type_t<T, Tp> mul(T const& x, Tp const& y) noexcept`
`395`	`395`	`{`
`396`	`396`	`return x * y;`
`397`	`397`	`}`
`@@ -880,7 +880,7 @@ namespace xsimd`
`880`	`880`	`}`
`881`	`881`
`882`	`882`	`template <class T, class Tp>`
`883`		`- XSIMD_INLINE typename std::common_type<T, Tp>::type sub(T const& x, Tp const& y) noexcept`
	`883`	`+ XSIMD_INLINE std::common_type_t<T, Tp> sub(T const& x, Tp const& y) noexcept`
`884`	`884`	`{`
`885`	`885`	`return x - y;`
`886`	`886`	`}`
`@@ -921,7 +921,7 @@ namespace xsimd`
`921`	`921`
`922`	`922`	`// numpy defines minimum operator on complex using lexical comparison`
`923`	`923`	`template <class T0, class T1>`
`924`		`- XSIMD_INLINE std::complex<typename std::common_type<T0, T1>::type>`
	`924`	`+ XSIMD_INLINE std::complex<std::common_type_t<T0, T1>>`
`925`	`925`	`min(std::complex<T0> const& self, std::complex<T1> const& other) noexcept`
`926`	`926`	`{`
`927`	`927`	`return (self.real() < other.real()) ? (self) : (self.real() == other.real() ? (self.imag() < other.imag() ? self : other) : other);`
`@@ -935,7 +935,7 @@ namespace xsimd`
`935`	`935`
`936`	`936`	`// numpy defines maximum operator on complex using lexical comparison`
`937`	`937`	`template <class T0, class T1>`
`938`		`- XSIMD_INLINE std::complex<typename std::common_type<T0, T1>::type>`
	`938`	`+ XSIMD_INLINE std::complex<std::common_type_t<T0, T1>>`
`939`	`939`	`max(std::complex<T0> const& self, std::complex<T1> const& other) noexcept`
`940`	`940`	`{`
`941`	`941`	`return (self.real() > other.real()) ? (self) : (self.real() == other.real() ? (self.imag() > other.imag() ? self : other) : other);`
Original file line number	Diff line number	Diff line change
`@@ -551,7 +551,7 @@ namespace xsimd`
`551`	`551`	`{`
`552`	`552`	`return _mm_castsi128_ps(self);`
`553`	`553`	`}`
`554`		`- template <class A, class T, class Tp, class = std::enable_if_t<std::is_integral<typename std::common_type<T, Tp>::type>::value>>`
	`554`	`+ template <class A, class T, class Tp, class = std::enable_if_t<std::is_integral<std::common_type_t<T, Tp>>::value>>`
`555`	`555`	`XSIMD_INLINE batch<Tp, A> bitwise_cast(batch<T, A> const& self, batch<Tp, A> const&, requires_arch<sse2>) noexcept`
`556`	`556`	`{`
`557`	`557`	`return batch<Tp, A>(self.data);`
Original file line number	Diff line number	Diff line change
`@@ -341,9 +341,9 @@ namespace xsimd`
`341`	`341`	`}`
`342`	`342`
`343`	`343`	`template <class T, class A = default_arch>`
`344`		`- using default_allocator = typename std::conditional<A::requires_alignment(),`
`345`		`- aligned_allocator<T, A::alignment()>,`
`346`		`- std::allocator<T>>::type;`
	`344`	`+ using default_allocator = std::conditional_t<A::requires_alignment(),`
	`345`	`+ aligned_allocator<T, A::alignment()>,`
	`346`	`+ std::allocator<T>>;`
`347`	`347`	`}`
`348`	`348`
`349`	`349`	`#endif`