diff --git a/include/xsimd/arch/xsimd_rvv.hpp b/include/xsimd/arch/xsimd_rvv.hpp
index 6d1eae59d..12ae39280 100644
--- a/include/xsimd/arch/xsimd_rvv.hpp
+++ b/include/xsimd/arch/xsimd_rvv.hpp
@@ -16,6 +16,7 @@
 #include "../config/xsimd_macros.hpp"
 #include "../types/xsimd_batch_constant.hpp"
 #include "../types/xsimd_rvv_register.hpp"
+#include "../types/xsimd_utils.hpp"
 #include "../utils/xsimd_type_traits.hpp"
 #include "./xsimd_constants.hpp"
 
@@ -288,8 +289,6 @@ namespace xsimd
     {
         namespace detail
         {
-            template <class T>
-            using rvv_fix_char_t = types::detail::rvv_fix_char_t<T>;
             template <class T, size_t Width = XSIMD_RVV_BITS>
             using rvv_reg_t = types::detail::rvv_reg_t<T, Width>;
             template <class T, size_t Width = XSIMD_RVV_BITS>
@@ -375,26 +374,6 @@ namespace xsimd
                     index = __riscv_vsll(index, shift, batch<T, A>::size);
                 return __riscv_vadd(index, T(offset), batch<T, A>::size);
             }
-
-            // enable for signed integers
-            template <class T>
-            using rvv_enable_signed_int_t = std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, int>;
-
-            // enable for unsigned integers
-            template <class T>
-            using rvv_enable_unsigned_int_t = std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, int>;
-
-            // enable for floating points
-            template <class T>
-            using rvv_enable_floating_point_t = std::enable_if_t<std::is_floating_point<T>::value, int>;
-
-            // enable for signed integers or floating points
-            template <class T>
-            using rvv_enable_signed_int_or_floating_point_t = std::enable_if_t<std::is_signed<T>::value, int>;
-
-            // enable for all RVE supported types
-            template <class T>
-            using rvv_enable_all_t = std::enable_if_t<std::is_arithmetic<T>::value, int>;
         } // namespace detail
 
         /********************
@@ -409,7 +388,7 @@ namespace xsimd
                 // A bit of a dance, here, because rvvmv_splat has no other
                 // argument from which to deduce type, and T=char is not
                 // supported.
-                detail::rvv_fix_char_t<T> arg_not_char(arg);
+                project_num_t<T> arg_not_char(arg);
                 const auto splat = detail::rvvmv_splat(arg_not_char);
                 return detail::rvv_reg_t<T, Width>(splat.get_bytes(), types::detail::XSIMD_RVV_BITCAST);
             }
@@ -432,13 +411,13 @@ namespace xsimd
             XSIMD_RVV_OVERLOAD(rvvse, (__riscv_vse XSIMD_RVV_S _v_ XSIMD_RVV_TSM), , void(T*, vec))
         }
 
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<rvv>) noexcept
         {
-            return detail::rvvle(reinterpret_cast<detail::rvv_fix_char_t<T> const*>(src));
+            return detail::rvvle(reinterpret_cast<project_num_t<T> const*>(src));
         }
 
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> load_unaligned(T const* src, convert<T>, requires_arch<rvv>) noexcept
         {
             return load_aligned<A>(src, convert<T>(), rvv {});
@@ -485,7 +464,7 @@ namespace xsimd
                 return __riscv_vslidedown(vv, vv.vl / 2, vv.vl);
             }
 
-            template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+            template <class A, class T, detail::enable_floating_point_t<T> = 0>
             XSIMD_INLINE batch<std::complex<T>, A> load_complex(batch<T, A> const& lo, batch<T, A> const& hi, requires_arch<rvv>) noexcept
             {
                 const auto real_index = vindex<A, as_unsigned_integer_t<T>, 0, 1>();
@@ -502,13 +481,13 @@ namespace xsimd
          * Store *
          *********/
 
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE void store_aligned(T* dst, batch<T, A> const& src, requires_arch<rvv>) noexcept
         {
-            detail::rvvse(reinterpret_cast<detail::rvv_fix_char_t<T>*>(dst), src);
+            detail::rvvse(reinterpret_cast<project_num_t<T>*>(dst), src);
         }
 
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE void store_unaligned(T* dst, batch<T, A> const& src, requires_arch<rvv>) noexcept
         {
             store_aligned<A>(dst, src, rvv {});
@@ -536,7 +515,7 @@ namespace xsimd
         {
             using UU = as_unsigned_integer_t<U>;
             const auto uindex = detail::rvv_to_unsigned_batch(index);
-            auto* base = reinterpret_cast<detail::rvv_fix_char_t<T>*>(dst);
+            auto* base = reinterpret_cast<project_num_t<T>*>(dst);
             // or rvvsuxei
             const auto bi = detail::rvvmul_splat(uindex, sizeof(T));
             detail::rvvsoxei(base, bi, vals);
@@ -548,7 +527,7 @@ namespace xsimd
         {
             using UU = as_unsigned_integer_t<U>;
             const auto uindex = detail::rvv_to_unsigned_batch(index);
-            auto const* base = reinterpret_cast<detail::rvv_fix_char_t<T> const*>(src);
+            auto const* base = reinterpret_cast<project_num_t<T> const*>(src);
             // or rvvluxei
             const auto bi = detail::rvvmul_splat(uindex, sizeof(T));
             return detail::rvvloxei(base, bi);
@@ -639,7 +618,7 @@ namespace xsimd
         } // namespace detail
 
         // add
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> add(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvadd(lhs, rhs);
@@ -653,7 +632,7 @@ namespace xsimd
         }
 
         // sub
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> sub(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvsub(lhs, rhs);
@@ -667,35 +646,35 @@ namespace xsimd
         }
 
         // mul
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> mul(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvmul(lhs, rhs);
         }
 
         // div
-        template <class A, class T, typename detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, typename detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> div(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvdiv(lhs, rhs);
         }
 
         // max
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> max(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvmax(lhs, rhs);
         }
 
         // min
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> min(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvmin(lhs, rhs);
         }
 
         // neg
-        template <class A, class T, detail::rvv_enable_unsigned_int_t<T> = 0>
+        template <class A, class T, detail::enable_unsigned_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> neg(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             using S = as_signed_integer_t<T>;
@@ -704,27 +683,27 @@ namespace xsimd
             return detail::rvvreinterpret<T>(result);
         }
 
-        template <class A, class T, detail::rvv_enable_signed_int_or_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_signed_numeral_t<T> = 0>
         XSIMD_INLINE batch<T, A> neg(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             return detail::rvvneg(arg);
         }
 
         // abs
-        template <class A, class T, detail::rvv_enable_unsigned_int_t<T> = 0>
+        template <class A, class T, detail::enable_unsigned_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> abs(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             return arg;
         }
 
-        template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> abs(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             return detail::rvvabs(arg);
         }
 
         // fma: x * y + z
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> fma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<rvv>) noexcept
         {
             // also detail::rvvmadd(x, y, z);
@@ -732,7 +711,7 @@ namespace xsimd
         }
 
         // fnma: z - x * y
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> fnma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<rvv>) noexcept
         {
             // also detail::rvvnmsub(x, y, z);
@@ -740,7 +719,7 @@ namespace xsimd
         }
 
         // fms: x * y - z
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> fms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<rvv>) noexcept
         {
             // also vfmsac(z, x, y), but lacking integer version
@@ -749,7 +728,7 @@ namespace xsimd
         }
 
         // fnms: - x * y - z
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> fnms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<rvv>) noexcept
         {
             // also vfnmacc(z, x, y), but lacking integer version
@@ -782,7 +761,7 @@ namespace xsimd
             return detail::rvvand(lhs, rhs);
         }
 
