Merge remote-tracking branch 'upstream/master'

Author: Alex-PLACET

include/xtensor/containers/xstorage.hpp

@@ -1640,6 +1640,16 @@ namespace xt
             return m_array.cend();
         }
 
+        auto crbegin() const
+        {
+            return m_array.crbegin();
+        }
+
+        auto crend() const
+        {
+            return m_array.crend();
+        }
+
         constexpr std::size_t operator[](std::size_t idx) const
         {
             return m_array[idx];

include/xtensor/generators/xbuilder.hpp

@@ -910,6 +910,32 @@ namespace xt
 
     namespace detail
     {
+        template <class S>
+        struct vstack_fixed_shape_impl;
+
+        template <std::size_t N>
+        struct vstack_fixed_shape_impl<fixed_shape<N>>
+        {
+            using type = fixed_shape<1, N>;
+        };
+
+        template <std::size_t I, std::size_t... J>
+        struct vstack_fixed_shape_impl<fixed_shape<I, J...>>
+        {
+            using type = fixed_shape<I, J...>;
+        };
+
+        template <class... CT>
+        struct vstack_fixed_shape
+        {
+            using type = concat_fixed_shape_t<
+                0,
+                typename vstack_fixed_shape_impl<typename std::decay_t<CT>::shape_type>::type...>;
+        };
+
+        template <class... CT>
+        using vstack_fixed_shape_t = typename vstack_fixed_shape<CT...>::type;
+
         template <class S, class... CT>
         inline auto vstack_shape(std::tuple<CT...>& t, const S& shape)
         {
@@ -948,6 +974,21 @@ namespace xt
         return detail::make_xgenerator(detail::vstack_impl<CT...>(std::move(t), size_t(0)), new_shape);
     }
 
+    /**
+     * @brief Stack fixed-shape xexpressions in sequence vertically (row wise).
+     * This overload preserves the result shape at compile time by treating
+     * 1-D fixed shapes as ``(1, N)`` row vectors before concatenation.
+     *
+     * @param t \ref xtuple of fixed-shape xexpressions to stack
+     * @return xgenerator evaluating to stacked elements with a fixed compile-time shape
+     */
+    template <fixed_shape_container_concept... CT>
+    inline auto vstack(std::tuple<CT...>&& t)
+    {
+        using shape_type = detail::vstack_fixed_shape_t<CT...>;
+        return detail::make_xgenerator(detail::vstack_impl<CT...>(std::move(t), size_t(0)), shape_type{});
+    }
+
     namespace detail
     {
 

include/xtensor/views/index_mapper.hpp

@@ -193,7 +193,7 @@ namespace xt
          * @throws Assertion failure if `i != 0` for integral slices.
          * @throws Assertion failure if `i >= slice.size()` for non-integral slices.
          */
-        template <size_t I, std::integral Index>
+        template <access_t ACCESS, size_t I, std::integral Index>
         size_t map_ith_index(const view_type& view, const Index i) const;
 
         /**
@@ -490,16 +490,16 @@ namespace xt
     {
         if constexpr (ACCESS == access_t::SAFE)
         {
-            return container.at(map_ith_index<Is>(view, indices[Is])...);
+            return container.at(map_ith_index<ACCESS, Is>(view, indices[Is])...);
         }
         else
         {
-            return container(map_ith_index<Is>(view, indices[Is])...);
+            return container(map_ith_index<ACCESS, Is>(view, indices[Is])...);
         }
     }
 
     template <class UnderlyingContainer, class... Slices>
-    template <size_t I, std::integral Index>
+    template <access_t ACCESS, size_t I, std::integral Index>
     auto
     index_mapper<xt::xview<UnderlyingContainer, Slices...>>::map_ith_index(const view_type& view, const Index i) const
         -> size_t
@@ -518,10 +518,17 @@ namespace xt
                 assert(i == 0);
                 return size_t(slice);
             }
+            else if constexpr (xt::detail::is_xall_slice<std::decay_t<current_slice>>::value)
+            {
+                return size_t(i);
+            }
             else
             {
                 using slice_size_type = typename current_slice::size_type;
-                assert(i < slice.size());
+                if constexpr (ACCESS == access_t::UNSAFE)
+                {
+                    assert(static_cast<slice_size_type>(i) < slice.size());
+                }
                 return size_t(slice(static_cast<slice_size_type>(i)));
             }
         }

include/xtensor/views/xslice.hpp

@@ -484,7 +484,7 @@ namespace xt
     template <class R = std::ptrdiff_t, class T>
     inline auto drop(T&& indices)
     {
-        if constexpr (xtl::is_integral<T>::value)
+        if constexpr (xtl::is_integral<std::remove_cvref_t<T>>::value)
         {
             using slice_type = xdrop_slice<R>;
             using container_type = typename slice_type::container_type;

test/test_xbuilder.cpp

@@ -424,6 +424,21 @@ namespace xt
         ASSERT_TRUE(arange(8) == w1);
         ASSERT_TRUE(w1 == w2);
     }
+
+    TEST(xbuilder, vstack_fixed)
+    {
+        xtensor_fixed<float, fixed_shape<1, 2>> a = {{1.f, 2.f}};
+        xtensor_fixed<float, fixed_shape<2, 2>> b = {{3.f, 4.f}, {5.f, 6.f}};
+
+        auto c = vstack(xtuple(a, b));
+
+        using expected_shape_t = fixed_shape<3, 2>;
+        ASSERT_EQ(expected_shape_t{}, c.shape());
+        EXPECT_EQ(1.f, c(0, 0));
+        EXPECT_EQ(2.f, c(0, 1));
+        EXPECT_EQ(3.f, c(1, 0));
+        EXPECT_EQ(6.f, c(2, 1));
+    }
 #endif
 
     TEST(xbuilder, access)

test/test_xfixed.cpp

@@ -22,6 +22,7 @@
 #include "xtensor/core/xnoalias.hpp"
 #include "xtensor/io/xio.hpp"
 #include "xtensor/misc/xmanipulation.hpp"
+#include "xtensor/views/xview.hpp"
 
 #include "test_common_macros.hpp"
 
@@ -306,6 +307,13 @@ namespace xt
         using tiny_tensor = xtensor_fixed<double, xshape<2>, layout_type::row_major, false>;
         EXPECT_GT(sizeof(fixed_tensor), sizeof(tiny_tensor));
     }
+
+    TEST(xtensor_fixed, iterators)
+    {
+        auto arr = xt::xtensor<double, 1>({5, 5, 5, 5, 5});
+        auto fixed_arr = xt::xtensor_fixed<double, xt::xshape<3>>{1, 2, 3};
+        xt::view(arr, xt::range(0, 3)) = fixed_arr + 1;
+    }
 }
 
 #endif

test/test_xoperation.cpp

@@ -858,6 +858,29 @@ namespace xt
             EXPECT_EQ(expected1, res3);
             EXPECT_EQ(expected2, res4);
         }
+
+        TEST_CASE("divide_4d")
+        {
+            using T4 = xt::xtensor<float, 4, xt::layout_type::row_major>;
+            using shape_type = typename T4::shape_type;
+
+            shape_type shape = {2, 3, 2, 2};
+            T4 a(shape, 4.5f);
+            T4 b(shape, 1.3f);
+
+            EXPECT_EQ((a / b)(0, 0, 0, 0), a(0, 0, 0, 0) / b(0, 0, 0, 0));
+
+            float sb = 1.2f;
+            EXPECT_EQ((a / sb)(0, 0, 0, 0), a(0, 0, 0, 0) / sb);
+
+            float sa = 4.6f;
+            EXPECT_EQ((sa / b)(0, 0, 0, 0), sa / b(0, 0, 0, 0));
+
+            // self-divide assignment: a = a / b (no zeros in b)
+            auto a_before = a(1, 2, 1, 1);
+            a = a / b;
+            EXPECT_EQ(a(1, 2, 1, 1), a_before / b(1, 2, 1, 1));
+        }
     }
 
 #undef XOPERATION_TEST_TYPES

test/test_xview.cpp

@@ -1861,4 +1861,23 @@ namespace xt
 
         XT_ASSERT_THROW(const auto col = xt::col(arr, 0), std::invalid_argument);
     }
+
+    TEST(xview, drop_on_1dim_array)
+    {
+        auto my_array = xt::xtensor<double, 1>({1, 2, 3});
+
+        // drop(1) creates a view excluding index 1
+        auto v1 = xt::view(my_array, xt::drop(1));
+        EXPECT_EQ(v1, (xt::xtensor<double, 1>{1, 3}));
+
+        // Assign through the drop view
+        xt::view(my_array, xt::drop(1)) = 0.;
+        EXPECT_EQ(my_array, (xt::xtensor<double, 1>{0, 2, 0}));
+
+        // Reset, then test drop with a variable (the original compilation issue)
+        my_array = xt::xtensor<double, 1>({1, 2, 3});
+        const size_t index = 1;
+        auto v2 = xt::view(my_array, xt::drop(index));
+        EXPECT_EQ(v2, (xt::xtensor<double, 1>{1, 3}));
+    }
 }