Merge pull request #436 from JohanMabille/from_to

Added broadcast / from_aligned / form_unaligned static methods

Author: JohanMabille

include/xsimd/types/xsimd_base.hpp

@@ -153,6 +153,14 @@ namespace xsimd
         using reverse_iterator = std::reverse_iterator<iterator>;
         using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
+        static X broadcast(value_type v);
+
+        template <class T>
+        static X from_unaligned(T* src);
+
+        template <class T>
+        static X from_aligned(T* src);
+
         X& operator+=(const X& rhs);
         X& operator+=(const value_type& rhs);
 
@@ -676,6 +684,52 @@ namespace xsimd
     {
     }
 
+    /**
+     * @name Static builders
+     */
+    //@{
+    /**
+     * Creates a batch from the single value \c v.
+     * @param v the value used to initialize the batch
+     * @return a new batch instance
+     */
+    template <class X>
+    inline X simd_batch<X>::broadcast(value_type v)
+    {
+        return X(v);
+    }
+
+    /**
+     * Creates a batch from the buffer \c src. The
+     * memory does not need to be aligned.
+     * @param src the memory buffer to read
+     * @return a new batch instance
+     */
+    template <class X>
+    template <class T>
+    inline X simd_batch<X>::from_unaligned(T* src)
+    {
+        X res;
+        res.load_unaligned(src);
+        return res;
+    }
+
+    /**
+     * Creates a batch from the buffer \c src. The
+     * memory needs to be aligned.
+     * @param src the memory buffer to read
+     * @return a new batch instance
+     */
+    template <class X>
+    template <class T>
+    inline X simd_batch<X>::from_aligned(T* src)
+    {
+        X res;
+        res.load_aligned(src);
+        return res;
+    }
+    //@}
+    
     /**
      * @name Arithmetic computed assignment
      */

test/test_batch.cpp

@@ -62,6 +62,30 @@ class batch_test : public testing::Test
         EXPECT_EQ(b1, lhs) << print_function_name("batch(value_type*)");
     }
 
+    void test_static_builders() const
+    {
+        {
+            array_type expected;
+            std::fill(expected.begin(), expected.end(), value_type(2));
+
+            auto res = batch_type::broadcast(value_type(2));
+            EXPECT_EQ(res, expected) << print_function_name("batch::broadcast");
+        }
+        {
+            array_type res;
+            auto b = batch_type::from_unaligned(lhs.data());
+            b.store_unaligned(res.data());
+            EXPECT_EQ(res, lhs) << print_function_name("batch::from_unaligned");
+        }
+        {
+            alignas(XSIMD_DEFAULT_ALIGNMENT) array_type arhs(this->rhs);
+            alignas(XSIMD_DEFAULT_ALIGNMENT) array_type ares;
+            auto b = batch_type::from_aligned(arhs.data());
+            b.store_aligned(ares.data());
+            EXPECT_EQ(ares, rhs) << print_function_name("batch::from_aligned");
+        }
+    }
+
     void test_access_operator() const
     {
         batch_type res = batch_lhs();
@@ -549,6 +573,11 @@ TYPED_TEST(batch_test, constructors)
     this->test_constructors();
 }
 
+TYPED_TEST(batch_test, static_builders)
+{
+    this->test_static_builders();
+}
+
 TYPED_TEST(batch_test, access_operator)
 {
     this->test_access_operator();