Merge pull request #6 from SylvainCorlay/dynamic-access

Dynamic access operator

Author: JohanMabille

.appveyor.yml

@@ -24,7 +24,7 @@ install:
   - conda info -a
   - conda install pytest -c conda-forge
   - cd test
-  - conda install xtensor==0.1.1 pytest numpy pybind11==1.8.1 -c conda-forge
+  - conda install xtensor==0.2.0 pytest numpy pybind11==1.8.1 -c conda-forge
   - xcopy /S %APPVEYOR_BUILD_FOLDER%\include %MINICONDA%\include
 
 build_script:

.travis.yml

@@ -59,7 +59,7 @@ install:
     # Useful for debugging any issues with conda
     - conda info -a
     - cd test
-    - conda install xtensor==0.1.1 pytest numpy pybind11==1.8.1 -c conda-forge
+    - conda install xtensor==0.2.0 pytest numpy pybind11==1.8.1 -c conda-forge
     - cp -r $TRAVIS_BUILD_DIR/include/* $HOME/miniconda/include/
 
 script:

conda.recipe/bld.bat

@@ -11,6 +11,7 @@
 
 #include <cstddef>
 #include <algorithm>
+#include <vector>
 
 #include "pybind11/numpy.h"
 #include "pybind11_backport.hpp"
@@ -33,7 +34,7 @@ namespace xt
     class pyarray;
 
     template <class T, int ExtraFlags>
-    struct array_inner_types<pyarray<T, ExtraFlags>>
+    struct xcontainer_inner_types<pyarray<T, ExtraFlags>>
     {
         using temporary_type = pyarray<T, ExtraFlags>;
     };
@@ -63,14 +64,14 @@ namespace xt
      */
     template <class T, int ExtraFlags = pybind_array::forcecast>
     class pyarray : public pybind_array,
-                     public xarray_semantic<pyarray<T, ExtraFlags>>
+                    public xcontainer_semantic<pyarray<T, ExtraFlags>>
     {
 
     public:
 
         using self_type = pyarray<T, ExtraFlags>;
         using base_type = pybind_array;
-        using semantic_base = xarray_semantic<self_type>;
+        using semantic_base = xcontainer_semantic<self_type>;
         using value_type = T;
         using reference = T&;
         using const_reference = const T&;
@@ -89,8 +90,8 @@ namespace xt
         using storage_iterator = T*;
         using const_storage_iterator = const T*;
 
-        using shape_type = xshape<size_type>;
-        using strides_type = xstrides<size_type>;
+        using shape_type = std::vector<size_type>;
+        using strides_type = std::vector<size_type>;
         using backstrides_type = pyarray_backstrides<self_type>;
 
         using closure_type = const self_type&;
@@ -101,12 +102,12 @@ namespace xt
 
         explicit pyarray(const buffer_info& info);
 
-        pyarray(const xshape<size_type>& shape,
-                const xstrides<size_type>& strides, 
+        pyarray(const shape_type& shape,
+                const strides_type& strides, 
                 const T* ptr = nullptr,
                 handle base = handle());
 
-        explicit pyarray(const xshape<size_type>& shape, 
+        explicit pyarray(const shape_type& shape, 
                          const T* ptr = nullptr,
                          handle base = handle());
 
@@ -129,14 +130,20 @@ namespace xt
         template<typename... Args>
         const_reference operator()(Args... args) const;
 
+        reference operator[](const xindex& index);
+        const_reference operator[](const xindex& index) const;
+
         template<typename... Args>
         pointer data(Args... args);
 
         template<typename... Args>
         const_pointer data(Args... args) const;
 
-        bool broadcast_shape(shape_type& shape) const;
-        bool is_trivial_broadcast(const strides_type& strides) const;
+        template <class S>
+        bool broadcast_shape(S& shape) const;
+
+        template <class S>
+        bool is_trivial_broadcast(const S& strides) const;
 
         iterator begin();
         iterator end();
@@ -175,9 +182,11 @@ namespace xt
     private:
 
         template<typename... Args>
-        auto index_at(Args... args) const -> size_type;
+        size_type index_at(Args... args) const;
 
-        static constexpr auto itemsize() -> size_type;
+        size_type data_offset(const xindex& index) const;
+
+        static constexpr size_type itemsize();
 
         static bool is_non_null(PyObject* ptr);
 
@@ -223,16 +232,16 @@ namespace xt
     }
 
     template <class T, int ExtraFlags>
-    inline pyarray<T, ExtraFlags>::pyarray(const xshape<size_type>& shape,
-                                           const xstrides<size_type>& strides, 
+    inline pyarray<T, ExtraFlags>::pyarray(const shape_type& shape,
+                                           const strides_type& strides, 
                                            const T *ptr,
                                            handle base)
         : pybind_array(shape, strides, ptr, base)
     {
     }
 
     template <class T, int ExtraFlags>
-    inline pyarray<T, ExtraFlags>::pyarray(const xshape<size_type>& shape, 
+    inline pyarray<T, ExtraFlags>::pyarray(const shape_type& shape, 
                                            const T* ptr,
                                            handle base)
         : pybind_array(shape, ptr, base)
@@ -340,6 +349,18 @@ namespace xt
         return *(static_cast<const_pointer>(pybind_array::data()) + pybind_array::byte_offset(args...) / itemsize());
     }
 
+    template <class T, int ExtraFlags>
+    inline auto pyarray<T, ExtraFlags>::operator[](const xindex& index) -> reference
+    {
+        return *(static_cast<pointer>(pybind_array::mutable_data()) + data_offset(index));
+    }
+
+    template <class T, int ExtraFlags>
+    inline auto pyarray<T, ExtraFlags>::operator[](const xindex& index) const -> const_reference
+    {
+        return *(static_cast<const_pointer>(pybind_array::data()) + data_offset(index));
+    }
+
     template <class T, int ExtraFlags>
     template<typename... Args> 
     inline auto pyarray<T, ExtraFlags>::data(Args... args) -> pointer
@@ -355,13 +376,15 @@ namespace xt
     }
 
     template <class T, int ExtraFlags>
-    bool pyarray<T, ExtraFlags>::broadcast_shape(shape_type& shape) const
+    template <class S>
+    bool pyarray<T, ExtraFlags>::broadcast_shape(S& shape) const
     {
         return xt::broadcast_shape(this->shape(), shape);
     }
 
     template <class T, int ExtraFlags>
-    bool pyarray<T, ExtraFlags>::is_trivial_broadcast(const strides_type& strides) const
+    template <class S>
+    bool pyarray<T, ExtraFlags>::is_trivial_broadcast(const S& strides) const
     {
         return strides.size() == dimension() &&
             std::equal(strides.begin(), strides.end(), this->strides().begin());
@@ -515,6 +538,15 @@ namespace xt
         return pybind_array::byte_offset(args...) / itemsize();
     }
 
+    template <class T, int ExtraFlags>
+    inline auto pyarray<T, ExtraFlags>::data_offset(const xindex& index) const -> size_type
+    {
+        const strides_type& str = strides();
+        auto iter = index.begin();
+        iter += index.size() - str.size();
+        return std::inner_product(str.begin(), str.end(), iter, size_type(0)) / itemsize();
+    }
+
     template <class T, int ExtraFlags>
     constexpr auto pyarray<T, ExtraFlags>::itemsize() -> size_type
     {