Move to C++14: take advantage of auto type deduction for functions

serge-sans-paille · serge-sans-paille · commit fd7ee1ed5a10 · 2025-12-02T13:17:51.000+01:00
As a side effect also cleanup some instances where auto was unneeded or
redundant.
diff --git a/include/xsimd/arch/common/xsimd_common_memory.hpp b/include/xsimd/arch/common/xsimd_common_memory.hpp
@@ -222,7 +222,7 @@ namespace xsimd
         }
 
         template <class A, size_t I, class T>
-        XSIMD_INLINE auto get(batch<std::complex<T>, A> const& self, ::xsimd::index<I>, requires_arch<common>) noexcept -> typename batch<std::complex<T>, A>::value_type
+        XSIMD_INLINE typename batch<std::complex<T>, A>::value_type get(batch<std::complex<T>, A> const& self, ::xsimd::index<I>, requires_arch<common>) noexcept
         {
             alignas(A::alignment()) T buffer[batch<std::complex<T>, A>::size];
             self.store_aligned(&buffer[0]);
@@ -246,7 +246,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE auto get(batch<std::complex<T>, A> const& self, std::size_t i, requires_arch<common>) noexcept -> typename batch<std::complex<T>, A>::value_type
+        XSIMD_INLINE typename batch<std::complex<T>, A>::value_type get(batch<std::complex<T>, A> const& self, std::size_t i, requires_arch<common>) noexcept
         {
             using T2 = typename batch<std::complex<T>, A>::value_type;
             alignas(A::alignment()) T2 buffer[batch<std::complex<T>, A>::size];
@@ -268,7 +268,7 @@ namespace xsimd
         }
 
         template <class A, class T>
-        XSIMD_INLINE auto first(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept -> typename batch<std::complex<T>, A>::value_type
+        XSIMD_INLINE typename batch<std::complex<T>, A>::value_type first(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept
         {
             return { first(self.real(), A {}), first(self.imag(), A {}) };
         }
diff --git a/include/xsimd/arch/xsimd_avx2.hpp b/include/xsimd/arch/xsimd_avx2.hpp
@@ -1287,17 +1287,16 @@ namespace xsimd
             }
 
             template <typename T, typename A, T... Vals, std::size_t... Ids>
-            constexpr auto swizzle_make_self_batch_impl(std::index_sequence<Ids...>)
-                -> batch_constant<T, A, swizzle_self_val(Vals, T(Ids), static_cast<T>(sizeof...(Vals)))...>
+            constexpr batch_constant<T, A, swizzle_self_val(Vals, T(Ids), static_cast<T>(sizeof...(Vals)))...>
+            swizzle_make_self_batch_impl(std::index_sequence<Ids...>)
             {
                 return {};
             }
 
             template <typename T, typename A, T... Vals>
             constexpr auto swizzle_make_self_batch()
-                -> decltype(swizzle_make_self_batch_impl<T, A, Vals...>(std::make_index_sequence<sizeof...(Vals)>()))
             {
-                return {};
+                return swizzle_make_self_batch_impl<T, A, Vals...>(std::make_index_sequence<sizeof...(Vals)>());
             }
 
             template <typename T>
@@ -1309,17 +1308,16 @@ namespace xsimd
             }
 
             template <typename T, typename A, T... Vals, std::size_t... Ids>
-            constexpr auto swizzle_make_cross_batch_impl(std::index_sequence<Ids...>)
-                -> batch_constant<T, A, swizzle_cross_val(Vals, T(Ids), static_cast<T>(sizeof...(Vals)))...>
+            constexpr batch_constant<T, A, swizzle_cross_val(Vals, T(Ids), static_cast<T>(sizeof...(Vals)))...>
+            swizzle_make_cross_batch_impl(std::index_sequence<Ids...>)
             {
                 return {};
             }
 
             template <typename T, typename A, T... Vals>
             constexpr auto swizzle_make_cross_batch()
-                -> decltype(swizzle_make_cross_batch_impl<T, A, Vals...>(std::make_index_sequence<sizeof...(Vals)>()))
             {
-                return {};
+                return swizzle_make_cross_batch_impl<T, A, Vals...>(std::make_index_sequence<sizeof...(Vals)>());
             }
         }
 
