Switched to xtensor 0.9.0

JohanMabille · JohanMabille · commit bfc4c94d3cc4 · 2017-04-18T14:36:12.000+02:00
diff --git a/.appveyor.yml b/.appveyor.yml
@@ -23,7 +23,7 @@ install:
   - conda update -q conda
   - conda info -a
   - conda install gtest cmake -c conda-forge
-  - conda install xtensor==0.8.3 pytest numpy pybind11==2.1.1 -c conda-forge
+  - conda install xtensor==0.9.0 pytest numpy pybind11==2.1.1 -c conda-forge
   - "set PYTHONHOME=%MINICONDA%"
   - cmake -G "NMake Makefiles" -D CMAKE_INSTALL_PREFIX=%MINICONDA%\\Library -D BUILD_TESTS=ON -D PYTHON_EXECUTABLE=%MINICONDA%\\python.exe .
   - nmake test_xtensor_python
diff --git a/.travis.yml b/.travis.yml
@@ -94,7 +94,7 @@ install:
     - conda update -q conda
     # Useful for debugging any issues with conda
     - conda info -a
-    - conda install xtensor==0.8.3 pytest numpy pybind11==2.1.1 -c conda-forge
+    - conda install xtensor==0.9.0 pytest numpy pybind11==2.1.1 -c conda-forge
     - cd test
     - conda env create -f ./test-environment.yml
     - source activate test-xtensor-python
diff --git a/README.md b/README.md
@@ -30,7 +30,7 @@ conda install -c conda-forge xtensor-python
 
 | `xtensor-python`  | `xtensor`  |  `pybind11` |
 |-------------------|------------|-------------|
-| master            |  ^0.8.1    | ^2.1.0      |
+| master            |  ^0.9.0    | ^2.1.0      |
 | 0.9.4             |  ^0.8.1    | ^2.1.0      |
 | 0.9.3             |  ^0.8.1    | ^2.1.0      |
 | 0.9.2             |  ^0.8.1    | ^2.1.0      |
diff --git a/include/xtensor-python/pyarray.hpp b/include/xtensor-python/pyarray.hpp
@@ -145,8 +145,8 @@ namespace xt
         pyarray(pybind11::handle h, pybind11::object::stolen_t);
         pyarray(const pybind11::object &o);
         
-        explicit pyarray(const shape_type& shape, layout l = layout::row_major);
-        explicit pyarray(const shape_type& shape, const_reference value, layout l = layout::row_major);
+        explicit pyarray(const shape_type& shape, layout_type l = layout_type::row_major);
+        explicit pyarray(const shape_type& shape, const_reference value, layout_type l = layout_type::row_major);
         explicit pyarray(const shape_type& shape, const strides_type& strides, const_reference value);
         explicit pyarray(const shape_type& shape, const strides_type& strides);
 
@@ -238,47 +238,47 @@ namespace xt
     inline pyarray<T>::pyarray(const value_type& t)
         : base_type()
     {
-        base_type::reshape(xt::shape<shape_type>(t), layout::row_major);
+        base_type::reshape(xt::shape<shape_type>(t), layout_type::row_major);
         nested_copy(m_data.begin(), t);
     }
 
     template <class T>
     inline pyarray<T>::pyarray(nested_initializer_list_t<T, 1> t)
         : base_type()
     {
-        base_type::reshape(xt::shape<shape_type>(t), layout::row_major);
+        base_type::reshape(xt::shape<shape_type>(t), layout_type::row_major);
         nested_copy(m_data.begin(), t);
     }
 
     template <class T>
     inline pyarray<T>::pyarray(nested_initializer_list_t<T, 2> t)
         : base_type()
     {
-        base_type::reshape(xt::shape<shape_type>(t), layout::row_major);
+        base_type::reshape(xt::shape<shape_type>(t), layout_type::row_major);
         nested_copy(m_data.begin(), t);
     }
 
     template <class T>
     inline pyarray<T>::pyarray(nested_initializer_list_t<T, 3> t)
         : base_type()
     {
-        base_type::reshape(xt::shape<shape_type>(t), layout::row_major);
+        base_type::reshape(xt::shape<shape_type>(t), layout_type::row_major);
         nested_copy(m_data.begin(), t);
     }
 
     template <class T>
     inline pyarray<T>::pyarray(nested_initializer_list_t<T, 4> t)
         : base_type()
     {
-        base_type::reshape(xt::shape<shape_type>(t), layout::row_major);
+        base_type::reshape(xt::shape<shape_type>(t), layout_type::row_major);
         nested_copy(m_data.begin(), t);
     }
 
     template <class T>
     inline pyarray<T>::pyarray(nested_initializer_list_t<T, 5> t)
         : base_type()
     {
-        base_type::reshape(xt::shape<shape_type>(t), layout::row_major);
+        base_type::reshape(xt::shape<shape_type>(t), layout_type::row_major);
         nested_copy(m_data.begin(), t);
     }
 