-        template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_and(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             const auto lhs_bits = detail::rvv_to_unsigned_batch(lhs);
@@ -791,7 +770,7 @@ namespace xsimd
             return detail::rvvreinterpret<T>(result_bits);
         }
 
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_and(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvmand(lhs, rhs);
@@ -805,7 +784,7 @@ namespace xsimd
             return detail::rvvand(lhs, not_rhs);
         }
 
-        template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_andnot(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             const auto lhs_bits = detail::rvv_to_unsigned_batch(lhs);
@@ -815,7 +794,7 @@ namespace xsimd
             return detail::rvvreinterpret<T>(result_bits);
         }
 
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvmandn(lhs, rhs);
@@ -828,7 +807,7 @@ namespace xsimd
             return detail::rvvor(lhs, rhs);
         }
 
-        template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_or(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             const auto lhs_bits = detail::rvv_to_unsigned_batch(lhs);
@@ -837,7 +816,7 @@ namespace xsimd
             return detail::rvvreinterpret<T>(result_bits);
         }
 
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_or(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvmor(lhs, rhs);
@@ -850,7 +829,7 @@ namespace xsimd
             return detail::rvvxor(lhs, rhs);
         }
 
-        template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_xor(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             const auto lhs_bits = detail::rvv_to_unsigned_batch(lhs);
@@ -859,7 +838,7 @@ namespace xsimd
             return detail::rvvreinterpret<T>(result_bits);
         }
 
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_xor(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvmxor(lhs, rhs);
@@ -872,7 +851,7 @@ namespace xsimd
             return detail::rvvnot(arg);
         }
 
-        template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_not(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             const auto arg_bits = detail::rvv_to_unsigned_batch(arg);
@@ -880,7 +859,7 @@ namespace xsimd
             return detail::rvvreinterpret<T>(result_bits);
         }
 
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_not(batch_bool<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             return detail::rvvmnot(arg);
@@ -967,7 +946,7 @@ namespace xsimd
             }
         }
         // reduce_add
-        template <class A, class T, class V = typename batch<T, A>::value_type, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, class V = typename batch<T, A>::value_type, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE V reduce_add(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             const auto zero = detail::broadcast<T, types::detail::rvv_width_m1>(T(0));
@@ -976,7 +955,7 @@ namespace xsimd
         }
 
         // reduce_max
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE T reduce_max(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             const auto lowest = detail::broadcast<T, types::detail::rvv_width_m1>(std::numeric_limits<T>::lowest());
@@ -985,7 +964,7 @@ namespace xsimd
         }
 
         // reduce_min
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE T reduce_min(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             const auto max = detail::broadcast<T, types::detail::rvv_width_m1>(std::numeric_limits<T>::max());
@@ -994,7 +973,7 @@ namespace xsimd
         }
 
         // haddp