diff --git a/include/xsimd/arch/xsimd_emulated.hpp b/include/xsimd/arch/xsimd_emulated.hpp
@@ -46,7 +46,7 @@ namespace xsimd
         namespace detail
         {
             template <size_t I, class F, class... Bs>
-            auto emulated_apply(F func, Bs const&... bs) -> decltype(func(bs.data[I]...))
+            auto emulated_apply(F func, Bs const&... bs)
             {
                 return func(bs.data[I]...);
             }
@@ -58,7 +58,7 @@ namespace xsimd
             }
 
             template <class B, class F, class... Bs>
-            auto emulated_apply(F func, B const& b, Bs const&... bs) -> std::array<decltype(func(b.data[0], bs.data[0]...)), B::size>
+            auto emulated_apply(F func, B const& b, Bs const&... bs)
             {
                 return emulated_apply(func, std::make_index_sequence<B::size>(), b, bs...);
             }
diff --git a/include/xsimd/arch/xsimd_scalar.hpp b/include/xsimd/arch/xsimd_scalar.hpp
@@ -385,7 +385,7 @@ namespace xsimd
     }
 
     template <class T, class Tp>
-    XSIMD_INLINE auto mod(T const& x, Tp const& y) noexcept -> decltype(x % y)
+    XSIMD_INLINE auto mod(T const& x, Tp const& y) noexcept
     {
         return x % y;
     }
@@ -403,7 +403,7 @@ namespace xsimd
     }
 
     template <class T>
-    XSIMD_INLINE auto pos(T const& x) noexcept -> decltype(+x)
+    XSIMD_INLINE auto pos(T const& x) noexcept
     {
         return +x;
     }
@@ -627,7 +627,7 @@ namespace xsimd
 #endif
 
     template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>
-    XSIMD_INLINE auto rsqrt(const T& x) noexcept -> decltype(std::sqrt(x))
+    XSIMD_INLINE auto rsqrt(const T& x) noexcept
     {
         using float_type = decltype(std::sqrt(x));
         return static_cast<float_type>(1) / std::sqrt(x);
@@ -770,10 +770,9 @@ namespace xsimd
         return detail::ipow(x, n);
     }
 
-    template <class T0, class T1>
+    template <class T0, class T1, class = typename std::enable_if<std::is_scalar<T0>::value && std::is_floating_point<T1>::value>::type>
     XSIMD_INLINE auto
     pow(const T0& t0, const T1& t1) noexcept
-        -> typename std::enable_if<std::is_scalar<T0>::value && std::is_floating_point<T1>::value, decltype(std::pow(t0, t1))>::type
     {
         return std::pow(t0, t1);
     }
@@ -792,10 +791,9 @@ namespace xsimd
         return std::pow(t0, t1);
     }
 
-    template <class T0, class T1>
+    template <class T0, class T1, class = typename std::enable_if<std::is_scalar<T0>::value>::type>
     XSIMD_INLINE auto
     pow(const T0& t0, const std::complex<T1>& t1) noexcept
-        -> typename std::enable_if<std::is_scalar<T0>::value, decltype(std::pow(t0, t1))>::type
     {
         return std::pow(t0, t1);
     }
@@ -822,7 +820,7 @@ namespace xsimd
     }
 
     template <class T>
-    XSIMD_INLINE auto signbit(T const& v) noexcept -> decltype(bitofsign(v))
+    XSIMD_INLINE auto signbit(T const& v) noexcept
     {
         return bitofsign(v);
     }
@@ -915,10 +913,8 @@ namespace xsimd
     }
 #endif
 
-    template <class T0, class T1>
+    template <class T0, class T1, class = typename std::enable_if<std::is_scalar<T0>::value && std::is_scalar<T1>::value>::type>
     XSIMD_INLINE auto min(T0 const& self, T1 const& other) noexcept
-        -> typename std::enable_if<std::is_scalar<T0>::value && std::is_scalar<T1>::value,
-                                   typename std::decay<decltype(self > other ? other : self)>::type>::type
     {
         return self > other ? other : self;
     }
