Extend support of batch_cast<...> to upcasting to a type twice as big

Fix #1179

Author: serge-sans-paille

include/xsimd/arch/xsimd_avx.hpp

@@ -527,6 +527,22 @@ namespace xsimd
             }
         }
 
+        // upcast
+        template <class A, class T>
+        XSIMD_INLINE std::array<batch<detail::upcast_t<T>, A>, 2> batch_upcast(batch<T, A> const& x, requires_arch<avx>) noexcept
+        {
+            auto pair_lo = batch_upcast(batch<T, sse4_2>(_mm256_extractf128_si256(x, 0)), sse4_2 {});
+            auto pair_hi = batch_upcast(batch<T, sse4_2>(_mm256_extractf128_si256(x, 1)), sse4_2 {});
+            return { detail::merge_sse(pair_lo[0], pair_lo[1]), detail::merge_sse(pair_hi[0], pair_hi[1]) };
+        }
+        template <class A>
+        XSIMD_INLINE std::array<batch<double, A>, 2> batch_upcast(batch<float, A> const& x, requires_arch<avx>) noexcept
+        {
+            __m256d lo = _mm256_cvtps_pd(_mm256_extractf128_ps(x, 0));
+            __m256d hi = _mm256_cvtps_pd(_mm256_extractf128_ps(x, 1));
+            return { lo, hi };
+        }
+
         // decr_if
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> decr_if(batch<T, A> const& self, batch_bool<T, A> const& mask, requires_arch<avx>) noexcept

include/xsimd/arch/xsimd_avx2.hpp

@@ -431,6 +431,31 @@ namespace xsimd
             }
         }
 
+        // upcast
+        template <class A, class T>
+        XSIMD_INLINE std::array<batch<detail::upcast_t<T>, A>, 2> batch_upcast(batch<T, A> const& x, requires_arch<avx2>) noexcept
+        {
+            __m128i x_lo = _mm256_extracti128_si256(x, 0);
+            __m128i x_hi = _mm256_extracti128_si256(x, 1);
+            __m256i lo, hi;
+            XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
+            {
+                lo = _mm256_cvtepi32_epi64(x_lo);
+                hi = _mm256_cvtepi32_epi64(x_hi);
+            }
+            else XSIMD_IF_CONSTEXPR(sizeof(T) == 2)
+            {
+                lo = _mm256_cvtepi16_epi32(x_lo);
+                hi = _mm256_cvtepi16_epi32(x_hi);
+            }
+            else XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
+            {
+                lo = _mm256_cvtepi8_epi16(x_lo);
+                hi = _mm256_cvtepi8_epi16(x_hi);
+            }
+            return { lo, hi };
+        }
+
         // eq
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         XSIMD_INLINE batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<avx2>) noexcept

include/xsimd/arch/xsimd_sse4_1.hpp

@@ -67,6 +67,76 @@ namespace xsimd
             }
         }
 
+        // upcast
+        namespace detail
+        {
+            template <typename T>
+            struct upcast;
+            template <>
+            struct upcast<uint32_t>
+            {
+                using type = uint64_t;
+            };
+            template <>
+            struct upcast<uint16_t>
+            {
+                using type = uint32_t;
+            };
+            template <>
+            struct upcast<uint8_t>
+            {
+                using type = uint8_t;
+            };
+            template <>
+            struct upcast<int32_t>
+            {
+                using type = int64_t;
+            };
+            template <>
+            struct upcast<int16_t>
+            {
+                using type = int32_t;
+            };
+            template <>
+            struct upcast<int8_t>
+            {
+                using type = int8_t;
+            };
+            template <typename T>
+            using upcast_t = typename upcast<T>::type;
+        }
+
+        template <class T, class A>
+        XSIMD_INLINE std::array<batch<detail::upcast_t<T>, A>, 2> batch_upcast(batch<T, A> const& x, requires_arch<sse4_1>) noexcept
+        {
+            __m128i x_shuf = _mm_unpackhi_epi64(x, x);
+            __m128i lo, hi;
+            XSIMD_IF_CONSTEXPR(sizeof(T) == 4)
+            {
+                lo = _mm_cvtepi32_epi64(x);
+                hi = _mm_cvtepi32_epi64(x_shuf);
+            }
+            else XSIMD_IF_CONSTEXPR(sizeof(T) == 2)
+            {
+                lo = _mm_cvtepi16_epi32(x);
+                hi = _mm_cvtepi16_epi32(x_shuf);
+            }
+            else XSIMD_IF_CONSTEXPR(sizeof(T) == 1)
+            {
+                lo = _mm_cvtepi8_epi16(x);
+                hi = _mm_cvtepi8_epi16(x_shuf);
+            }
+            return { lo, hi };
+        }
+        template <class A>
+        XSIMD_INLINE std::array<batch<double, A>, 2> batch_upcast(batch<float, A> const& x, requires_arch<sse4_1>) noexcept
+        {
+            __m128 x_shuf = _mm_unpackhi_ps(x, x);
+            __m128d lo = _mm_cvtps_pd(x);
+            __m128d hi = _mm_cvtps_pd(x_shuf);
+            return { lo, hi };
+        }
+
         // eq
         template <class A, class T, class = typename std::enable_if<std::is_integral<T>::value, void>::type>
         XSIMD_INLINE batch_bool<T, A> eq(batch<T, A> const& self, batch<T, A> const& other, requires_arch<sse4_1>) noexcept

include/xsimd/types/xsimd_api.hpp

@@ -256,14 +256,22 @@ namespace xsimd
      * @param x batch of \c T_in
      * @return \c x cast to \c T_out
      */
-    template <class T_out, class T_in, class A>
+    template <class T_out, class T_in, class A, class = typename std::enable_if<sizeof(T_out) == sizeof(T_in), void>::type>
     XSIMD_INLINE batch<T_out, A> batch_cast(batch<T_in, A> const& x) noexcept
     {
         detail::static_check_supported_config<T_out, A>();
         detail::static_check_supported_config<T_in, A>();
         return kernel::batch_cast<A>(x, batch<T_out, A> {}, A {});
     }
 
+    template <class T_out, class T_in, class A, class = typename std::enable_if<sizeof(T_out) == 2 * sizeof(T_in), void>::type>
+    XSIMD_INLINE std::array<batch<T_out, A>, 2> batch_cast(batch<T_in, A> const& x) noexcept
+    {
+        detail::static_check_supported_config<T_out, A>();
+        detail::static_check_supported_config<T_in, A>();
+        return kernel::batch_upcast<A>(x, A {});
+    }
+
     /**
      * @ingroup batch_miscellaneous
      *