Fix xview::element when a newaxis precedes an integral slice

make_index maps each dimension i of the underlying expression to its
slice k, then to the position of that slice in the view index:
k minus the number of integral slices before it. It counted the
integral slices before i instead of before k. The two differ when a
newaxis comes before an integral slice, so the wrong index was read:

    xt::xarray<int> a = {{0, 1, 2}, {3, 4, 5}};
    auto v = xt::view(a, xt::newaxis(), 1, xt::all());
    v[{0, 2}];  // returned 3 instead of 5

operator() already used the slice position. element(), and the
operator[] and at-style accesses built on it, now do too.

Author: gouarin

include/xtensor/views/xview.hpp

@@ -1707,7 +1707,7 @@ namespace xt
 
             // need to advance captured `first`
             first = first_copy;
-            std::advance(first, static_cast<diff_type>(k - xt::integral_count_before<S...>(i)));
+            std::advance(first, static_cast<diff_type>(k - xt::integral_count_before<S...>(k)));
 
             if (first < last)
             {

test/test_xview.cpp

@@ -1736,6 +1736,28 @@ namespace xt
         EXPECT_EQ(res, 2);
     }
 
+    TEST(xview, element_newaxis_before_integral)
+    {
+        xarray<int> a = xt::arange<int>(24).reshape({2, 3, 4});
+
+        // The newaxis shifts the view dimensions that follow the integral slice.
+        auto v = view(a, newaxis(), 1, all());
+        auto w = view(a, newaxis(), keep(1), 0, newaxis(), drop(0, 3));
+        for (std::size_t j = 0; j < 3; ++j)
+        {
+            for (std::size_t k = 0; k < 4; ++k)
+            {
+                xindex idx = {0, j, k};
+                EXPECT_EQ(v[idx], a(1, j, k));
+            }
+        }
+        for (std::size_t k = 0; k < 2; ++k)
+        {
+            xindex idx = {0, 0, 0, k};
+            EXPECT_EQ(w[idx], a(1, 0, k + 1));
+        }
+    }
+
     TEST(xview, view_reshape_view)
     {
         xtensor<int, 1> a = {0, 1, 2};