Merge pull request #449 from serge-sans-paille/feature/load-complex

Support loading / storing complex numbers with empty imaginary part

Author: JohanMabille

include/xsimd/types/xsimd_complex_base.hpp

@@ -15,6 +15,7 @@
 #include <cstddef>
 #include <limits>
 #include <ostream>
+#include <cassert>
 
 #ifdef XSIMD_ENABLE_XTL_COMPLEX
 #include "xtl/xcomplex.hpp"
@@ -199,9 +200,18 @@ namespace xsimd
         load_unaligned(const T* src);
 
         template <class T>
-        void store_aligned(T* dst) const;
+        inline typename std::enable_if<detail::is_complex<T>::value, void>::type
+        store_aligned(T* dst) const;
         template <class T>
-        void store_unaligned(T* dst) const;
+        inline typename std::enable_if<detail::is_complex<T>::value, void>::type
+        store_unaligned(T* dst) const;
+
+        template <class T>
+        inline typename std::enable_if<!detail::is_complex<T>::value, void>::type
+        store_aligned(T* dst) const;
+        template <class T>
+        inline typename std::enable_if<!detail::is_complex<T>::value, void>::type
+        store_unaligned(T* dst) const;
 
         value_type operator[](std::size_t index) const;
 
@@ -824,12 +834,13 @@ namespace xsimd
     /// @endcond
 
     /**
-     * Stores the N values of the batch into a contiguous array
+     * Stores the N values of the batch into a contiguous array of complex
      * pointed by \c dst. \c dst must be aligned.
      */
     template <class X>
     template <class T>
-    inline void simd_complex_batch<X>::store_aligned(T* dst) const
+    inline typename std::enable_if<detail::is_complex<T>::value, void>::type
+    simd_complex_batch<X>::store_aligned(T* dst) const
     {
         real_batch hi = (*this)().get_complex_high();
         real_batch lo = (*this)().get_complex_low();
@@ -840,12 +851,26 @@ namespace xsimd
     }
 
     /**
-     * Stores the N values of the batch into a contiguous array
+     * Stores the N values of the batch into a contiguous array of reals
+     * pointed by \c dst. \c dst must be aligned.
+     */
+    template <class X>
+    template <class T>
+    inline typename std::enable_if<!detail::is_complex<T>::value, void>::type
+    simd_complex_batch<X>::store_aligned(T* dst) const
+    {
+        m_real.store_aligned(dst);
+        assert(all(m_imag == 0) && "no imaginary part");
+    }
+
+    /**
+     * Stores the N values of the batch into a contiguous array of complex
      * pointed by \c dst. \c dst is not required to be aligned.
      */
     template <class X>
     template <class T>
-    inline void simd_complex_batch<X>::store_unaligned(T* dst) const
+    inline typename std::enable_if<detail::is_complex<T>::value, void>::type
+    simd_complex_batch<X>::store_unaligned(T* dst) const
     {
         real_batch hi = (*this)().get_complex_high();
         real_batch lo = (*this)().get_complex_low();
@@ -854,6 +879,20 @@ namespace xsimd
         hi.store_unaligned(rbuf);
         lo.store_unaligned(rbuf + size);
     }
+
+    /**
+     * Stores the N values of the batch into a contiguous array of reals
+     * pointed by \c dst. \c dst is not required to be aligned.
+     */
+    template <class X>
+    template <class T>
+    inline typename std::enable_if<!detail::is_complex<T>::value, void>::type
+    simd_complex_batch<X>::store_unaligned(T* dst) const
+    {
+        m_real.store_aligned(dst);
+        assert(all(m_imag == 0) && "no imaginary part");
+    }
+
     //@}
 
     template <class X>

test/test_batch_complex.cpp

@@ -74,10 +74,6 @@ class batch_complex_test : public testing::Test
             b.store_unaligned(res_real.data(), res_imag.data());
             EXPECT_EQ(res_real, real) << print_function_name("load_unaligned / store_unaligned (real*, real*)");
 
-            //b.load_unaligned(real.data());
-            //b.store_unaligned(res_real.data());
-            //EXPECT_EQ(res_real, real) << print_function_name("load_unaligned / store_unaligned (real*)");
-
             alignas(XSIMD_DEFAULT_ALIGNMENT) real_array_type areal, aimag, ares_real, ares_imag;
             for (size_t i = 0; i < size; ++i)
             {
@@ -87,10 +83,26 @@ class batch_complex_test : public testing::Test
             b.load_aligned(areal.data(), aimag.data());
             b.store_aligned(ares_real.data(), ares_imag.data());
             EXPECT_EQ(ares_real, areal) << print_function_name("load_aligned / store_aligned (real*, real*)");
+        }
+        {
+            real_array_type real, res_real;
+            for (size_t i = 0; i < size; ++i)
+            {
+                real[i] = lhs[i].real();
+            }
+            batch_type b;
+            b.load_unaligned(real.data());
+            b.store_unaligned(res_real.data());
+            EXPECT_EQ(res_real, real) << print_function_name("load_unaligned / store_unaligned (real*)");
 
-            //b.load_aligned(areal.data());
-            //b.store_aligned(ares_real.data());
-            //EXPECT_EQ(ares_real, areal) << print_function_name("load_aligned / store_aligned (real*)");
+            alignas(XSIMD_DEFAULT_ALIGNMENT) real_array_type areal, ares_real;
+            for (size_t i = 0; i < size; ++i)
+            {
+                areal[i] = lhs[i].real();
+            }
+            b.load_aligned(areal.data());
+            b.store_aligned(ares_real.data());
+            EXPECT_EQ(ares_real, areal) << print_function_name("load_aligned / store_aligned (real*)");
         }
     }