addressed issues from review

Author: DerThorsten

include/xtensor/xblockwise_reducer.hpp

@@ -6,7 +6,7 @@
 
 #include "xshape.hpp"
 #include "xblockwise_reducer_functors.hpp"
-#include "xgrid_iterator.hpp"
+#include "xmultiindex_iterator.hpp"
 #include "xreducer.hpp"
 
 namespace xt
@@ -50,12 +50,13 @@ class xblockwise_reducer
     using mapping_type = filter_fixed_shape_t<shape_type>;
     using input_chunked_view_type = xchunked_view<const std::decay_t<CT> &>;
     using input_const_chunked_iterator_type = typename input_chunked_view_type::const_chunk_iterator;
+    using input_chunk_range_type = std::array<xmultiindex_iterator<input_chunk_index_type>, 2>;
 
     template<class CI>
     void assign_to_chunk(CI & result_chunk_iter) const;
 
     template<class CI>
-    std::array<xsubgrid_iterator<input_chunk_index_type>, 2> compute_input_chunk_range(CI & result_chunk_iter) const;
+    input_chunk_range_type compute_input_chunk_range(CI & result_chunk_iter) const;
 
     input_const_chunked_iterator_type get_input_chunk_iter(input_chunk_index_type  input_chunk_index) const;
     void init_shapes();
@@ -184,12 +185,14 @@ void xblockwise_reducer<CT, F, X, O>::assign_to_chunk(CI & result_chunk_iter) co
 
 template<class CT, class F, class X, class O>
 template<class CI>
-auto xblockwise_reducer<CT, F, X, O>::compute_input_chunk_range(CI & result_chunk_iter) const -> std::array<xsubgrid_iterator<input_chunk_index_type>, 2>
+auto xblockwise_reducer<CT, F, X, O>::compute_input_chunk_range(CI & result_chunk_iter) const -> input_chunk_range_type
 {
-    auto input_chunks_begin = construct_container_with_size<input_chunk_index_type>(m_e_chunked_view.dimension());
-    auto input_chunks_end = construct_container_with_size<input_chunk_index_type>(m_e_chunked_view.dimension());
+    auto input_chunks_begin = xtl::make_sequence<input_chunk_index_type>(m_e_chunked_view.dimension(), 0);
+    auto input_chunks_end = xtl::make_sequence<input_chunk_index_type>(m_e_chunked_view.dimension());
+
+    XTENSOR_ASSERT(input_chunks_begin.size() == m_e_chunked_view.dimension());
+    XTENSOR_ASSERT(input_chunks_end.size() == m_e_chunked_view.dimension());
 
-    std::fill(input_chunks_begin.begin(), input_chunks_begin.end(), 0);
     std::copy(m_e_chunked_view.grid_shape().begin(), m_e_chunked_view.grid_shape().end(),  input_chunks_end.begin());
 
     const auto & chunk_index = result_chunk_iter.chunk_index();
@@ -202,9 +205,9 @@ auto xblockwise_reducer<CT, F, X, O>::compute_input_chunk_range(CI & result_chun
             input_chunks_end[input_ax_index] = chunk_index[result_ax_index] + 1;
         }
     }
-    return std::array<xsubgrid_iterator<input_chunk_index_type>, 2>{
-        subgrid_iterator_begin<input_chunk_index_type>(input_chunks_begin, input_chunks_end), 
-        subgrid_iterator_end<input_chunk_index_type>(input_chunks_begin, input_chunks_end)
+    return input_chunk_range_type{
+        multiindex_iterator_begin<input_chunk_index_type>(input_chunks_begin, input_chunks_end), 
+        multiindex_iterator_end<input_chunk_index_type>(input_chunks_begin, input_chunks_end)
     };
 }
 