@@ -931,10 +927,8 @@ namespace xsimd
         return (self.real() < other.real()) ? (self) : (self.real() == other.real() ? (self.imag() < other.imag() ? self : other) : other);
     }
 
-    template <class T0, class T1>
+    template <class T0, class T1, class = typename std::enable_if<std::is_scalar<T0>::value && std::is_scalar<T1>::value>::type>
     XSIMD_INLINE auto max(T0 const& self, T1 const& other) noexcept
-        -> typename std::enable_if<std::is_scalar<T0>::value && std::is_scalar<T1>::value,
-                                   typename std::decay<decltype(self > other ? other : self)>::type>::type
     {
         return self < other ? other : self;
     }
diff --git a/include/xsimd/config/xsimd_arch.hpp b/include/xsimd/config/xsimd_arch.hpp
@@ -198,14 +198,14 @@ namespace xsimd
             F functor;
 
             template <class Arch, class... Tys>
-            XSIMD_INLINE auto walk_archs(arch_list<Arch>, Tys&&... args) noexcept -> decltype(functor(Arch {}, std::forward<Tys>(args)...))
+            XSIMD_INLINE auto walk_archs(arch_list<Arch>, Tys&&... args) noexcept
             {
                 assert(Arch::available() && "At least one arch must be supported during dispatch");
                 return functor(Arch {}, std::forward<Tys>(args)...);
             }
 
             template <class Arch, class ArchNext, class... Archs, class... Tys>
-            XSIMD_INLINE auto walk_archs(arch_list<Arch, ArchNext, Archs...>, Tys&&... args) noexcept -> decltype(functor(Arch {}, std::forward<Tys>(args)...))
+            XSIMD_INLINE auto walk_archs(arch_list<Arch, ArchNext, Archs...>, Tys&&... args) noexcept
             {
                 if (availables_archs.has(Arch {}))
                     return functor(Arch {}, std::forward<Tys>(args)...);
@@ -221,7 +221,7 @@ namespace xsimd
             }
 
             template <class... Tys>
-            XSIMD_INLINE auto operator()(Tys&&... args) noexcept -> decltype(functor(default_arch {}, std::forward<Tys>(args)...))
+            XSIMD_INLINE auto operator()(Tys&&... args) noexcept
             {
                 return walk_archs(ArchList {}, std::forward<Tys>(args)...);
             }
diff --git a/include/xsimd/types/xsimd_api.hpp b/include/xsimd/types/xsimd_api.hpp
@@ -83,7 +83,7 @@ namespace xsimd
      * @return the sum of \c x and \c y
      */
     template <class T, class A>
