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

Fix #1179

Author: serge-sans-paille

include/xsimd/arch/common/xsimd_common_cast.hpp

@@ -0,0 +1,82 @@
+/***************************************************************************
+ * Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
+ * Martin Renou                                                             *
+ * Copyright (c) QuantStack                                                 *
+ * Copyright (c) Serge Guelton                                              *
+ *                                                                          *
+ * Distributed under the terms of the BSD 3-Clause License.                 *
+ *                                                                          *
+ * The full license is in the file LICENSE, distributed with this software. *
+ ****************************************************************************/
+
+#ifndef XSIMD_COMMON_CAST_HPP
+#define XSIMD_COMMON_CAST_HPP
+
+namespace xsimd
+{
+    namespace kernel
+    {
+        // 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 <>
+            struct upcast<float>
+            {
+                using type = double;
+            };
+            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<common>) noexcept
+        {
+            alignas(A::alignment()) T buffer[batch<T, A>::size];
+            x.store_aligned(&buffer[0]);
+
+            using T_out = detail::upcast_t<T>;
+            alignas(A::alignment()) T_out out_buffer[batch<T, A>::size];
+            for (size_t i = 0; i < batch<T, A>::size; ++i)
+                out_buffer[i] = static_cast<T_out>(buffer[i]);
+
+            return { batch<T_out, A>::load_aligned(&out_buffer[0]),
+                     batch<T_out, A>::load_aligned(&out_buffer[batch<T_out, A>::size]) };
+        }
+
+    }
+
+}
+
+#endif

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_common.hpp

@@ -13,6 +13,7 @@
 #define XSIMD_COMMON_HPP
 
 #include "./common/xsimd_common_arithmetic.hpp"
+#include "./common/xsimd_common_cast.hpp"
 #include "./common/xsimd_common_complex.hpp"
 #include "./common/xsimd_common_logical.hpp"
 #include "./common/xsimd_common_math.hpp"

include/xsimd/arch/xsimd_sse4_1.hpp

@@ -15,6 +15,7 @@
 #include <type_traits>
 
 #include "../types/xsimd_sse4_1_register.hpp"
+#include "./common/xsimd_common_cast.hpp"
 
 namespace xsimd
 {
@@ -67,6 +68,38 @@ namespace xsimd
             }
         }
 
+        // upcast
+        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
      *