Generate a swizzle-friendly mask during generic reduction

It changes nothing for clang which has a nice shuffle optimizer, but it
does help gcc a lot.

Somehow related to #1132

Author: serge-sans-paille

include/xsimd/arch/common/xsimd_common_math.hpp

@@ -2110,22 +2110,22 @@ namespace xsimd
             {
                 static constexpr T get(T i, T)
                 {
-                    return i >= N ? (i % 2) : i + N;
+                    return i < N ? (i + N) : ((i % N) + N);
                 }
             };
 
             template <class Op, class A, class T>
-            XSIMD_INLINE T reduce(Op, batch<T, A> const& self, std::integral_constant<unsigned, 1>) noexcept
+            XSIMD_INLINE T reduce(Op, batch<T, A> const& self, std::integral_constant<unsigned, 1>, requires_arch<common>) noexcept
             {
                 return ::xsimd::kernel::first(self, A {});
             }
 
             template <class Op, class A, class T, unsigned Lvl>
-            XSIMD_INLINE T reduce(Op op, batch<T, A> const& self, std::integral_constant<unsigned, Lvl>) noexcept
+            XSIMD_INLINE T reduce(Op op, batch<T, A> const& self, std::integral_constant<unsigned, Lvl>, requires_arch<common>) noexcept
             {
                 using index_type = as_unsigned_integer_t<T>;
                 batch<T, A> split = swizzle(self, make_batch_constant<index_type, split_high<index_type, Lvl / 2>, A>());
-                return reduce(op, op(split, self), std::integral_constant<unsigned, Lvl / 2>());
+                return reduce(op, op(split, self), std::integral_constant<unsigned, Lvl / 2>(), A {});
             }
         }
 
@@ -2135,7 +2135,7 @@ namespace xsimd
         {
             return detail::reduce([](batch<T, A> const& x, batch<T, A> const& y)
                                   { return max(x, y); },
-                                  self, std::integral_constant<unsigned, batch<T, A>::size>());
+                                  self, std::integral_constant<unsigned, batch<T, A>::size>(), A {});
         }
 
         // reduce_min
@@ -2144,7 +2144,8 @@ namespace xsimd
         {
             return detail::reduce([](batch<T, A> const& x, batch<T, A> const& y)
                                   { return min(x, y); },
-                                  self, std::integral_constant<unsigned, batch<T, A>::size>());
+                                  self, std::integral_constant<unsigned, batch<T, A>::size>()),
+                   A {};
         }
 
         // remainder

include/xsimd/types/xsimd_api.hpp

@@ -1834,7 +1834,7 @@ namespace xsimd
     XSIMD_INLINE T reduce(F&& f, batch<T, A> const& x) noexcept
     {
         detail::static_check_supported_config<T, A>();
-        return kernel::detail::reduce(std::forward<F>(f), x, std::integral_constant<unsigned, batch<T, A>::size>());
+        return kernel::detail::reduce(std::forward<F>(f), x, std::integral_constant<unsigned, batch<T, A>::size>(), A {});
     }
 
     /**