@@ -318,7 +321,8 @@ namespace blockwise
         {\
             using input_expression_type = std::decay_t<E>;\
             using axes_type = filter_fixed_shape_t<typename input_expression_type::shape_type>;\
-            axes_type axes = construct_container_with_size<axes_type>(e.dimension());\
+            axes_type axes = xtl::make_sequence<axes_type>(e.dimension());\
+            XTENSOR_ASSERT(axes.dimension() == e.dimension());\
             std::iota(axes.begin(), axes.end(), 0);\
             using functor_type = FUNCTOR <typename input_expression_type::value_type, T>;\
             return blockwise_reducer(\
@@ -392,7 +396,8 @@ namespace blockwise
         {\
             using input_expression_type = std::decay_t<E>;\
             using axes_type = filter_fixed_shape_t<typename input_expression_type::shape_type>;\
-            axes_type axes = construct_container_with_size<axes_type>(e.dimension());\
+            axes_type axes = xtl::make_sequence<axes_type>(e.dimension());\
+            XTENSOR_ASSERT(axes.dimension() == e.dimension());\
             std::iota(axes.begin(), axes.end(), 0);\
             using functor_type = FUNCTOR <typename input_expression_type::value_type>;\
             return blockwise_reducer(\
@@ -462,7 +467,8 @@ namespace blockwise
         {\
             using input_expression_type = std::decay_t<E>;\
             using axes_type = filter_fixed_shape_t<typename input_expression_type::shape_type>;\
-            axes_type axes = construct_container_with_size<axes_type>(e.dimension());\
+            axes_type axes = xtl::make_sequence<axes_type>(e.dimension());\
+            XTENSOR_ASSERT(axes.dimension() == e.dimension());\
             std::iota(axes.begin(), axes.end(), 0);\
             using functor_type = FUNCTOR <typename input_expression_type::value_type>;\
             return blockwise_reducer(\

include/xtensor/xgrid_iterator.hpp renamed to include/xtensor/xmultiindex_iterator.hpp

@@ -7,8 +7,8 @@
 * The full license is in the file LICENSE, distributed with this software. *
 ****************************************************************************/
 
-#ifndef XTENSOR_XGRID_ITERATOR
-#define XTENSOR_XGRID_ITERATOR
+#ifndef XTENSOR_XMULTIINDEX_ITERATOR
+#define XTENSOR_XMULTIINDEX_ITERATOR
 
 #include "xtl/xsequence.hpp"
 
@@ -19,10 +19,10 @@ namespace xt
 {
 
     template<class S>
-    class xsubgrid_iterator
+    class xmultiindex_iterator
     {
     public:
-        using self_type = xsubgrid_iterator<S>;
+        using self_type = xmultiindex_iterator<S>;
         using shape_type = S;
 
         using value_type = shape_type;
@@ -31,14 +31,10 @@ namespace xt
         using difference_type = std::size_t;
         using iterator_category = std::forward_iterator_tag;
 
-        xsubgrid_iterator() = default;
-        xsubgrid_iterator(const xsubgrid_iterator&) = default;
-        xsubgrid_iterator(xsubgrid_iterator&&) = default;
-        xsubgrid_iterator& operator=(const xsubgrid_iterator&) = default;
-        xsubgrid_iterator& operator=(xsubgrid_iterator&&) = default;    
+        xmultiindex_iterator() = default;
 
         template<class B, class E, class C>
-        xsubgrid_iterator(B && begin, E && end, C && current, const std::size_t linear_index)
+        xmultiindex_iterator(B && begin, E && end, C && current, const std::size_t linear_index)
         :   m_begin(std::forward<B>(begin)),
             m_end(std::forward<E>(end)),
             m_current(std::forward<C>(current)),
@@ -100,12 +96,12 @@ namespace xt
 
 
     template<class S, class B, class E>
-    auto subgrid_iterator_begin(B && roi_begin, E && roi_end)
+    auto multiindex_iterator_begin(B && roi_begin, E && roi_end)
     {
         S current;
         resize_container(current, roi_begin.size());
         std::copy(roi_begin.begin(), roi_begin.end(), current.begin());
-        return xsubgrid_iterator<S>(
+        return xmultiindex_iterator<S>(
             std::forward<B>(roi_begin),
             std::forward<E>(roi_end),
             std::move(current),
@@ -114,7 +110,7 @@ namespace xt
     }
 
     template<class S, class B, class E>
-    auto subgrid_iterator_end(B && roi_begin, E && roi_end)
+    auto multiindex_iterator_end(B && roi_begin, E && roi_end)
     {
         S current;
         resize_container(current, roi_begin.size());
@@ -126,7 +122,7 @@ namespace xt
             linear_index *= roi_end[i] - roi_begin[i];
         }
 
-        return xsubgrid_iterator<S>(
+        return xmultiindex_iterator<S>(
             std::forward<B>(roi_begin),
             std::forward<E>(roi_end),
             std::move(current),

include/xtensor/xutils.hpp

@@ -331,72 +331,6 @@ namespace xt
         }
     }
 
-    /***********************************
-     * construct_container_with_size implementation *
-     ***********************************/
-    namespace detail
-    {
-
-        template<class C>
-        struct construct_container_with_size_impl
-        {
-            static C op(typename C::size_type size)
-            {
-                C c;
-                const bool success = resize_container(c, size);
-                if(!success)
-                {
-                    XTENSOR_THROW(std::runtime_error, "cannot resize container to given size");
-                }
-                c.resize(size);
-                return c;
-            }
-        };
-
-        template <class T, class A>
-        struct construct_container_with_size_impl<std::vector<T,A>>
-        {
-            using container_type = std::vector<T,A>;
-            static container_type op(typename container_type::size_type size)
-            {
-                return container_type(size);
-            }
-        };
-
-        template <class T, std::size_t N>
-        struct construct_container_with_size_impl<std::array<T, N>>
-        {
-            using container_type = std::array<T, N>;
-            static container_type op(typename container_type::size_type size)
-            {
-                if(size != N)
-                {
-                    XTENSOR_THROW(std::runtime_error, "cannot resize container to given size");
-                }
-                return container_type{};
-            }
-        };
-
-        template <std::size_t... I>
-        struct construct_container_with_size_impl<xt::fixed_shape<I...>>
-        {
-            using container_type = xt::fixed_shape<I...>;
-            static container_type op(std::size_t size)
-            {
-                if(sizeof...(I) != size)
-                {
-                    XTENSOR_THROW(std::runtime_error, "cannot resize container to given size");
-                }
-                return container_type{};
-            }
-        };
-    }
-
-    template <class C, class S>
-    inline C construct_container_with_size(S size)
-    {
-        return detail::construct_container_with_size_impl<C>::op(size);
-    }
     /***********************************
      * resize_container implementation *
      ***********************************/

test/CMakeLists.txt

@@ -143,7 +143,7 @@ set(COMMON_BASE
     test_xexpression_traits.cpp
     test_xfunction.cpp
     test_xfunc_on_xexpression.cpp
-    test_xgrid_iterator.cpp
+    test_xmultiindex_iterator.cpp
     test_xiterator.cpp
     test_xmath.cpp
     test_xoperation.cpp

test/test_xgrid_iterator.cpp renamed to test/test_xmultiindex_iterator.cpp

@@ -1,18 +1,18 @@
 #include "test_common.hpp"
 #include <vector>
 
-#include "xtensor/xgrid_iterator.hpp"
+#include "xtensor/xmultiindex_iterator.hpp"
 
 namespace xt
 {
 
-TEST_SUITE("xgrid_iterator")
+TEST_SUITE("xmultiindex_iterator")
 {
 
     TEST_CASE("sum")
     {   
         using shape_type = std::vector<std::size_t>;
-        using iter_type = xsubgrid_iterator<shape_type>;
+        using iter_type = xmultiindex_iterator<shape_type>;
 
         shape_type roi_begin{2,3,4};
         shape_type roi_end{3,5,6};