-    XSIMD_INLINE auto add(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x + y)
+    XSIMD_INLINE batch<T, A> add(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x + y;
@@ -287,7 +287,7 @@ namespace xsimd
      * @return the result of the bitwise and.
      */
     template <class T, class A>
-    XSIMD_INLINE auto bitwise_and(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x & y)
+    XSIMD_INLINE batch<T, A> bitwise_and(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x & y;
@@ -302,7 +302,7 @@ namespace xsimd
      * @return the result of the bitwise and.
      */
     template <class T, class A>
-    XSIMD_INLINE auto bitwise_and(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept -> decltype(x & y)
+    XSIMD_INLINE batch_bool<T, A> bitwise_and(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x & y;
@@ -417,7 +417,7 @@ namespace xsimd
      * @return the result of the bitwise or.
      */
     template <class T, class A>
-    XSIMD_INLINE auto bitwise_or(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x | y)
+    XSIMD_INLINE batch<T, A> bitwise_or(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x | y;
@@ -432,7 +432,7 @@ namespace xsimd
      * @return the result of the bitwise or.
      */
     template <class T, class A>
-    XSIMD_INLINE auto bitwise_or(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept -> decltype(x | y)
+    XSIMD_INLINE batch_bool<T, A> bitwise_or(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x | y;
@@ -474,7 +474,7 @@ namespace xsimd
      * @return the result of the bitwise xor.
      */
     template <class T, class A>
-    XSIMD_INLINE auto bitwise_xor(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x ^ y)
+    XSIMD_INLINE batch<T, A> bitwise_xor(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x ^ y;
@@ -489,7 +489,7 @@ namespace xsimd
      * @return the result of the bitwise xor.
      */
     template <class T, class A>
-    XSIMD_INLINE auto bitwise_xor(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept -> decltype(x ^ y)
+    XSIMD_INLINE batch_bool<T, A> bitwise_xor(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x ^ y;
@@ -699,7 +699,7 @@ namespace xsimd
      * @return the result of the division.
      */
     template <class T, class A>
-    XSIMD_INLINE auto div(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x / y)
+    XSIMD_INLINE batch<T, A> div(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x / y;
@@ -714,7 +714,7 @@ namespace xsimd
      * @return a boolean batch.
      */
     template <class T, class A>
-    XSIMD_INLINE auto eq(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x == y)
+    XSIMD_INLINE auto eq(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x == y;
@@ -729,7 +729,7 @@ namespace xsimd
      * @return a boolean batch.
      */
     template <class T, class A>
-    XSIMD_INLINE auto eq(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept -> decltype(x == y)
+    XSIMD_INLINE batch_bool<T, A> eq(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x == y;
@@ -1607,7 +1607,7 @@ namespace xsimd
      * @return the result of the modulo.
      */
     template <class T, class A>
-    XSIMD_INLINE auto mod(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x % y)
+    XSIMD_INLINE batch<T, A> mod(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x % y;
@@ -1623,7 +1623,7 @@ namespace xsimd
      * @return the result of the product.
      */
     template <class T, class A>
-    XSIMD_INLINE auto mul(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x * y)
+    XSIMD_INLINE batch<T, A> mul(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x * y;
@@ -1671,7 +1671,7 @@ namespace xsimd
      * @return a boolean batch.
      */
     template <class T, class A>
-    XSIMD_INLINE auto neq(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x != y)
+    XSIMD_INLINE auto neq(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x != y;
@@ -1686,7 +1686,7 @@ namespace xsimd
      * @return a boolean batch.
      */
     template <class T, class A>
-    XSIMD_INLINE auto neq(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept -> decltype(x != y)
+    XSIMD_INLINE batch_bool<T, A> neq(batch_bool<T, A> const& x, batch_bool<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x != y;
@@ -2572,7 +2572,7 @@ namespace xsimd
      * @return the difference between \c x and \c y
      */
     template <class T, class A>
-    XSIMD_INLINE auto sub(batch<T, A> const& x, batch<T, A> const& y) noexcept -> decltype(x - y)
+    XSIMD_INLINE batch<T, A> sub(batch<T, A> const& x, batch<T, A> const& y) noexcept
     {
         detail::static_check_supported_config<T, A>();
         return x - y;
diff --git a/include/xsimd/types/xsimd_batch_constant.hpp b/include/xsimd/types/xsimd_batch_constant.hpp

Original file line number	Diff line number	Diff line change
`@@ -222,7 +222,7 @@ namespace xsimd`
`222`	`222`	`}`
`223`	`223`
`224`	`224`	`template <class A, size_t I, class T>`
`225`		`- XSIMD_INLINE auto get(batch<std::complex<T>, A> const& self, ::xsimd::index<I>, requires_arch<common>) noexcept -> typename batch<std::complex<T>, A>::value_type`
	`225`	`+ XSIMD_INLINE typename batch<std::complex<T>, A>::value_type get(batch<std::complex<T>, A> const& self, ::xsimd::index<I>, requires_arch<common>) noexcept`
`226`	`226`	`{`
`227`	`227`	`alignas(A::alignment()) T buffer[batch<std::complex<T>, A>::size];`
`228`	`228`	`self.store_aligned(&buffer[0]);`
`@@ -246,7 +246,7 @@ namespace xsimd`
`246`	`246`	`}`
`247`	`247`
`248`	`248`	`template <class A, class T>`
`249`		`- XSIMD_INLINE auto get(batch<std::complex<T>, A> const& self, std::size_t i, requires_arch<common>) noexcept -> typename batch<std::complex<T>, A>::value_type`
	`249`	`+ XSIMD_INLINE typename batch<std::complex<T>, A>::value_type get(batch<std::complex<T>, A> const& self, std::size_t i, requires_arch<common>) noexcept`
`250`	`250`	`{`
`251`	`251`	`using T2 = typename batch<std::complex<T>, A>::value_type;`
`252`	`252`	`alignas(A::alignment()) T2 buffer[batch<std::complex<T>, A>::size];`
`@@ -268,7 +268,7 @@ namespace xsimd`
`268`	`268`	`}`
`269`	`269`
`270`	`270`	`template <class A, class T>`
`271`		`- XSIMD_INLINE auto first(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept -> typename batch<std::complex<T>, A>::value_type`
	`271`	`+ XSIMD_INLINE typename batch<std::complex<T>, A>::value_type first(batch<std::complex<T>, A> const& self, requires_arch<common>) noexcept`
`272`	`272`	`{`
`273`	`273`	`return { first(self.real(), A {}), first(self.imag(), A {}) };`
`274`	`274`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1287,17 +1287,16 @@ namespace xsimd`
`1287`	`1287`	`}`
`1288`	`1288`
`1289`	`1289`	`template <typename T, typename A, T... Vals, std::size_t... Ids>`
`1290`		`- constexpr auto swizzle_make_self_batch_impl(std::index_sequence<Ids...>)`
`1291`		`- -> batch_constant<T, A, swizzle_self_val(Vals, T(Ids), static_cast<T>(sizeof...(Vals)))...>`
	`1290`	`+ constexpr batch_constant<T, A, swizzle_self_val(Vals, T(Ids), static_cast<T>(sizeof...(Vals)))...>`
	`1291`	`+ swizzle_make_self_batch_impl(std::index_sequence<Ids...>)`
`1292`	`1292`	`{`
`1293`	`1293`	`return {};`
`1294`	`1294`	`}`
`1295`	`1295`
`1296`	`1296`	`template <typename T, typename A, T... Vals>`
`1297`	`1297`	`constexpr auto swizzle_make_self_batch()`
`1298`		`- -> decltype(swizzle_make_self_batch_impl<T, A, Vals...>(std::make_index_sequence<sizeof...(Vals)>()))`
`1299`	`1298`	`{`
`1300`		`- return {};`
	`1299`	`+ return swizzle_make_self_batch_impl<T, A, Vals...>(std::make_index_sequence<sizeof...(Vals)>());`
`1301`	`1300`	`}`
`1302`	`1301`
`1303`	`1302`	`template <typename T>`
`@@ -1309,17 +1308,16 @@ namespace xsimd`
`1309`	`1308`	`}`
`1310`	`1309`
`1311`	`1310`	`template <typename T, typename A, T... Vals, std::size_t... Ids>`
`1312`		`- constexpr auto swizzle_make_cross_batch_impl(std::index_sequence<Ids...>)`
`1313`		`- -> batch_constant<T, A, swizzle_cross_val(Vals, T(Ids), static_cast<T>(sizeof...(Vals)))...>`
	`1311`	`+ constexpr batch_constant<T, A, swizzle_cross_val(Vals, T(Ids), static_cast<T>(sizeof...(Vals)))...>`
	`1312`	`+ swizzle_make_cross_batch_impl(std::index_sequence<Ids...>)`
`1314`	`1313`	`{`
`1315`	`1314`	`return {};`
`1316`	`1315`	`}`
`1317`	`1316`
`1318`	`1317`	`template <typename T, typename A, T... Vals>`
`1319`	`1318`	`constexpr auto swizzle_make_cross_batch()`
`1320`		`- -> decltype(swizzle_make_cross_batch_impl<T, A, Vals...>(std::make_index_sequence<sizeof...(Vals)>()))`
`1321`	`1319`	`{`
`1322`		`- return {};`
	`1320`	`+ return swizzle_make_cross_batch_impl<T, A, Vals...>(std::make_index_sequence<sizeof...(Vals)>());`
`1323`	`1321`	`}`
`1324`	`1322`	`}`
`1325`	`1323`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ namespace xsimd`
`46`	`46`	`namespace detail`
`47`	`47`	`{`
`48`	`48`	`template <size_t I, class F, class... Bs>`
`49`		`- auto emulated_apply(F func, Bs const&... bs) -> decltype(func(bs.data[I]...))`
	`49`	`+ auto emulated_apply(F func, Bs const&... bs)`
`50`	`50`	`{`
`51`	`51`	`return func(bs.data[I]...);`
`52`	`52`	`}`
`@@ -58,7 +58,7 @@ namespace xsimd`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`template <class B, class F, class... Bs>`
`61`		`- auto emulated_apply(F func, B const& b, Bs const&... bs) -> std::array<decltype(func(b.data[0], bs.data[0]...)), B::size>`
	`61`	`+ auto emulated_apply(F func, B const& b, Bs const&... bs)`
`62`	`62`	`{`
`63`	`63`	`return emulated_apply(func, std::make_index_sequence<B::size>(), b, bs...);`
`64`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -385,7 +385,7 @@ namespace xsimd`
`385`	`385`	`}`
`386`	`386`
`387`	`387`	`template <class T, class Tp>`
`388`		`- XSIMD_INLINE auto mod(T const& x, Tp const& y) noexcept -> decltype(x % y)`
	`388`	`+ XSIMD_INLINE auto mod(T const& x, Tp const& y) noexcept`
`389`	`389`	`{`
`390`	`390`	`return x % y;`
`391`	`391`	`}`
`@@ -403,7 +403,7 @@ namespace xsimd`
`403`	`403`	`}`
`404`	`404`
`405`	`405`	`template <class T>`
`406`		`- XSIMD_INLINE auto pos(T const& x) noexcept -> decltype(+x)`
	`406`	`+ XSIMD_INLINE auto pos(T const& x) noexcept`
`407`	`407`	`{`
`408`	`408`	`return +x;`
`409`	`409`	`}`
`@@ -627,7 +627,7 @@ namespace xsimd`
`627`	`627`	`#endif`
`628`	`628`
`629`	`629`	`template <class T, class = typename std::enable_if<std::is_scalar<T>::value>::type>`
`630`		`- XSIMD_INLINE auto rsqrt(const T& x) noexcept -> decltype(std::sqrt(x))`
	`630`	`+ XSIMD_INLINE auto rsqrt(const T& x) noexcept`
`631`	`631`	`{`
`632`	`632`	`using float_type = decltype(std::sqrt(x));`
`633`	`633`	`return static_cast<float_type>(1) / std::sqrt(x);`
`@@ -770,10 +770,9 @@ namespace xsimd`
`770`	`770`	`return detail::ipow(x, n);`
`771`	`771`	`}`
`772`	`772`
`773`		`- template <class T0, class T1>`
	`773`	`+ template <class T0, class T1, class = typename std::enable_if<std::is_scalar<T0>::value && std::is_floating_point<T1>::value>::type>`
`774`	`774`	`XSIMD_INLINE auto`
`775`	`775`	`pow(const T0& t0, const T1& t1) noexcept`
`776`		`- -> typename std::enable_if<std::is_scalar<T0>::value && std::is_floating_point<T1>::value, decltype(std::pow(t0, t1))>::type`
`777`	`776`	`{`
`778`	`777`	`return std::pow(t0, t1);`
`779`	`778`	`}`
`@@ -792,10 +791,9 @@ namespace xsimd`
`792`	`791`	`return std::pow(t0, t1);`
`793`	`792`	`}`
`794`	`793`
`795`		`- template <class T0, class T1>`
	`794`	`+ template <class T0, class T1, class = typename std::enable_if<std::is_scalar<T0>::value>::type>`
`796`	`795`	`XSIMD_INLINE auto`
`797`	`796`	`pow(const T0& t0, const std::complex<T1>& t1) noexcept`
`798`		`- -> typename std::enable_if<std::is_scalar<T0>::value, decltype(std::pow(t0, t1))>::type`
`799`	`797`	`{`
`800`	`798`	`return std::pow(t0, t1);`
`801`	`799`	`}`
`@@ -822,7 +820,7 @@ namespace xsimd`
`822`	`820`	`}`
`823`	`821`
`824`	`822`	`template <class T>`
`825`		`- XSIMD_INLINE auto signbit(T const& v) noexcept -> decltype(bitofsign(v))`
	`823`	`+ XSIMD_INLINE auto signbit(T const& v) noexcept`
`826`	`824`	`{`
`827`	`825`	`return bitofsign(v);`
`828`	`826`	`}`
`@@ -915,10 +913,8 @@ namespace xsimd`
`915`	`913`	`}`
`916`	`914`	`#endif`
`917`	`915`
`918`		`- template <class T0, class T1>`
	`916`	`+ template <class T0, class T1, class = typename std::enable_if<std::is_scalar<T0>::value && std::is_scalar<T1>::value>::type>`
`919`	`917`	`XSIMD_INLINE auto min(T0 const& self, T1 const& other) noexcept`
`920`		`- -> typename std::enable_if<std::is_scalar<T0>::value && std::is_scalar<T1>::value,`
`921`		`- typename std::decay<decltype(self > other ? other : self)>::type>::type`
`922`	`918`	`{`
`923`	`919`	`return self > other ? other : self;`
`924`	`920`	`}`
`@@ -931,10 +927,8 @@ namespace xsimd`
`931`	`927`	`return (self.real() < other.real()) ? (self) : (self.real() == other.real() ? (self.imag() < other.imag() ? self : other) : other);`
`932`	`928`	`}`
`933`	`929`
`934`		`- template <class T0, class T1>`
	`930`	`+ template <class T0, class T1, class = typename std::enable_if<std::is_scalar<T0>::value && std::is_scalar<T1>::value>::type>`
`935`	`931`	`XSIMD_INLINE auto max(T0 const& self, T1 const& other) noexcept`
`936`		`- -> typename std::enable_if<std::is_scalar<T0>::value && std::is_scalar<T1>::value,`
`937`		`- typename std::decay<decltype(self > other ? other : self)>::type>::type`
`938`	`932`	`{`
`939`	`933`	`return self < other ? other : self;`
`940`	`934`	`}`
Original file line number	Diff line number	Diff line change
`@@ -198,14 +198,14 @@ namespace xsimd`
`198`	`198`	`F functor;`
`199`	`199`
`200`	`200`	`template <class Arch, class... Tys>`
`201`		`- XSIMD_INLINE auto walk_archs(arch_list<Arch>, Tys&&... args) noexcept -> decltype(functor(Arch {}, std::forward<Tys>(args)...))`
	`201`	`+ XSIMD_INLINE auto walk_archs(arch_list<Arch>, Tys&&... args) noexcept`
`202`	`202`	`{`
`203`	`203`	`assert(Arch::available() && "At least one arch must be supported during dispatch");`
`204`	`204`	`return functor(Arch {}, std::forward<Tys>(args)...);`
`205`	`205`	`}`
`206`	`206`
`207`	`207`	`template <class Arch, class ArchNext, class... Archs, class... Tys>`
`208`		`- XSIMD_INLINE auto walk_archs(arch_list<Arch, ArchNext, Archs...>, Tys&&... args) noexcept -> decltype(functor(Arch {}, std::forward<Tys>(args)...))`
	`208`	`+ XSIMD_INLINE auto walk_archs(arch_list<Arch, ArchNext, Archs...>, Tys&&... args) noexcept`
`209`	`209`	`{`
`210`	`210`	`if (availables_archs.has(Arch {}))`
`211`	`211`	`return functor(Arch {}, std::forward<Tys>(args)...);`
`@@ -221,7 +221,7 @@ namespace xsimd`
`221`	`221`	`}`
`222`	`222`
`223`	`223`	`template <class... Tys>`
`224`		`- XSIMD_INLINE auto operator()(Tys&&... args) noexcept -> decltype(functor(default_arch {}, std::forward<Tys>(args)...))`
	`224`	`+ XSIMD_INLINE auto operator()(Tys&&... args) noexcept`
`225`	`225`	`{`
`226`	`226`	`return walk_archs(ArchList {}, std::forward<Tys>(args)...);`
`227`	`227`	`}`