Merge pull request #251 from adriendelsalle/pyarray-init-list

JohanMabille · web-flow · commit 1e922c552f88 · 2021-02-04T15:08:30.000+01:00
`pyarray` initializers lists work with all layouts
diff --git a/include/xtensor-python/pyarray.hpp b/include/xtensor-python/pyarray.hpp
@@ -224,6 +224,8 @@ namespace xt
         storage_type& storage_impl() noexcept;
         const storage_type& storage_impl() const noexcept;
 
+        layout_type default_dynamic_layout();
+
         friend class xcontainer<pyarray<T, L>>;
         friend class pycontainer<pyarray<T, L>>;
     };
@@ -254,48 +256,48 @@ namespace xt
     inline pyarray<T, L>::pyarray(const value_type& t)
         : base_type()
     {
-        base_type::resize(xt::shape<shape_type>(t), layout_type::row_major);
+        base_type::resize(xt::shape<shape_type>(t), default_dynamic_layout());
         nested_copy(m_storage.begin(), t);
     }
 
     template <class T, layout_type L>
     inline pyarray<T, L>::pyarray(nested_initializer_list_t<T, 1> t)
         : base_type()
     {
-        base_type::resize(xt::shape<shape_type>(t), layout_type::row_major);
-        nested_copy(m_storage.begin(), t);
+        base_type::resize(xt::shape<shape_type>(t), default_dynamic_layout());
+        L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);
     }
 
     template <class T, layout_type L>
     inline pyarray<T, L>::pyarray(nested_initializer_list_t<T, 2> t)
         : base_type()
     {
-        base_type::resize(xt::shape<shape_type>(t), layout_type::row_major);
-        nested_copy(m_storage.begin(), t);
+        base_type::resize(xt::shape<shape_type>(t), default_dynamic_layout());
+        L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);
     }
 
     template <class T, layout_type L>
     inline pyarray<T, L>::pyarray(nested_initializer_list_t<T, 3> t)
         : base_type()
     {
-        base_type::resize(xt::shape<shape_type>(t), layout_type::row_major);
-        nested_copy(m_storage.begin(), t);
+        base_type::resize(xt::shape<shape_type>(t), default_dynamic_layout());
+        L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);
     }
 
     template <class T, layout_type L>
     inline pyarray<T, L>::pyarray(nested_initializer_list_t<T, 4> t)
         : base_type()
     {
-        base_type::resize(xt::shape<shape_type>(t), layout_type::row_major);
-        nested_copy(m_storage.begin(), t);
+        base_type::resize(xt::shape<shape_type>(t), default_dynamic_layout());
+        L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);
     }
 
     template <class T, layout_type L>
     inline pyarray<T, L>::pyarray(nested_initializer_list_t<T, 5> t)
         : base_type()
     {
-        base_type::resize(xt::shape<shape_type>(t), layout_type::row_major);
-        nested_copy(m_storage.begin(), t);
+        base_type::resize(xt::shape<shape_type>(t), default_dynamic_layout());
+        L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);
     }
 
     template <class T, layout_type L>
@@ -443,7 +445,9 @@ namespace xt
         // TODO: prevent intermediary shape allocation
         shape_type shape = xtl::forward_sequence<shape_type, decltype(e.derived_cast().shape())>(e.derived_cast().shape());
         strides_type strides = xtl::make_sequence<strides_type>(shape.size(), size_type(0));
-        compute_strides(shape, L, strides);
+        layout_type layout = default_dynamic_layout();
+
+        compute_strides(shape, layout, strides);
         init_array(shape, strides);
         semantic_base::assign(e);
     }
@@ -559,6 +563,12 @@ namespace xt
     {
         return m_storage;
     }
+
+    template <class T, layout_type L>
+    layout_type pyarray<T, L>::default_dynamic_layout()
+    {
+        return L == layout_type::dynamic ? layout_type::row_major : L;
+    }
 }
 
 #endif
diff --git a/test/test_pyarray.cpp b/test/test_pyarray.cpp
@@ -37,17 +37,44 @@ namespace xt
 
     TEST(pyarray, initializer_constructor)
     {
-        pyarray<int> t 
+        pyarray<int> r
           {{{ 0,  1,  2}, 
             { 3,  4,  5}, 
             { 6,  7,  8}}, 
            {{ 9, 10, 11}, 
             {12, 13, 14}, 
             {15, 16, 17}}}; 
 
-        EXPECT_EQ(t.dimension(), 3);
-        EXPECT_EQ(t(0, 0, 1), 1);
-        EXPECT_EQ(t.shape()[0], 2);
+        EXPECT_EQ(r.layout(), xt::layout_type::row_major);
+        EXPECT_EQ(r.dimension(), 3);
+        EXPECT_EQ(r(0, 0, 1), 1);
+        EXPECT_EQ(r.shape()[0], 2);
+
+        pyarray<int, xt::layout_type::column_major> c
+          {{{ 0,  1,  2}, 
+            { 3,  4,  5}, 
+            { 6,  7,  8}}, 
+           {{ 9, 10, 11}, 
+            {12, 13, 14}, 
+            {15, 16, 17}}}; 
+
+        EXPECT_EQ(c.layout(), xt::layout_type::column_major);
+        EXPECT_EQ(c.dimension(), 3);
+        EXPECT_EQ(c(0, 0, 1), 1);
+        EXPECT_EQ(c.shape()[0], 2);
+
+        pyarray<int, xt::layout_type::dynamic> d
+          {{{ 0,  1,  2}, 
+            { 3,  4,  5}, 
+            { 6,  7,  8}}, 
+           {{ 9, 10, 11}, 
+            {12, 13, 14}, 
+            {15, 16, 17}}}; 
+
+        EXPECT_EQ(d.layout(), xt::layout_type::row_major);
+        EXPECT_EQ(d.dimension(), 3);
+        EXPECT_EQ(d(0, 0, 1), 1);
+        EXPECT_EQ(d.shape()[0], 2);
     }
 
     TEST(pyarray, shaped_constructor)