-        template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> haddp(const batch<T, A>* row, requires_arch<rvv>) noexcept
         {
             constexpr std::size_t size = batch<T, A>::size;
@@ -1012,13 +991,13 @@ namespace xsimd
          ***************/
 
         // eq
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> eq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvmseq(lhs, rhs);
         }
 
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> eq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             const auto neq_result = detail::rvvmxor(lhs, rhs);
@@ -1026,41 +1005,41 @@ namespace xsimd
         }
 
         // neq
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> neq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvmsne(lhs, rhs);
         }
 
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> neq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvmxor(lhs, rhs);
         }
 
         // lt
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> lt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvmslt(lhs, rhs);
         }
 
         // le
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> le(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvmsle(lhs, rhs);
         }
 
         // gt
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> gt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvmsgt(lhs, rhs);
         }
 
         // ge
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> ge(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             return detail::rvvmsge(lhs, rhs);
@@ -1116,7 +1095,7 @@ namespace xsimd
 
         // extract_pair
 
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, size_t n, requires_arch<rvv>) noexcept
         {
             const auto tmp = detail::rvvslidedown(rhs, n);
@@ -1124,7 +1103,7 @@ namespace xsimd
         }
 
         // select
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& a, batch<T, A> const& b, requires_arch<rvv>) noexcept
         {
             return detail::rvvmerge(b, a, cond);
@@ -1137,7 +1116,7 @@ namespace xsimd
         }
 
         // zip_lo
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             const auto index = detail::vindex<A, as_unsigned_integer_t<T>, 0, -1>();
@@ -1148,7 +1127,7 @@ namespace xsimd
         }
 
         // zip_hi
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<rvv>) noexcept
         {
             const auto index = detail::vindex<A, as_unsigned_integer_t<T>, batch<T, A>::size / 2, -1>();
@@ -1159,7 +1138,7 @@ namespace xsimd
         }
 
         // store_complex
-        template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::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<rvv>) noexcept
         {
             const auto lo = zip_lo(src.real(), src.imag());
@@ -1169,7 +1148,7 @@ namespace xsimd
             store_aligned(buf + lo.size, hi, rvv {});
         }
 
-        template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE void store_complex_unaligned(std::complex<T>* dst, batch<std::complex<T>, A> const& src, requires_arch<rvv>) noexcept
         {
             store_complex_aligned(dst, src, rvv {});
@@ -1187,7 +1166,7 @@ namespace xsimd
         }
 
         // rsqrt
-        template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> rsqrt(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             auto approx = detail::rvvfrsqrt7(arg);
@@ -1196,14 +1175,14 @@ namespace xsimd
         }
 
         // sqrt
-        template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> sqrt(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             return detail::rvvfsqrt(arg);
         }
 
         // reciprocal
-        template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> reciprocal(const batch<T, A>& arg, requires_arch<rvv>) noexcept
         {
             return detail::rvvfrec7(arg);
@@ -1278,20 +1257,20 @@ namespace xsimd
         }
 
         // first
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE T first(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             return detail::rvvmv_lane0(arg);
         }
 
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE std::complex<T> first(batch<std::complex<T>, A> const& arg, requires_arch<rvv>) noexcept
         {
             return std::complex<T> { detail::rvvmv_lane0(arg.real()), detail::rvvmv_lane0(arg.imag()) };
         }
 
         // insert
-        template <class A, class T, size_t I, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, size_t I, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> insert(batch<T, A> const& arg, T val, index<I>, requires_arch<rvv>) noexcept
         {
             const auto mask = detail::pmask<T, A::width>(uint64_t(1) << I);
@@ -1299,14 +1278,14 @@ namespace xsimd
         }
 
         // get
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE T get(batch<T, A> const& arg, size_t i, requires_arch<rvv>) noexcept
         {
             const auto tmp = detail::rvvslidedown(arg, i);
             return detail::rvvmv_lane0(tmp);
         }
 
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE std::complex<T> get(batch<std::complex<T>, A> const& arg, size_t i, requires_arch<rvv>) noexcept
         {
             const auto tmpr = detail::rvvslidedown(arg.real(), i);
@@ -1315,28 +1294,28 @@ namespace xsimd
         }
 
         // all
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE bool all(batch_bool<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             return detail::rvvcpop(arg) == batch_bool<T, A>::size;
         }
 
         // any
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE bool any(batch_bool<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             return detail::rvvcpop(arg) > 0;
         }
 
         // bitwise_cast
-        template <class A, class T, class R, detail::rvv_enable_all_t<T> = 0, detail::rvv_enable_all_t<R> = 0>
+        template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_arithmetic_t<R> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<rvv>) noexcept
         {
             return detail::rvv_reg_t<R, A::width>(arg.data.get_bytes(), types::detail::XSIMD_RVV_BITCAST);
         }
 
         // batch_bool_cast
-        template <class A, class T_out, class T_in, detail::rvv_enable_all_t<T_in> = 0>
+        template <class A, class T_out, class T_in, detail::enable_arithmetic_t<T_in> = 0>
         XSIMD_INLINE batch_bool<T_out, A> batch_bool_cast(batch_bool<T_in, A> const& arg, batch_bool<T_out, A> const&, requires_arch<rvv>) noexcept
         {
             using intermediate_t = typename detail::rvv_bool_t<T_out>;
@@ -1344,7 +1323,7 @@ namespace xsimd
         }
 
         // from_bool
-        template <class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             const auto zero = broadcast<A>(T(0), rvv {});
@@ -1382,7 +1361,7 @@ namespace xsimd
         }
 
         // slide_left
-        template <size_t N, class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <size_t N, class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> slide_left(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             const auto zero = broadcast<A>(uint8_t(0), rvv {});
@@ -1391,7 +1370,7 @@ namespace xsimd
         }
 
         // slide_right
-        template <size_t N, class A, class T, detail::rvv_enable_all_t<T> = 0>
+        template <size_t N, class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> slide_right(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             using reg_t = detail::rvv_reg_t<T, A::width>;
@@ -1400,7 +1379,7 @@ namespace xsimd
         }
 
         // isnan
-        template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> isnan(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             return !(arg == arg);
@@ -1433,7 +1412,7 @@ namespace xsimd
         }
 
         // round
-        template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> round(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             // Round ties away from zero.
@@ -1442,7 +1421,7 @@ namespace xsimd
         }
 
         // nearbyint