@@ -310,7 +310,7 @@ namespace xt
      * @param l the layout of the pyarray
      */
     template <class T>
-    inline pyarray<T>::pyarray(const shape_type& shape, layout l)
+    inline pyarray<T>::pyarray(const shape_type& shape, layout_type l)
         : base_type()
     {
         strides_type strides(shape.size());
@@ -326,7 +326,7 @@ namespace xt
      * @param l the layout of the pyarray
      */
     template <class T>
-    inline pyarray<T>::pyarray(const shape_type& shape, const_reference value, layout l)
+    inline pyarray<T>::pyarray(const shape_type& shape, const_reference value, layout_type l)
         : base_type()
     {
         strides_type strides(shape.size());
@@ -415,7 +415,7 @@ namespace xt
     {
         shape_type shape = forward_sequence<shape_type>(e.derived_cast().shape());
         strides_type strides = make_sequence<strides_type>(shape.size(), size_type(0));
-        compute_strides(shape, layout::row_major, strides);
+        compute_strides(shape, layout_type::row_major, strides);
         init_array(shape, strides);
         semantic_base::assign(e);
     }
diff --git a/include/xtensor-python/pycontainer.hpp b/include/xtensor-python/pycontainer.hpp
@@ -80,10 +80,15 @@ namespace xt
         using broadcast_iterator = typename iterable_base::broadcast_iterator;
         using const_broadcast_iterator = typename iterable_base::broadcast_iterator;
 
+        static constexpr layout_type static_layout = layout_type::dynamic;
+        static constexpr bool contiguous_layout = false;
+
         void reshape(const shape_type& shape);
-        void reshape(const shape_type& shape, layout l);
+        void reshape(const shape_type& shape, layout_type l);
         void reshape(const shape_type& shape, const strides_type& strides);
 
+        layout_type layout() const;
+
         using base_type::operator();
         using base_type::operator[];
         using base_type::begin;
@@ -213,7 +218,7 @@ namespace xt
     {
         if (shape.size() != this->dimension() || !std::equal(shape.begin(), shape.end(), this->shape().begin()))
         {
-            reshape(shape, layout::row_major);
+            reshape(shape, layout_type::row_major);
         }
     }
 
@@ -223,7 +228,7 @@ namespace xt
      * @param l the new layout
      */
     template <class D>
-    inline void pycontainer<D>::reshape(const shape_type& shape, layout l)
+    inline void pycontainer<D>::reshape(const shape_type& shape, layout_type l)
     {
         strides_type strides = make_sequence<strides_type>(shape.size(), size_type(1));
         compute_strides(shape, l, strides);
@@ -242,6 +247,21 @@ namespace xt
         *static_cast<derived_type*>(this) = std::move(tmp);
     }
 
+    /**
+     * Return the layout_type of the container
+     * @return layout_type of the container
+     */
+    template <class D>
+    inline layout_type pycontainer<D>::layout() const
+    {
+        if (PyArray_CHKFLAGS(python_array(), NPY_ARRAY_C_CONTIGUOUS))
+            return layout_type::row_major;
+        else if (PyArray_CHKFLAGS(python_array(), NPY_ARRAY_F_CONTIGUOUS))
+            return layout_type::column_major;
+        else
+            return layout_type::dynamic;
+    }
+
     /**
      * Import the numpy Python module.
      */
diff --git a/include/xtensor-python/pytensor.hpp b/include/xtensor-python/pytensor.hpp
@@ -123,8 +123,8 @@ namespace xt
         pytensor(pybind11::handle h, pybind11::object::stolen_t);
         pytensor(const pybind11::object& o);
         
-        explicit pytensor(const shape_type& shape, layout l = layout::row_major);
-        explicit pytensor(const shape_type& shape, const_reference value, layout l = layout::row_major);
+        explicit pytensor(const shape_type& shape, layout_type l = layout_type::row_major);
+        explicit pytensor(const shape_type& shape, const_reference value, layout_type l = layout_type::row_major);
         explicit pytensor(const shape_type& shape, const strides_type& strides, const_reference value);
         explicit pytensor(const shape_type& shape, const strides_type& strides);
 
@@ -197,7 +197,7 @@ namespace xt
     inline pytensor<T, N>::pytensor(nested_initializer_list_t<T, N> t)
         : base_type()
     {
-        base_type::reshape(xt::shape<shape_type>(t), layout::row_major);
+        base_type::reshape(xt::shape<shape_type>(t), layout_type::row_major);
         nested_copy(m_data.begin(), t);
     }
 
@@ -226,10 +226,10 @@ namespace xt
      * Allocates an uninitialized pytensor with the specified shape and
      * layout.
      * @param shape the shape of the pytensor
-     * @param l the layout of the pytensor
+     * @param l the layout_type of the pytensor
      */
     template <class T, std::size_t N>
-    inline pytensor<T, N>::pytensor(const shape_type& shape, layout l)
+    inline pytensor<T, N>::pytensor(const shape_type& shape, layout_type l)
     {
         compute_strides(shape, l, m_strides);
         init_tensor(shape, m_strides);
@@ -240,12 +240,12 @@ namespace xt
      * are initialized to the specified value.
      * @param shape the shape of the pytensor
      * @param value the value of the elements
-     * @param l the layout of the pytensor
+     * @param l the layout_type of the pytensor
      */
     template <class T, std::size_t N>
     inline pytensor<T, N>::pytensor(const shape_type& shape,
                                     const_reference value,
-                                    layout l)
+                                    layout_type l)
     {
         compute_strides(shape, l, m_strides);
         init_tensor(shape, m_strides);
@@ -322,7 +322,7 @@ namespace xt
     {
         shape_type shape = forward_sequence<shape_type>(e.derived_cast().shape());
         strides_type strides = make_sequence<strides_type>(N, size_type(0));
-        compute_strides(shape, layout::row_major, strides);
+        compute_strides(shape, layout_type::row_major, strides);
         init_tensor(shape, strides);
         semantic_base::assign(e);
     }
diff --git a/test/test_common.hpp b/test/test_common.hpp
@@ -162,14 +162,14 @@ namespace xt
         {
             SCOPED_TRACE("row_major reshape");
             row_major_result<C> rm;
-            vec.reshape(rm.m_shape, layout::row_major);
+            vec.reshape(rm.m_shape, layout_type::row_major);
             compare_shape(vec, rm);
         }
 
         {
             SCOPED_TRACE("column_major reshape");
             column_major_result<C> cm;
-            vec.reshape(cm.m_shape, layout::column_major);
+            vec.reshape(cm.m_shape, layout_type::column_major);
             compare_shape(vec, cm);
         }
 
@@ -183,12 +183,14 @@ namespace xt
         {
             SCOPED_TRACE("unit_shape reshape");
             unit_shape_result<C> usr;
-            vec.reshape(usr.m_shape, layout::row_major);
+            vec.reshape(usr.m_shape, layout_type::row_major);
             compare_shape(vec, usr);
         }
     }
 
-    template <class V, class C = std::vector<std::size_t>>
+    // TODO: add back when in place transpose methods have been added
+    // into xtensor
+    /*template <class V, class C = std::vector<std::size_t>>
     void test_transpose(V& vec)
     {
         using inner_shape_type = typename V::inner_shape_type;
@@ -280,7 +282,7 @@ namespace xt
             EXPECT_THROW(vec.transpose({1, 2}, check_policy::full()), transpose_error);
             EXPECT_THROW(vec.transpose({3, 0, 1}, check_policy::full()), transpose_error);
         }
-    }
+    }*/
 
     template <class V1, class V2>
     void assign_array(V1& dst, const V2& src)
@@ -313,7 +315,7 @@ namespace xt
         {
             SCOPED_TRACE("row_major access");
             row_major_result<C> rm;
-            vec.reshape(rm.m_shape, layout::row_major);
+            vec.reshape(rm.m_shape, layout_type::row_major);
             assign_array(vec, rm.m_assigner);
             EXPECT_TRUE(std::equal(vec.data().cbegin(), vec.data().cend(), rm.m_data.cbegin()));
             EXPECT_EQ(vec(2, 1, 0), vec(2, 1));
@@ -324,7 +326,7 @@ namespace xt
         {
             SCOPED_TRACE("column_major access");
             column_major_result<C> cm;
-            vec.reshape(cm.m_shape, layout::column_major);
+            vec.reshape(cm.m_shape, layout_type::column_major);
             assign_array(vec, cm.m_assigner);
             EXPECT_TRUE(std::equal(vec.data().cbegin(), vec.data().cend(), cm.m_data.cbegin()));
             EXPECT_EQ(vec(2, 1, 0), vec(2, 1));
@@ -346,7 +348,7 @@ namespace xt
         {
             SCOPED_TRACE("unit_shape access");
             unit_shape_result<C> usr;
-            vec.reshape(usr.m_shape, layout::row_major);
+            vec.reshape(usr.m_shape, layout_type::row_major);
             assign_array(vec, usr.m_assigner);
             EXPECT_TRUE(std::equal(vec.data().cbegin(), vec.data().cend(), usr.m_data.cbegin()));
             EXPECT_EQ(vec(2, 0, 0), vec(2, 0));
@@ -382,7 +384,7 @@ namespace xt
         {
             SCOPED_TRACE("row_major access");
             row_major_result<C> rm;
-            vec.reshape(rm.m_shape, layout::row_major);
+            vec.reshape(rm.m_shape, layout_type::row_major);
             indexed_assign_array(vec, rm.m_assigner);
             EXPECT_TRUE(std::equal(vec.data().cbegin(), vec.data().cend(), rm.m_data.cbegin()));
             EXPECT_EQ(vec(2, 1, 0), vec[index1]);
@@ -392,7 +394,7 @@ namespace xt
         {
             SCOPED_TRACE("column_major access");
             column_major_result<C> cm;
-            vec.reshape(cm.m_shape, layout::column_major);
+            vec.reshape(cm.m_shape, layout_type::column_major);
             indexed_assign_array(vec, cm.m_assigner);
             EXPECT_TRUE(std::equal(vec.data().cbegin(), vec.data().cend(), cm.m_data.cbegin()));
             EXPECT_EQ(vec(2, 1, 0), vec[index1]);
@@ -412,7 +414,7 @@ namespace xt
         {
             SCOPED_TRACE("unit_shape access");
             unit_shape_result<C> usr;
-            vec.reshape(usr.m_shape, layout::row_major);
+            vec.reshape(usr.m_shape, layout_type::row_major);
             indexed_assign_array(vec, usr.m_assigner);
             EXPECT_TRUE(std::equal(vec.data().cbegin(), vec.data().cend(), usr.m_data.cbegin()));
             xindex id1 = { 2, 0 };
@@ -488,15 +490,15 @@ namespace xt
         {
             SCOPED_TRACE("row_major storage iterator");
             row_major_result<C> rm;
-            vec.reshape(rm.m_shape, layout::row_major);
+            vec.reshape(rm.m_shape, layout_type::row_major);
             std::copy(rm.data().cbegin(), rm.data().cend(), vec.begin());
             EXPECT_TRUE(std::equal(rm.data().cbegin(), rm.data().cend(), vec.data().cbegin()));
         }
 
         {
             SCOPED_TRACE("column_major storage iterator");
             column_major_result<C> cm;
-            vec.reshape(cm.m_shape, layout::column_major);
+            vec.reshape(cm.m_shape, layout_type::column_major);
             std::copy(cm.data().cbegin(), cm.data().cend(), vec.begin());
             EXPECT_TRUE(std::equal(cm.data().cbegin(), cm.data().cend(), vec.data().cbegin()));
         }
@@ -512,7 +514,7 @@ namespace xt
         {
             SCOPED_TRACE("unit_shape storage iterator");
             unit_shape_result<C> usr;
-            vec.reshape(usr.m_shape, layout::row_major);
+            vec.reshape(usr.m_shape, layout_type::row_major);
             std::copy(usr.data().cbegin(), usr.data().cend(), vec.begin());
             EXPECT_TRUE(std::equal(usr.data().cbegin(), usr.data().cend(), vec.data().cbegin()));
         }
diff --git a/test/test_pyarray.cpp b/test/test_pyarray.cpp
@@ -37,13 +37,15 @@ namespace xt
             row_major_result<> rm;
             pyarray<int> ra(rm.m_shape);
             compare_shape(ra, rm);
+            EXPECT_EQ(layout_type::row_major, ra.layout());
         }
         
         {
             SCOPED_TRACE("column_major constructor");
             column_major_result<> cm;
-            pyarray<int> ca(cm.m_shape, layout::column_major);
+            pyarray<int> ca(cm.m_shape, layout_type::column_major);
             compare_shape(ca, cm);
+            EXPECT_EQ(layout_type::column_major, ca.layout());
         }
     }
 
@@ -70,7 +72,7 @@ namespace xt
             SCOPED_TRACE("column_major valued constructor");
             column_major_result<> cm;
             int value = 2;
-            pyarray<int> ca(cm.m_shape, value, layout::column_major);
+            pyarray<int> ca(cm.m_shape, value, layout_type::column_major);
             compare_shape(ca, cm);
             std::vector<int> vec(ca.size(), value);
             EXPECT_TRUE(std::equal(vec.cbegin(), vec.cend(), ca.data().cbegin()));
diff --git a/test/test_pytensor.cpp b/test/test_pytensor.cpp

Original file line number	Diff line number	Diff line change
`@@ -145,8 +145,8 @@ namespace xt`
`145`	`145`	`pyarray(pybind11::handle h, pybind11::object::stolen_t);`
`146`	`146`	`pyarray(const pybind11::object &o);`
`147`	`147`
`148`		`- explicit pyarray(const shape_type& shape, layout l = layout::row_major);`
`149`		`- explicit pyarray(const shape_type& shape, const_reference value, layout l = layout::row_major);`
	`148`	`+ explicit pyarray(const shape_type& shape, layout_type l = layout_type::row_major);`
	`149`	`+ explicit pyarray(const shape_type& shape, const_reference value, layout_type l = layout_type::row_major);`
`150`	`150`	`explicit pyarray(const shape_type& shape, const strides_type& strides, const_reference value);`
`151`	`151`	`explicit pyarray(const shape_type& shape, const strides_type& strides);`
`152`	`152`
`@@ -238,47 +238,47 @@ namespace xt`
`238`	`238`	`inline pyarray<T>::pyarray(const value_type& t)`
`239`	`239`	`: base_type()`
`240`	`240`	`{`
`241`		`- base_type::reshape(xt::shape<shape_type>(t), layout::row_major);`
	`241`	`+ base_type::reshape(xt::shape<shape_type>(t), layout_type::row_major);`
`242`	`242`	`nested_copy(m_data.begin(), t);`
`243`	`243`	`}`
`244`	`244`
`245`	`245`	`template <class T>`
`246`	`246`	`inline pyarray<T>::pyarray(nested_initializer_list_t<T, 1> t)`
`247`	`247`	`: base_type()`
`248`	`248`	`{`
`249`		`- base_type::reshape(xt::shape<shape_type>(t), layout::row_major);`
	`249`	`+ base_type::reshape(xt::shape<shape_type>(t), layout_type::row_major);`
`250`	`250`	`nested_copy(m_data.begin(), t);`
`251`	`251`	`}`
`252`	`252`
`253`	`253`	`template <class T>`
`254`	`254`	`inline pyarray<T>::pyarray(nested_initializer_list_t<T, 2> t)`
`255`	`255`	`: base_type()`
`256`	`256`	`{`
`257`		`- base_type::reshape(xt::shape<shape_type>(t), layout::row_major);`
	`257`	`+ base_type::reshape(xt::shape<shape_type>(t), layout_type::row_major);`
`258`	`258`	`nested_copy(m_data.begin(), t);`
`259`	`259`	`}`
`260`	`260`
`261`	`261`	`template <class T>`
`262`	`262`	`inline pyarray<T>::pyarray(nested_initializer_list_t<T, 3> t)`
`263`	`263`	`: base_type()`
`264`	`264`	`{`
`265`		`- base_type::reshape(xt::shape<shape_type>(t), layout::row_major);`
	`265`	`+ base_type::reshape(xt::shape<shape_type>(t), layout_type::row_major);`
`266`	`266`	`nested_copy(m_data.begin(), t);`
`267`	`267`	`}`
`268`	`268`
`269`	`269`	`template <class T>`
`270`	`270`	`inline pyarray<T>::pyarray(nested_initializer_list_t<T, 4> t)`
`271`	`271`	`: base_type()`
`272`	`272`	`{`
`273`		`- base_type::reshape(xt::shape<shape_type>(t), layout::row_major);`
	`273`	`+ base_type::reshape(xt::shape<shape_type>(t), layout_type::row_major);`
`274`	`274`	`nested_copy(m_data.begin(), t);`
`275`	`275`	`}`
`276`	`276`
`277`	`277`	`template <class T>`
`278`	`278`	`inline pyarray<T>::pyarray(nested_initializer_list_t<T, 5> t)`
`279`	`279`	`: base_type()`
`280`	`280`	`{`
`281`		`- base_type::reshape(xt::shape<shape_type>(t), layout::row_major);`
	`281`	`+ base_type::reshape(xt::shape<shape_type>(t), layout_type::row_major);`
`282`	`282`	`nested_copy(m_data.begin(), t);`
`283`	`283`	`}`
`284`	`284`
`@@ -310,7 +310,7 @@ namespace xt`
`310`	`310`	`* @param l the layout of the pyarray`
`311`	`311`	`*/`
`312`	`312`	`template <class T>`
`313`		`- inline pyarray<T>::pyarray(const shape_type& shape, layout l)`
	`313`	`+ inline pyarray<T>::pyarray(const shape_type& shape, layout_type l)`
`314`	`314`	`: base_type()`
`315`	`315`	`{`
`316`	`316`	`strides_type strides(shape.size());`
`@@ -326,7 +326,7 @@ namespace xt`
`326`	`326`	`* @param l the layout of the pyarray`
`327`	`327`	`*/`
`328`	`328`	`template <class T>`
`329`		`- inline pyarray<T>::pyarray(const shape_type& shape, const_reference value, layout l)`
	`329`	`+ inline pyarray<T>::pyarray(const shape_type& shape, const_reference value, layout_type l)`
`330`	`330`	`: base_type()`
`331`	`331`	`{`
`332`	`332`	`strides_type strides(shape.size());`
`@@ -415,7 +415,7 @@ namespace xt`
`415`	`415`	`{`
`416`	`416`	`shape_type shape = forward_sequence<shape_type>(e.derived_cast().shape());`
`417`	`417`	`strides_type strides = make_sequence<strides_type>(shape.size(), size_type(0));`
`418`		`- compute_strides(shape, layout::row_major, strides);`
	`418`	`+ compute_strides(shape, layout_type::row_major, strides);`
`419`	`419`	`init_array(shape, strides);`
`420`	`420`	`semantic_base::assign(e);`
`421`	`421`	`}`
Original file line number	Diff line number	Diff line change
`@@ -162,14 +162,14 @@ namespace xt`
`162`	`162`	`{`
`163`	`163`	`SCOPED_TRACE("row_major reshape");`
`164`	`164`	`row_major_result<C> rm;`
`165`		`- vec.reshape(rm.m_shape, layout::row_major);`
	`165`	`+ vec.reshape(rm.m_shape, layout_type::row_major);`
`166`	`166`	`compare_shape(vec, rm);`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`{`
`170`	`170`	`SCOPED_TRACE("column_major reshape");`
`171`	`171`	`column_major_result<C> cm;`
`172`		`- vec.reshape(cm.m_shape, layout::column_major);`
	`172`	`+ vec.reshape(cm.m_shape, layout_type::column_major);`
`173`	`173`	`compare_shape(vec, cm);`
`174`	`174`	`}`
`175`	`175`
`@@ -183,12 +183,14 @@ namespace xt`
`183`	`183`	`{`
`184`	`184`	`SCOPED_TRACE("unit_shape reshape");`
`185`	`185`	`unit_shape_result<C> usr;`
`186`		`- vec.reshape(usr.m_shape, layout::row_major);`
	`186`	`+ vec.reshape(usr.m_shape, layout_type::row_major);`
`187`	`187`	`compare_shape(vec, usr);`
`188`	`188`	`}`
`189`	`189`	`}`
`190`	`190`
`191`		`- template <class V, class C = std::vector<std::size_t>>`
	`191`	`+ // TODO: add back when in place transpose methods have been added`
	`192`	`+ // into xtensor`
	`193`	`+ /*template <class V, class C = std::vector<std::size_t>>`
`192`	`194`	`void test_transpose(V& vec)`
`193`	`195`	`{`
`194`	`196`	`using inner_shape_type = typename V::inner_shape_type;`
`@@ -280,7 +282,7 @@ namespace xt`
`280`	`282`	`EXPECT_THROW(vec.transpose({1, 2}, check_policy::full()), transpose_error);`
`281`	`283`	`EXPECT_THROW(vec.transpose({3, 0, 1}, check_policy::full()), transpose_error);`
`282`	`284`	`}`
`283`		`- }`
	`285`	`+ }*/`
`284`	`286`
`285`	`287`	`template <class V1, class V2>`
`286`	`288`	`void assign_array(V1& dst, const V2& src)`
`@@ -313,7 +315,7 @@ namespace xt`
`313`	`315`	`{`
`314`	`316`	`SCOPED_TRACE("row_major access");`
`315`	`317`	`row_major_result<C> rm;`
`316`		`- vec.reshape(rm.m_shape, layout::row_major);`
	`318`	`+ vec.reshape(rm.m_shape, layout_type::row_major);`
`317`	`319`	`assign_array(vec, rm.m_assigner);`
`318`	`320`	`EXPECT_TRUE(std::equal(vec.data().cbegin(), vec.data().cend(), rm.m_data.cbegin()));`
`319`	`321`	`EXPECT_EQ(vec(2, 1, 0), vec(2, 1));`
`@@ -324,7 +326,7 @@ namespace xt`
`324`	`326`	`{`
`325`	`327`	`SCOPED_TRACE("column_major access");`
`326`	`328`	`column_major_result<C> cm;`
`327`		`- vec.reshape(cm.m_shape, layout::column_major);`
	`329`	`+ vec.reshape(cm.m_shape, layout_type::column_major);`
`328`	`330`	`assign_array(vec, cm.m_assigner);`
`329`	`331`	`EXPECT_TRUE(std::equal(vec.data().cbegin(), vec.data().cend(), cm.m_data.cbegin()));`
`330`	`332`	`EXPECT_EQ(vec(2, 1, 0), vec(2, 1));`
`@@ -346,7 +348,7 @@ namespace xt`
`346`	`348`	`{`
`347`	`349`	`SCOPED_TRACE("unit_shape access");`
`348`	`350`	`unit_shape_result<C> usr;`
`349`		`- vec.reshape(usr.m_shape, layout::row_major);`
	`351`	`+ vec.reshape(usr.m_shape, layout_type::row_major);`
`350`	`352`	`assign_array(vec, usr.m_assigner);`
`351`	`353`	`EXPECT_TRUE(std::equal(vec.data().cbegin(), vec.data().cend(), usr.m_data.cbegin()));`
`352`	`354`	`EXPECT_EQ(vec(2, 0, 0), vec(2, 0));`
`@@ -382,7 +384,7 @@ namespace xt`
`382`	`384`	`{`
`383`	`385`	`SCOPED_TRACE("row_major access");`
`384`	`386`	`row_major_result<C> rm;`
`385`		`- vec.reshape(rm.m_shape, layout::row_major);`
	`387`	`+ vec.reshape(rm.m_shape, layout_type::row_major);`
`386`	`388`	`indexed_assign_array(vec, rm.m_assigner);`
`387`	`389`	`EXPECT_TRUE(std::equal(vec.data().cbegin(), vec.data().cend(), rm.m_data.cbegin()));`
`388`	`390`	`EXPECT_EQ(vec(2, 1, 0), vec[index1]);`
`@@ -392,7 +394,7 @@ namespace xt`
`392`	`394`	`{`
`393`	`395`	`SCOPED_TRACE("column_major access");`
`394`	`396`	`column_major_result<C> cm;`
`395`		`- vec.reshape(cm.m_shape, layout::column_major);`
	`397`	`+ vec.reshape(cm.m_shape, layout_type::column_major);`
`396`	`398`	`indexed_assign_array(vec, cm.m_assigner);`
`397`	`399`	`EXPECT_TRUE(std::equal(vec.data().cbegin(), vec.data().cend(), cm.m_data.cbegin()));`
`398`	`400`	`EXPECT_EQ(vec(2, 1, 0), vec[index1]);`
`@@ -412,7 +414,7 @@ namespace xt`
`412`	`414`	`{`
`413`	`415`	`SCOPED_TRACE("unit_shape access");`
`414`	`416`	`unit_shape_result<C> usr;`
`415`		`- vec.reshape(usr.m_shape, layout::row_major);`
	`417`	`+ vec.reshape(usr.m_shape, layout_type::row_major);`
`416`	`418`	`indexed_assign_array(vec, usr.m_assigner);`
`417`	`419`	`EXPECT_TRUE(std::equal(vec.data().cbegin(), vec.data().cend(), usr.m_data.cbegin()));`
`418`	`420`	`xindex id1 = { 2, 0 };`
`@@ -488,15 +490,15 @@ namespace xt`
`488`	`490`	`{`
`489`	`491`	`SCOPED_TRACE("row_major storage iterator");`
`490`	`492`	`row_major_result<C> rm;`
`491`		`- vec.reshape(rm.m_shape, layout::row_major);`
	`493`	`+ vec.reshape(rm.m_shape, layout_type::row_major);`
`492`	`494`	`std::copy(rm.data().cbegin(), rm.data().cend(), vec.begin());`
`493`	`495`	`EXPECT_TRUE(std::equal(rm.data().cbegin(), rm.data().cend(), vec.data().cbegin()));`
`494`	`496`	`}`
`495`	`497`
`496`	`498`	`{`
`497`	`499`	`SCOPED_TRACE("column_major storage iterator");`
`498`	`500`	`column_major_result<C> cm;`
`499`		`- vec.reshape(cm.m_shape, layout::column_major);`
	`501`	`+ vec.reshape(cm.m_shape, layout_type::column_major);`
`500`	`502`	`std::copy(cm.data().cbegin(), cm.data().cend(), vec.begin());`
`501`	`503`	`EXPECT_TRUE(std::equal(cm.data().cbegin(), cm.data().cend(), vec.data().cbegin()));`
`502`	`504`	`}`
`@@ -512,7 +514,7 @@ namespace xt`
`512`	`514`	`{`
`513`	`515`	`SCOPED_TRACE("unit_shape storage iterator");`
`514`	`516`	`unit_shape_result<C> usr;`
`515`		`- vec.reshape(usr.m_shape, layout::row_major);`
	`517`	`+ vec.reshape(usr.m_shape, layout_type::row_major);`
`516`	`518`	`std::copy(usr.data().cbegin(), usr.data().cend(), vec.begin());`
`517`	`519`	`EXPECT_TRUE(std::equal(usr.data().cbegin(), usr.data().cend(), vec.data().cbegin()));`
`518`	`520`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,13 +37,15 @@ namespace xt`
`37`	`37`	`row_major_result<> rm;`
`38`	`38`	`pyarray<int> ra(rm.m_shape);`
`39`	`39`	`compare_shape(ra, rm);`
	`40`	`+ EXPECT_EQ(layout_type::row_major, ra.layout());`
`40`	`41`	`}`
`41`	`42`
`42`	`43`	`{`
`43`	`44`	`SCOPED_TRACE("column_major constructor");`
`44`	`45`	`column_major_result<> cm;`
`45`		`- pyarray<int> ca(cm.m_shape, layout::column_major);`
	`46`	`+ pyarray<int> ca(cm.m_shape, layout_type::column_major);`
`46`	`47`	`compare_shape(ca, cm);`
	`48`	`+ EXPECT_EQ(layout_type::column_major, ca.layout());`
`47`	`49`	`}`
`48`	`50`	`}`
`49`	`51`
`@@ -70,7 +72,7 @@ namespace xt`
`70`	`72`	`SCOPED_TRACE("column_major valued constructor");`
`71`	`73`	`column_major_result<> cm;`
`72`	`74`	`int value = 2;`
`73`		`- pyarray<int> ca(cm.m_shape, value, layout::column_major);`
	`75`	`+ pyarray<int> ca(cm.m_shape, value, layout_type::column_major);`
`74`	`76`	`compare_shape(ca, cm);`
`75`	`77`	`std::vector<int> vec(ca.size(), value);`
`76`	`78`	`EXPECT_TRUE(std::equal(vec.cbegin(), vec.cend(), ca.data().cbegin()));`