Original file line number	Diff line number	Diff line change
`@@ -224,6 +224,8 @@ namespace xt`
`224`	`224`	`storage_type& storage_impl() noexcept;`
`225`	`225`	`const storage_type& storage_impl() const noexcept;`
`226`	`226`
	`227`	`+ layout_type default_dynamic_layout();`
	`228`	`+`
`227`	`229`	`friend class xcontainer<pyarray<T, L>>;`
`228`	`230`	`friend class pycontainer<pyarray<T, L>>;`
`229`	`231`	`};`
`@@ -254,48 +256,48 @@ namespace xt`
`254`	`256`	`inline pyarray<T, L>::pyarray(const value_type& t)`
`255`	`257`	`: base_type()`
`256`	`258`	`{`
`257`		`- base_type::resize(xt::shape<shape_type>(t), layout_type::row_major);`
	`259`	`+ base_type::resize(xt::shape<shape_type>(t), default_dynamic_layout());`
`258`	`260`	`nested_copy(m_storage.begin(), t);`
`259`	`261`	`}`
`260`	`262`
`261`	`263`	`template <class T, layout_type L>`
`262`	`264`	`inline pyarray<T, L>::pyarray(nested_initializer_list_t<T, 1> t)`
`263`	`265`	`: base_type()`
`264`	`266`	`{`
`265`		`- base_type::resize(xt::shape<shape_type>(t), layout_type::row_major);`
`266`		`- nested_copy(m_storage.begin(), t);`
	`267`	`+ base_type::resize(xt::shape<shape_type>(t), default_dynamic_layout());`
	`268`	`+ L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);`
`267`	`269`	`}`
`268`	`270`
`269`	`271`	`template <class T, layout_type L>`
`270`	`272`	`inline pyarray<T, L>::pyarray(nested_initializer_list_t<T, 2> t)`
`271`	`273`	`: base_type()`
`272`	`274`	`{`
`273`		`- base_type::resize(xt::shape<shape_type>(t), layout_type::row_major);`
`274`		`- nested_copy(m_storage.begin(), t);`
	`275`	`+ base_type::resize(xt::shape<shape_type>(t), default_dynamic_layout());`
	`276`	`+ L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);`
`275`	`277`	`}`
`276`	`278`
`277`	`279`	`template <class T, layout_type L>`
`278`	`280`	`inline pyarray<T, L>::pyarray(nested_initializer_list_t<T, 3> t)`
`279`	`281`	`: base_type()`
`280`	`282`	`{`
`281`		`- base_type::resize(xt::shape<shape_type>(t), layout_type::row_major);`
`282`		`- nested_copy(m_storage.begin(), t);`
	`283`	`+ base_type::resize(xt::shape<shape_type>(t), default_dynamic_layout());`
	`284`	`+ L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);`
`283`	`285`	`}`
`284`	`286`
`285`	`287`	`template <class T, layout_type L>`
`286`	`288`	`inline pyarray<T, L>::pyarray(nested_initializer_list_t<T, 4> t)`
`287`	`289`	`: base_type()`
`288`	`290`	`{`
`289`		`- base_type::resize(xt::shape<shape_type>(t), layout_type::row_major);`
`290`		`- nested_copy(m_storage.begin(), t);`
	`291`	`+ base_type::resize(xt::shape<shape_type>(t), default_dynamic_layout());`
	`292`	`+ L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);`
`291`	`293`	`}`
`292`	`294`
`293`	`295`	`template <class T, layout_type L>`
`294`	`296`	`inline pyarray<T, L>::pyarray(nested_initializer_list_t<T, 5> t)`
`295`	`297`	`: base_type()`
`296`	`298`	`{`
`297`		`- base_type::resize(xt::shape<shape_type>(t), layout_type::row_major);`
`298`		`- nested_copy(m_storage.begin(), t);`
	`299`	`+ base_type::resize(xt::shape<shape_type>(t), default_dynamic_layout());`
	`300`	`+ L == layout_type::row_major ? nested_copy(m_storage.begin(), t) : nested_copy(this->template begin<layout_type::row_major>(), t);`
`299`	`301`	`}`
`300`	`302`
`301`	`303`	`template <class T, layout_type L>`
`@@ -443,7 +445,9 @@ namespace xt`
`443`	`445`	`// TODO: prevent intermediary shape allocation`
`444`	`446`	`shape_type shape = xtl::forward_sequence<shape_type, decltype(e.derived_cast().shape())>(e.derived_cast().shape());`
`445`	`447`	`strides_type strides = xtl::make_sequence<strides_type>(shape.size(), size_type(0));`
`446`		`- compute_strides(shape, L, strides);`
	`448`	`+ layout_type layout = default_dynamic_layout();`
	`449`	`+`
	`450`	`+ compute_strides(shape, layout, strides);`
`447`	`451`	`init_array(shape, strides);`
`448`	`452`	`semantic_base::assign(e);`
`449`	`453`	`}`
`@@ -559,6 +563,12 @@ namespace xt`
`559`	`563`	`{`
`560`	`564`	`return m_storage;`
`561`	`565`	`}`
	`566`	`+`
	`567`	`+ template <class T, layout_type L>`
	`568`	`+ layout_type pyarray<T, L>::default_dynamic_layout()`
	`569`	`+ {`
	`570`	`+ return L == layout_type::dynamic ? layout_type::row_major : L;`
	`571`	`+ }`
`562`	`572`	`}`
`563`	`573`
`564`	`574`	`#endif`