-        template <class A, class T, detail::rvv_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> nearbyint(batch<T, A> const& arg, requires_arch<rvv>) noexcept
         {
             // Round according to current rounding mode.
diff --git a/include/xsimd/arch/xsimd_sve.hpp b/include/xsimd/arch/xsimd_sve.hpp
index 6636f4c37..05109dfd1 100644
--- a/include/xsimd/arch/xsimd_sve.hpp
+++ b/include/xsimd/arch/xsimd_sve.hpp
@@ -59,26 +59,10 @@ namespace xsimd
             template <class T>
             XSIMD_INLINE uint64_t sve_pcount(svbool_t p) noexcept { return sve_pcount_impl(p, index<sizeof(T)> {}); }
 
-            // enable for signed integers
-            template <class T>
-            using sve_enable_signed_int_t = std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, int>;
-
-            // enable for unsigned integers
-            template <class T>
-            using sve_enable_unsigned_int_t = std::enable_if_t<std::is_integral<T>::value && !std::is_signed<T>::value, int>;
-
-            // enable for floating points
-            template <class T>
-            using sve_enable_floating_point_t = std::enable_if_t<std::is_floating_point<T>::value, int>;
-
             // enable for signed integers or floating points
             template <class T>
             using sve_enable_signed_int_or_floating_point_t = std::enable_if_t<std::is_signed<T>::value, int>;
 
-            // enable for all SVE supported types
-            template <class T>
-            using sve_enable_all_t = std::enable_if_t<std::is_arithmetic<T>::value, int>;
-
             // `sizeless` is the matching sizeless SVE type. xsimd stores SVE
             // vectors as fixed-size attributed types (arm_sve_vector_bits),
             // which clang treats as implicitly convertible to every sizeless
@@ -88,55 +72,33 @@ namespace xsimd
             // 1-vector candidate.
             template <class T>
             using sve_sizeless_t = xsimd::types::detail::sizeless_sve_vector_type<T>;
-
-            // Remap integer Ts to their matching fixed-width counterpart
-            // so svld1/svst1 see the pointer type their overload set expects;
-            // pass non-integer Ts through unchanged.
-            template <class T, bool IsInt = std::is_integral<std::decay_t<T>>::value>
-            struct sve_fix_integer_impl
-            {
-                using type = T;
-            };
-            template <class T>
-            struct sve_fix_integer_impl<T, true>
-            {
-                using type = std::conditional_t<std::is_signed<T>::value,
-                                                sized_int_t<sizeof(T)>, sized_uint_t<sizeof(T)>>;
-            };
-
-            // SVE load/store intrinsics are overloaded on these pointer for integer
-            // types, but some platform have explicit different types between
-            // `long` vs `long long` or `char` vs `int8_t`.
-            // We remap the type to avoid these.
-            template <class T>
-            using sve_fix_char_t = typename sve_fix_integer_impl<T>::type;
         } // namespace detail
 
         /*********
          * Load *
          *********/
 
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> load_aligned(T const* src, convert<T>, requires_arch<sve>) noexcept
         {
-            return svld1(detail::sve_ptrue<T>(), reinterpret_cast<detail::sve_fix_char_t<T> const*>(src));
+            return svld1(detail::sve_ptrue<T>(), reinterpret_cast<project_num_t<T> const*>(src));
         }
 
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> load_unaligned(T const* src, convert<T>, requires_arch<sve>) noexcept
         {
             return load_aligned<A>(src, convert<T>(), sve {});
         }
 
         // load_masked
-        template <class A, class T, bool... Values, class Mode, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, bool... Values, class Mode, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> load_masked(T const* mem, batch_bool_constant<float, A, Values...>, Mode, requires_arch<sve>) noexcept
         {
-            return svld1(detail::sve_pmask<Values...>(), reinterpret_cast<detail::sve_fix_char_t<T> const*>(mem));
+            return svld1(detail::sve_pmask<Values...>(), reinterpret_cast<project_num_t<T> const*>(mem));
         }
 
         // load_complex
-        template <class A, class T, detail::sve_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<std::complex<T>, A> load_complex_aligned(std::complex<T> const* mem, convert<std::complex<T>>, requires_arch<sve>) noexcept
         {
             const T* buf = reinterpret_cast<const T*>(mem);
@@ -146,7 +108,7 @@ namespace xsimd
             return batch<std::complex<T>, A> { real, imag };
         }
 
-        template <class A, class T, detail::sve_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<std::complex<T>, A> load_complex_unaligned(std::complex<T> const* mem, convert<std::complex<T>>, requires_arch<sve>) noexcept
         {
             return load_complex_aligned<A>(mem, convert<std::complex<T>> {}, sve {});
@@ -156,20 +118,20 @@ namespace xsimd
          * Store *
          *********/
 
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE void store_aligned(T* dst, batch<T, A> const& src, requires_arch<sve>) noexcept
         {
-            svst1(detail::sve_ptrue<T>(), reinterpret_cast<detail::sve_fix_char_t<T>*>(dst), src);
+            svst1(detail::sve_ptrue<T>(), reinterpret_cast<project_num_t<T>*>(dst), src);
         }
 
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE void store_unaligned(T* dst, batch<T, A> const& src, requires_arch<sve>) noexcept
         {
             store_aligned<A>(dst, src, sve {});
         }
 
         // store_complex
-        template <class A, class T, detail::sve_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::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 = std::conditional_t<(sizeof(T) == 4), svfloat32x2_t, svfloat64x2_t>;
@@ -180,7 +142,7 @@ namespace xsimd
             svst2(detail::sve_ptrue<T>(), buf, tmp);
         }
 
-        template <class A, class T, detail::sve_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE void store_complex_unaligned(std::complex<T>* dst, batch<std::complex<T>, A> const& src, requires_arch<sve>) noexcept
         {
             store_complex_aligned(dst, src, sve {});
@@ -275,7 +237,7 @@ namespace xsimd
             return svdup_n_f64(arg);
         }
 
