Merge pull request #2488 from tdegeus/operator

Adding `xt::missing` to `operator()`

Author: JohanMabille

docs/source/indices.rst

@@ -52,12 +52,16 @@ To this end the following operators are at your disposal:
 Returns a (constant) reference to the element,
 specified by an *array index* given by a number of unsigned integers.
 
-.. note::
-
-    If the number of indices is less that the dimension of the array,
+*   If the number of indices is less that the dimension of the array,
     the indices are pre-padded with zeros until the dimension is matched
     (example: ``a(2) == a(0, 2) == 2``).
 
+*   If the number of indices is greater than the dimension of the array,
+    the first ``#indices - dimension`` indices are ignored.
+
+*   To post-pad an arbitrary number of zeros use ``xt::missing``
+    (example ``a(2, xt::missing) == a(2, 0) == 8``.
+
 ``at(args...)``
 ^^^^^^^^^^^^^^^
 

include/xtensor/xcontainer.hpp

@@ -438,7 +438,7 @@ namespace xt
     {
         XTENSOR_TRY(check_index(shape(), args...));
         XTENSOR_CHECK_DIMENSION(shape(), args...);
-        size_type index = xt::data_offset<size_type>(strides(), static_cast<std::ptrdiff_t>(args)...);
+        size_type index = xt::data_offset<size_type>(strides(), args...);
         return storage()[index];
     }
 
@@ -454,7 +454,7 @@ namespace xt
     {
         XTENSOR_TRY(check_index(shape(), args...));
         XTENSOR_CHECK_DIMENSION(shape(), args...);
-        size_type index = xt::data_offset<size_type>(strides(), static_cast<std::ptrdiff_t>(args)...);
+        size_type index = xt::data_offset<size_type>(strides(), args...);
         return storage()[index];
     }
 

include/xtensor/xexception.hpp

@@ -14,11 +14,36 @@
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include <iostream>
 
 #include "xtensor_config.hpp"
+#include <xtl/xsequence.hpp>
+#include <xtl/xspan_impl.hpp>
 
 namespace xt
 {
+    struct missing_type {};
+    namespace {
+        missing_type missing;
+    }
+
+    namespace detail
+    {
+        template <class... Args>
+        struct last_type_is_missing_impl
+            : std::is_same<missing_type, xtl::mpl::back_t<xtl::mpl::vector<Args...>>>
+        {
+        };
+
+        template <>
+        struct last_type_is_missing_impl<>
+            : std::false_type
+        {
+        };
+
+        template <class... Args>
+        constexpr bool last_type_is_missing = last_type_is_missing_impl<Args...>::value;
+    }
 
     /*******************
      * broadcast_error *
@@ -147,6 +172,11 @@ namespace xt
         {
         }
 
+        template <class S, std::size_t dim>
+        inline void check_index_impl(const S&, missing_type)
+        {
+        }
+
         template <class S, std::size_t dim, class T, class... Args>
         inline void check_index_impl(const S& shape, T arg, Args... args)
         {
@@ -165,6 +195,11 @@ namespace xt
     {
     }
 
+    template <class S>
+    inline void check_index(const S&, missing_type)
+    {
+    }
+
     template <class S, class Arg, class... Args>
     inline void check_index(const S& shape, Arg arg, Args... args)
     {
@@ -178,6 +213,11 @@ namespace xt
             // Too many arguments: drop the first
             check_index(shape, args...);
         }
+        else if (detail::last_type_is_missing<Args...>)
+        {
+            // Too few arguments & last argument xt::missing: postfix index with zeros
+            detail::check_index_impl<S, 0>(shape, arg, args...);
+        }
         else
         {
             // Too few arguments: ignore the beginning of the shape
@@ -194,7 +234,7 @@ namespace xt
         auto dst = static_cast<size_type>(last - first);
         It efirst = last - static_cast<std::ptrdiff_t>((std::min)(shape.size(), dst));
         std::size_t axis = 0;
-        
+
         while (efirst != last)
         {
             if (*efirst >= value_type(shape[axis]) && shape[axis] != 1)

include/xtensor/xstrides.hpp

@@ -169,17 +169,25 @@ namespace xt
 
     namespace detail
     {
+
         template <std::size_t dim, class S>
         inline auto raw_data_offset(const S&) noexcept
         {
             using strides_value_type = std::decay_t<decltype(std::declval<S>()[0])>;
             return strides_value_type(0);
         }
 
+        template <std::size_t dim, class S>
+        inline auto raw_data_offset(const S&, missing_type) noexcept
+        {
+            using strides_value_type = std::decay_t<decltype(std::declval<S>()[0])>;
+            return strides_value_type(0);
+        }
+
         template <std::size_t dim, class S, class Arg, class... Args>
         inline auto raw_data_offset(const S& strides, Arg arg, Args... args) noexcept
         {
-            return arg * strides[dim] + raw_data_offset<dim + 1>(strides, args...);
+            return static_cast<std::ptrdiff_t>(arg) * strides[dim] + raw_data_offset<dim + 1>(strides, args...);
         }
 
         template <layout_type L, std::ptrdiff_t static_dim>
@@ -270,11 +278,17 @@ namespace xt
             // Too many arguments: drop the first
             return data_offset<offset_type, S>(strides, args...);
         }
+        else if (detail::last_type_is_missing<Args...>)
+        {
+            // Too few arguments & last argument xt::missing: postfix index with zeros
+            return static_cast<offset_type>(detail::raw_data_offset<0>(strides, arg, args...));
+        }
         else
         {
             // Too few arguments: right to left scalar product
             auto view = strides.cend() - nargs;
             return static_cast<offset_type>(detail::raw_data_offset<0>(view, arg, args...));
+
         }
     }
 

test/test_xtensor.cpp

@@ -167,6 +167,43 @@ namespace xt
         }
     }
 
+    TEST(xtensor, missign)
+    {
+        xt::xtensor<int, 2> a
+           {{0, 1, 2},
+            {3, 4, 5},
+            {6, 7, 8}};
+
+        EXPECT_EQ(a(0), 0);
+        EXPECT_EQ(a(1), 1);
+        EXPECT_EQ(a(2), 2);
+        EXPECT_EQ(a(0, 0), 0);
+        EXPECT_EQ(a(1, 0), 3);
+        EXPECT_EQ(a(2, 0), 6);
+        EXPECT_EQ(a(xt::missing), 0);
+        EXPECT_EQ(a(0, xt::missing), 0);
+        EXPECT_EQ(a(1, xt::missing), 3);
+        EXPECT_EQ(a(2, xt::missing), 6);
+        EXPECT_EQ(a(0, 0), 0);
+        EXPECT_EQ(a(0, 1), 1);
+        EXPECT_EQ(a(0, 2), 2);
+        EXPECT_EQ(a(1, 0), 3);
+        EXPECT_EQ(a(1, 1), 4);
+        EXPECT_EQ(a(1, 2), 5);
+        EXPECT_EQ(a(2, 0), 6);
+        EXPECT_EQ(a(2, 1), 7);
+        EXPECT_EQ(a(2, 2), 8);
+        EXPECT_EQ(a(9, 9, 9, 0, 0), 0);
+        EXPECT_EQ(a(9, 9, 9, 0, 1), 1);
+        EXPECT_EQ(a(9, 9, 9, 0, 2), 2);
+        EXPECT_EQ(a(9, 9, 9, 1, 0), 3);
+        EXPECT_EQ(a(9, 9, 9, 1, 1), 4);
+        EXPECT_EQ(a(9, 9, 9, 1, 2), 5);
+        EXPECT_EQ(a(9, 9, 9, 2, 0), 6);
+        EXPECT_EQ(a(9, 9, 9, 2, 1), 7);
+        EXPECT_EQ(a(9, 9, 9, 2, 2), 8);
+    }
+
     TEST(xtensor, resize)
     {
         xtensor_dynamic a;