-        template <class A, class T, detail::sve_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> broadcast(T val, requires_arch<sve>) noexcept
         {
             return broadcast<sve>(val, sve {});
@@ -286,7 +248,7 @@ namespace xsimd
          **************/
 
         // add
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> add(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svadd_x(detail::sve_ptrue<T>(), lhs, rhs);
@@ -300,7 +262,7 @@ namespace xsimd
         }
 
         // sub
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> sub(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svsub_x(detail::sve_ptrue<T>(), lhs, rhs);
@@ -314,7 +276,7 @@ namespace xsimd
         }
 
         // mul
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> mul(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svmul_x(detail::sve_ptrue<T>(), lhs, rhs);
@@ -328,14 +290,14 @@ namespace xsimd
         }
 
         // max
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> max(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svmax_x(detail::sve_ptrue<T>(), lhs, rhs);
         }
 
         // min
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> min(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svmin_x(detail::sve_ptrue<T>(), lhs, rhs);
@@ -366,48 +328,48 @@ namespace xsimd
             return svreinterpret_u64(svneg_x(detail::sve_ptrue<T>(), svreinterpret_s64(static_cast<detail::sve_sizeless_t<T>>(arg))));
         }
 
-        template <class A, class T, detail::sve_enable_signed_int_or_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_signed_numeral_t<T> = 0>
         XSIMD_INLINE batch<T, A> neg(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
             return svneg_x(detail::sve_ptrue<T>(), arg);
         }
 
         // abs
-        template <class A, class T, detail::sve_enable_unsigned_int_t<T> = 0>
+        template <class A, class T, detail::enable_unsigned_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> abs(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
             return arg;
         }
 
-        template <class A, class T, detail::sve_enable_signed_int_or_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_signed_numeral_t<T> = 0>
         XSIMD_INLINE batch<T, A> abs(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
             return svabs_x(detail::sve_ptrue<T>(), arg);
         }
 
         // fma: x * y + z
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> fma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<sve>) noexcept
         {
             return svmad_x(detail::sve_ptrue<T>(), x, y, z);
         }
 
         // fnma: z - x * y
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> fnma(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<sve>) noexcept
         {
             return svmsb_x(detail::sve_ptrue<T>(), x, y, z);
         }
 
         // fms: x * y - z
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> fms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<sve>) noexcept
         {
             return -fnma(x, y, z, sve {});
         }
 
         // fnms: - x * y - z
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> fnms(batch<T, A> const& x, batch<T, A> const& y, batch<T, A> const& z, requires_arch<sve>) noexcept
         {
             return -fma(x, y, z, sve {});
@@ -442,7 +404,7 @@ namespace xsimd
             return svreinterpret_f64(result_bits);
         }
 
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_and(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svand_z(detail::sve_ptrue<T>(), lhs, rhs);
@@ -473,7 +435,7 @@ namespace xsimd
             return svreinterpret_f64(result_bits);
         }
 
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_andnot(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svbic_z(detail::sve_ptrue<T>(), lhs, rhs);
@@ -504,7 +466,7 @@ namespace xsimd
             return svreinterpret_f64(result_bits);
         }
 
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_or(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svorr_z(detail::sve_ptrue<T>(), lhs, rhs);
@@ -535,7 +497,7 @@ namespace xsimd
             return svreinterpret_f64(result_bits);
         }
 
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_xor(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return sveor_z(detail::sve_ptrue<T>(), lhs, rhs);
@@ -564,7 +526,7 @@ namespace xsimd
             return svreinterpret_f64(result_bits);
         }
 
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> bitwise_not(batch_bool<T, A> const& arg, requires_arch<sve>) noexcept
         {
             return svnot_z(detail::sve_ptrue<T>(), arg);
@@ -623,7 +585,7 @@ namespace xsimd
         }
 
         // bitwise_rshift
-        template <class A, class T, detail::sve_enable_unsigned_int_t<T> = 0>
+        template <class A, class T, detail::enable_unsigned_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& arg, int n, requires_arch<sve>) noexcept
         {
             constexpr std::size_t size = sizeof(typename batch<T, A>::value_type) * 8;
@@ -631,13 +593,13 @@ namespace xsimd
             return svlsr_x(detail::sve_ptrue<T>(), arg, static_cast<T>(n));
         }
 
-        template <class A, class T, detail::sve_enable_unsigned_int_t<T> = 0>
+        template <class A, class T, detail::enable_unsigned_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svlsr_x(detail::sve_ptrue<T>(), lhs, rhs);
         }
 
-        template <class A, class T, detail::sve_enable_signed_int_t<T> = 0>
+        template <class A, class T, detail::enable_signed_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& arg, int n, requires_arch<sve>) noexcept
         {
             constexpr std::size_t size = sizeof(typename batch<T, A>::value_type) * 8;
@@ -645,7 +607,7 @@ namespace xsimd
             return svasr_x(detail::sve_ptrue<T>(), arg, static_cast<as_unsigned_integer_t<T>>(n));
         }
 
-        template <class A, class T, detail::sve_enable_signed_int_t<T> = 0>
+        template <class A, class T, detail::enable_signed_integral_t<T> = 0>
         XSIMD_INLINE batch<T, A> bitwise_rshift(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svasr_x(detail::sve_ptrue<T>(), lhs, detail::sve_to_unsigned_batch<A, T>(rhs));
@@ -656,7 +618,7 @@ namespace xsimd
          **************/
 
         // reduce_add
-        template <class A, class T, class V = typename batch<T, A>::value_type, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, class V = typename batch<T, A>::value_type, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE V reduce_add(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
             // sve integer reduction results are promoted to 64 bits
@@ -664,21 +626,21 @@ namespace xsimd
         }
 
         // reduce_max
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE T reduce_max(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
             return svmaxv(detail::sve_ptrue<T>(), arg);
         }
 
         // reduce_min
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE T reduce_min(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
             return svminv(detail::sve_ptrue<T>(), arg);
         }
 
         // haddp
-        template <class A, class T, detail::sve_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> haddp(const batch<T, A>* row, requires_arch<sve>) noexcept
         {
             constexpr std::size_t size = batch<T, A>::size;
@@ -695,13 +657,13 @@ namespace xsimd
          ***************/
 
         // eq
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> eq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svcmpeq(detail::sve_ptrue<T>(), lhs, rhs);
         }
 
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> eq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             const auto neq_result = sveor_z(detail::sve_ptrue<T>(), lhs, rhs);
@@ -709,41 +671,41 @@ namespace xsimd
         }
 
         // neq
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> neq(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svcmpne(detail::sve_ptrue<T>(), lhs, rhs);
         }
 
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> neq(batch_bool<T, A> const& lhs, batch_bool<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return sveor_z(detail::sve_ptrue<T>(), lhs, rhs);
         }
 
         // lt
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> lt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svcmplt(detail::sve_ptrue<T>(), lhs, rhs);
         }
 
         // le
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> le(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svcmple(detail::sve_ptrue<T>(), lhs, rhs);
         }
 
         // gt
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> gt(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svcmpgt(detail::sve_ptrue<T>(), lhs, rhs);
         }
 
         // ge
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> ge(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svcmpge(detail::sve_ptrue<T>(), lhs, rhs);
@@ -754,7 +716,7 @@ namespace xsimd
          ***************/
 
         //  rotate_left
-        template <size_t N, class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <size_t N, class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> rotate_left(batch<T, A> const& a, requires_arch<sve>) noexcept
         {
             return svext(a, a, N);
@@ -835,7 +797,7 @@ namespace xsimd
             }
         }
 
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> extract_pair(batch<T, A> const& lhs, batch<T, A> const& rhs, std::size_t n, requires_arch<sve>) noexcept
         {
             constexpr std::size_t size = batch<T, A>::size;
@@ -844,7 +806,7 @@ namespace xsimd
         }
 
         // select
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> select(batch_bool<T, A> const& cond, batch<T, A> const& a, batch<T, A> const& b, requires_arch<sve>) noexcept
         {
             return svsel(cond, static_cast<detail::sve_sizeless_t<T>>(a), static_cast<detail::sve_sizeless_t<T>>(b));
@@ -857,14 +819,14 @@ namespace xsimd
         }
 
         // zip_lo
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> zip_lo(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svzip1(lhs, rhs);
         }
 
         // zip_hi
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> zip_hi(batch<T, A> const& lhs, batch<T, A> const& rhs, requires_arch<sve>) noexcept
         {
             return svzip2(lhs, rhs);
@@ -875,21 +837,21 @@ namespace xsimd
          *****************************/
 
         // rsqrt
-        template <class A, class T, detail::sve_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> rsqrt(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
             return svrsqrte(arg);
         }
 
         // sqrt
-        template <class A, class T, detail::sve_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> sqrt(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
             return svsqrt_x(detail::sve_ptrue<T>(), arg);
         }
 
         // reciprocal
-        template <class A, class T, detail::sve_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> reciprocal(const batch<T, A>& arg, requires_arch<sve>) noexcept
         {
             return svrecpe(arg);
@@ -980,7 +942,7 @@ namespace xsimd
             XSIMD_INLINE V sve_iota() noexcept { return sve_iota_impl(index<sizeof(T)> {}); }
         } // namespace detail
 
-        template <class A, class T, size_t I, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, size_t I, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> insert(batch<T, A> const& arg, T val, index<I>, requires_arch<sve>) noexcept
         {
             // create a predicate with only the I-th lane activated
@@ -990,96 +952,96 @@ namespace xsimd
         }
 
         // first
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE T first(batch<T, A> const& self, requires_arch<sve>) noexcept
         {
             return self.data[0];
         }
 
         // all
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE bool all(batch_bool<T, A> const& arg, requires_arch<sve>) noexcept
         {
             return detail::sve_pcount<T>(arg) == batch_bool<T, A>::size;
         }
 
         // any
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE bool any(batch_bool<T, A> const& arg, requires_arch<sve>) noexcept
         {
             return svptest_any(arg, arg);
         }
 
         // bitwise_cast
-        template <class A, class T, class R, detail::sve_enable_all_t<T> = 0, detail::enable_sized_unsigned_t<R, 1> = 0>
+        template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_unsigned_t<R, 1> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
             return svreinterpret_u8(static_cast<detail::sve_sizeless_t<T>>(arg));
         }
 
-        template <class A, class T, class R, detail::sve_enable_all_t<T> = 0, detail::enable_sized_signed_t<R, 1> = 0>
+        template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_signed_t<R, 1> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
             return svreinterpret_s8(static_cast<detail::sve_sizeless_t<T>>(arg));
         }
 
-        template <class A, class T, class R, detail::sve_enable_all_t<T> = 0, detail::enable_sized_unsigned_t<R, 2> = 0>
+        template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_unsigned_t<R, 2> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
             return svreinterpret_u16(static_cast<detail::sve_sizeless_t<T>>(arg));
         }
 
-        template <class A, class T, class R, detail::sve_enable_all_t<T> = 0, detail::enable_sized_signed_t<R, 2> = 0>
+        template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_signed_t<R, 2> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
             return svreinterpret_s16(static_cast<detail::sve_sizeless_t<T>>(arg));
         }
 
-        template <class A, class T, class R, detail::sve_enable_all_t<T> = 0, detail::enable_sized_unsigned_t<R, 4> = 0>
+        template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_unsigned_t<R, 4> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
             return svreinterpret_u32(static_cast<detail::sve_sizeless_t<T>>(arg));
         }
 
-        template <class A, class T, class R, detail::sve_enable_all_t<T> = 0, detail::enable_sized_signed_t<R, 4> = 0>
+        template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_signed_t<R, 4> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
             return svreinterpret_s32(static_cast<detail::sve_sizeless_t<T>>(arg));
         }
 
-        template <class A, class T, class R, detail::sve_enable_all_t<T> = 0, detail::enable_sized_unsigned_t<R, 8> = 0>
+        template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_unsigned_t<R, 8> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
             return svreinterpret_u64(static_cast<detail::sve_sizeless_t<T>>(arg));
         }
 
-        template <class A, class T, class R, detail::sve_enable_all_t<T> = 0, detail::enable_sized_signed_t<R, 8> = 0>
+        template <class A, class T, class R, detail::enable_arithmetic_t<T> = 0, detail::enable_sized_signed_t<R, 8> = 0>
         XSIMD_INLINE batch<R, A> bitwise_cast(batch<T, A> const& arg, batch<R, A> const&, requires_arch<sve>) noexcept
         {
             return svreinterpret_s64(static_cast<detail::sve_sizeless_t<T>>(arg));
         }
 
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<float, A> bitwise_cast(batch<T, A> const& arg, batch<float, A> const&, requires_arch<sve>) noexcept
         {
             return svreinterpret_f32(static_cast<detail::sve_sizeless_t<T>>(arg));
         }
 
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<double, A> bitwise_cast(batch<T, A> const& arg, batch<double, A> const&, requires_arch<sve>) noexcept
         {
             return svreinterpret_f64(static_cast<detail::sve_sizeless_t<T>>(arg));
         }
 
         // batch_bool_cast
-        template <class A, class T_out, class T_in, detail::sve_enable_all_t<T_in> = 0>
+        template <class A, class T_out, class T_in, detail::enable_arithmetic_t<T_in> = 0>
         XSIMD_INLINE batch_bool<T_out, A> batch_bool_cast(batch_bool<T_in, A> const& arg, batch_bool<T_out, A> const&, requires_arch<sve>) noexcept
         {
             return arg.data;
         }
 
         // from_bool
-        template <class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> from_bool(batch_bool<T, A> const& arg, requires_arch<sve>) noexcept
         {
             return select(arg, batch<T, A>(1), batch<T, A>(0));
@@ -1113,7 +1075,7 @@ namespace xsimd
             };
         } // namespace detail
 
-        template <size_t N, class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <size_t N, class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> slide_left(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
             return detail::sve_slider_left<N>()(arg);
@@ -1147,21 +1109,21 @@ namespace xsimd
             };
         } // namespace detail
 
-        template <size_t N, class A, class T, detail::sve_enable_all_t<T> = 0>
+        template <size_t N, class A, class T, detail::enable_arithmetic_t<T> = 0>
         XSIMD_INLINE batch<T, A> slide_right(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
             return detail::sve_slider_right<N>()(arg);
         }
 
         // isnan
-        template <class A, class T, detail::sve_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch_bool<T, A> isnan(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
             return !(arg == arg);
         }
 
         // nearbyint
-        template <class A, class T, detail::sve_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> nearbyint(batch<T, A> const& arg, requires_arch<sve>) noexcept
         {
             return svrintx_x(detail::sve_ptrue<T>(), arg);
@@ -1183,7 +1145,7 @@ namespace xsimd
         }
 
         // ldexp
-        template <class A, class T, detail::sve_enable_floating_point_t<T> = 0>
+        template <class A, class T, detail::enable_floating_point_t<T> = 0>
         XSIMD_INLINE batch<T, A> ldexp(const batch<T, A>& x, const batch<as_integer_t<T>, A>& exp, requires_arch<sve>) noexcept
         {
             return svscale_x(detail::sve_ptrue<T>(), x, exp);
diff --git a/include/xsimd/types/xsimd_rvv_register.hpp b/include/xsimd/types/xsimd_rvv_register.hpp
index 83f8bfcfd..cd9e84ba0 100644
--- a/include/xsimd/types/xsimd_rvv_register.hpp
+++ b/include/xsimd/types/xsimd_rvv_register.hpp
@@ -13,8 +13,9 @@
 #ifndef XSIMD_RVV_REGISTER_HPP
 #define XSIMD_RVV_REGISTER_HPP
 
-#include "xsimd_common_arch.hpp"
-#include "xsimd_register.hpp"
+#include "../utils/xsimd_type_traits.hpp"
+#include "./xsimd_common_arch.hpp"
+#include "./xsimd_register.hpp"
 
 #if XSIMD_WITH_RVV
 #include <riscv_vector.h>
@@ -287,15 +288,6 @@ 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 = std::conditional_t<std::is_signed<char>::value, int8_t, uint8_t>;
-            template <class T>
-            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
             // we add this vacuous flag argument when we're serious:
@@ -334,7 +326,7 @@ namespace xsimd
                 operator register_type() const noexcept { return value.get(); }
             };
             template <class T, size_t Width = XSIMD_RVV_BITS>
-            using rvv_reg_t = std::conditional_t<!std::is_void<T>::value, rvv_reg<rvv_fix_char_t<T>, Width>, void>;
+            using rvv_reg_t = std::conditional_t<!std::is_void<T>::value, rvv_reg<project_num_t<T>, Width>, void>;
 
             // And some more of the same stuff for bool types, which have
             // similar problems and similar workarounds.
@@ -396,7 +388,7 @@ namespace xsimd
 
             template <class T, size_t Width = XSIMD_RVV_BITS>
             using rvv_bool_t = std::enable_if_t < !std::is_void<T>::value,
-                  rvv_bool<rvv_fix_char_t<T>, Width<rvv_width_m1 ? rvv_width_m1 : Width>>;
+                  rvv_bool<project_num_t<T>, Width<rvv_width_m1 ? rvv_width_m1 : Width>>;
 
             template <size_t S>
             struct rvv_vector_type_impl;
diff --git a/include/xsimd/types/xsimd_utils.hpp b/include/xsimd/types/xsimd_utils.hpp
index 3284e97c0..6af62c1a0 100644
--- a/include/xsimd/types/xsimd_utils.hpp
+++ b/include/xsimd/types/xsimd_utils.hpp
@@ -206,9 +206,25 @@ namespace xsimd
              * enabling / disabling metafunctions *
              **************************************/
 
+            template <class T>
+            using enable_arithmetic_t = std::enable_if_t<std::is_arithmetic<T>::value, int>;
+
+            /// Enable signed integral or floating point
+            template <class T>
+            using enable_signed_numeral_t = std::enable_if_t<std::is_signed<T>::value, int>;
+
+            template <class T>
+            using enable_floating_point_t = std::enable_if_t<std::is_floating_point<T>::value, int>;
+
             template <class T>
             using enable_integral_t = std::enable_if_t<std::is_integral<T>::value, int>;
 
+            template <class T>
+            using enable_signed_integral_t = std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, int>;
+
+            template <class T>
+            using enable_unsigned_integral_t = std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, int>;
+
             template <class T, size_t S>
             using enable_sized_signed_t = std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value && sizeof(T) == S, int>;
 
diff --git a/include/xsimd/utils/xsimd_type_traits.hpp b/include/xsimd/utils/xsimd_type_traits.hpp
index a3f6842f5..20fc90ed8 100644
--- a/include/xsimd/utils/xsimd_type_traits.hpp
+++ b/include/xsimd/utils/xsimd_type_traits.hpp
@@ -57,7 +57,7 @@ namespace xsimd
     }
 
     /**
-     * @ingroup batch_traits
+     * @ingroup type_traits
      *
      * Signed integer type with exactly @c S bytes (1, 2, 4, or 8).
      *
@@ -67,7 +67,7 @@ namespace xsimd
     using sized_int_t = typename detail::sized_num_types<S>::signed_type;
 
     /**
-     * @ingroup batch_traits
+     * @ingroup type_traits
      *
      * Unsigned integer type with exactly @c S bytes (1, 2, 4, or 8).
      *
@@ -77,7 +77,7 @@ namespace xsimd
     using sized_uint_t = typename detail::sized_num_types<S>::unsigned_type;
 
     /**
-     * @ingroup batch_traits
+     * @ingroup type_traits
      *
      * Floating-point type with exactly @c S bytes (4 for @c float, 8 for @c double).
      * Yields @c void for sizes without a standard floating-point type (1, 2).
@@ -89,30 +89,48 @@ namespace xsimd
 
     namespace detail
     {
-        template <typename T, typename = void>
-        struct widen;
+        template <typename T, std::size_t factor, typename = void>
+        struct remap_num
+        {
+            using type = T;
+        };
 
-        template <typename T>
-        struct widen<T, std::enable_if_t<std::is_floating_point<T>::value>>
+        template <typename T, std::size_t factor>
+        struct remap_num<T, factor, std::enable_if_t<std::is_floating_point<T>::value>>
         {
-            using type = xsimd::sized_fp_t<sizeof(T) * 2>;
+            using type = xsimd::sized_fp_t<sizeof(T) * factor>;
         };
 
-        template <typename T>
-        struct widen<T, std::enable_if_t<!std::is_floating_point<T>::value && std::is_signed<T>::value>>
+        template <typename T, std::size_t factor>
+        struct remap_num<T, factor, std::enable_if_t<!std::is_floating_point<T>::value && std::is_signed<T>::value>>
         {
-            using type = xsimd::sized_int_t<sizeof(T) * 2>;
+            using type = xsimd::sized_int_t<sizeof(T) * factor>;
         };
 
-        template <typename T>
-        struct widen<T, std::enable_if_t<!std::is_floating_point<T>::value && std::is_unsigned<T>::value>>
+        template <typename T, std::size_t factor>
+        struct remap_num<T, factor, std::enable_if_t<!std::is_floating_point<T>::value && std::is_unsigned<T>::value>>
         {
-            using type = xsimd::sized_uint_t<sizeof(T) * 2>;
+            using type = xsimd::sized_uint_t<sizeof(T) * factor>;
         };
     }
 
     /**
-     * @ingroup batch_traits
+     * @ingroup type_traits
+     *
+     * Remap numeral types to their fixed sized variant (``[u]int{8,16,32}_t``
+     * and pass through other types).
+     * Certain platforms have different types (*i.e.* not aliases) between
+     * ``char`` and ``int8_t``, or ``long long`` and ``int{32,64}_t``, with SIMD
+     * intrinsicts only defined for some of them.
+     * Handling them requires to cast to a known predictable type.
+     *
+     * @tparam T arithmetic type to project from.
+     */
+    template <typename T>
+    using project_num_t = typename detail::remap_num<T, /* factor= */ 1>::type;
+
+    /**
+     * @ingroup type_traits
      *
      * The next-wider arithmetic type for @c T: doubles the size while preserving
      * signedness for integers and yielding @c double for @c float.
@@ -121,7 +139,7 @@ namespace xsimd
      * @tparam T arithmetic type to widen.
      */
     template <typename T>
-    using widen_t = typename detail::widen<T>::type;
+    using widen_t = typename detail::remap_num<T, /* factor= */ 2>::type;
 }
 
 #endif