Adding possibility to 'cast' or copy to xt::xarray etc

Author: tdegeus

.azure-pipelines/unix-build.yml

@@ -42,6 +42,14 @@ steps:
     displayName: Example - readme 1
     workingDirectory: $(Build.SourcesDirectory)/docs/source/examples/readme_example_1
 
+  - script: |
+      source activate xtensor-python
+      cmake . -DPYTHON_EXECUTABLE=`which python`
+      cmake --build .
+      python example.py
+    displayName: Example - Copy 'cast'
+    workingDirectory: $(Build.SourcesDirectory)/docs/source/examples/copy_cast
+
   - script: |
       source activate xtensor-python
       cmake . -DPYTHON_EXECUTABLE=`which python`

docs/source/examples/copy_cast/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.1..3.19)
+
+project(mymodule)
+
+find_package(pybind11 CONFIG REQUIRED)
+find_package(xtensor REQUIRED)
+find_package(xtensor-python REQUIRED)
+find_package(Python REQUIRED COMPONENTS NumPy)
+
+pybind11_add_module(mymodule main.cpp)
+target_link_libraries(mymodule PUBLIC pybind11::module xtensor-python Python::NumPy)
+
+target_compile_definitions(mymodule PRIVATE VERSION_INFO=0.1.0)

docs/source/examples/copy_cast/example.py

@@ -0,0 +1,6 @@
+import mymodule
+import numpy as np
+
+c = np.array([[1, 2, 3], [4, 5, 6]])
+assert np.isclose(np.sum(np.sin(c)), mymodule.sum_of_sines(c))
+assert np.isclose(np.sum(np.cos(c)), mymodule.sum_of_cosines(c))

docs/source/examples/copy_cast/main.cpp

@@ -0,0 +1,25 @@
+#include <numeric>
+#include <xtensor.hpp>
+#include <pybind11/pybind11.h>
+#define FORCE_IMPORT_ARRAY
+#include <xtensor-python/pyarray.hpp>
+
+double sum_of_sines(xt::pyarray<double>& m)
+{
+    auto sines = xt::sin(m);  // sines does not actually hold values.
+    return std::accumulate(sines.begin(), sines.end(), 0.0);
+}
+
+double sum_of_cosines(const xt::xarray<double>& m)
+{
+    auto cosines = xt::cos(m);  // cosines does not actually hold values.
+    return std::accumulate(cosines.begin(), cosines.end(), 0.0);
+}
+
+PYBIND11_MODULE(mymodule, m)
+{
+    xt::import_numpy();
+    m.doc() = "Test module for xtensor python bindings";
+    m.def("sum_of_sines", sum_of_sines, "Sum the sines of the input values");
+    m.def("sum_of_cosines", sum_of_cosines, "Sum the cosines of the input values");
+}

include/xtensor-python/pynative_casters.hpp

@@ -12,7 +12,6 @@
 
 #include "xtensor_type_caster_base.hpp"
 
-
 namespace pybind11
 {
     namespace detail

include/xtensor-python/xtensor_type_caster_base.hpp

@@ -23,6 +23,87 @@ namespace pybind11
 {
     namespace detail
     {
+        template <typename T, xt::layout_type L>
+        struct xtensor_get_buffer
+        {
+            template <typename H>
+            static auto get(H src)
+            {
+                return array_t<T, array::c_style | array::forcecast>::ensure(src);
+            }
+        };
+
+        template <typename T>
+        struct xtensor_get_buffer<T, xt::layout_type::column_major>
+        {
+            template <typename H>
+            static auto get(H src)
+            {
+                return array_t<T, array::f_style>::ensure(src);
+            }
+        };
+
+        template <class T>
+        struct xtensor_check_buffer
+        {
+        };
+
+        template <class T, xt::layout_type L>
+        struct xtensor_check_buffer<xt::xarray<T, L>>
+        {
+            template <typename H>
+            static auto get(H src)
+            {
+                auto buf = xtensor_get_buffer<T, L>::get(src);
+                return buf;
+            }
+        };
+
+        template <class T, std::size_t N, xt::layout_type L>
+        struct xtensor_check_buffer<xt::xtensor<T, N, L>>
+        {
+            template <typename H>
+            static auto get(H src)
+            {
+                auto buf = xtensor_get_buffer<T, L>::get(src);
+                if (buf.ndim() != N) {
+                    return false;
+                }
+                return buf;
+            }
+        };
+
+        template <class CT, class S, xt::layout_type L, class FST>
+        struct xtensor_check_buffer<xt::xstrided_view<CT, S, L, FST>>
+        {
+            template <typename H>
+            static auto get(H /*src*/)
+            {
+                return false;
+            }
+        };
+
+        template <class EC, xt::layout_type L, class SC, class Tag>
+        struct xtensor_check_buffer<xt::xarray_adaptor<EC, L, SC, Tag>>
+        {
+            template <typename H>
+            static auto get(H /*src*/)
+            {
+                return false;
+            }
+        };
+
+        template <class EC, std::size_t N, xt::layout_type L, class Tag>
+        struct xtensor_check_buffer<xt::xtensor_adaptor<EC, N, L, Tag>>
+        {
+            template <typename H>
+            static auto get(H /*src*/)
+            {
+                return false;
+            }
+        };
+
+
         // Casts a strided expression type to numpy array.If given a base,
         // the numpy array references the src data, otherwise it'll make a copy.
         // The writeable attributes lets you specify writeable flag for the array.
@@ -74,10 +155,6 @@ namespace pybind11
         template <class Type>
         struct xtensor_type_caster_base
         {
-            bool load(handle /*src*/, bool)
-            {
-                return false;
-            }
 
         private:
 
@@ -106,6 +183,30 @@ namespace pybind11
 
         public:
 
+            PYBIND11_TYPE_CASTER(Type, _("numpy.ndarray[") + npy_format_descriptor<typename Type::value_type>::name + _("]"));
+
+            bool load(handle src, bool convert)
+            {
+                using T = typename Type::value_type;
+
+                if (!convert && !array_t<T>::check_(src)) {
+                    return false;
+                }
+
+                auto buf = xtensor_check_buffer<Type>::get(src);
+
+                if (!buf) {
+                    return false;
+                }
+
+                std::vector<size_t> shape(buf.ndim());
+                std::copy(buf.shape(), buf.shape() + buf.ndim(), shape.begin());
+                value = Type(shape);
+                std::copy(buf.data(), buf.data() + buf.size(), value.begin());
+
+                return true;
+            }
+
             // Normal returned non-reference, non-const value:
             static handle cast(Type&& src, return_value_policy /* policy */, handle parent)
             {
@@ -151,18 +252,6 @@ namespace pybind11
             {
                 return cast_impl(src, policy, parent);
             }
-
-#ifdef PYBIND11_DESCR // The macro is removed from pybind11 since 2.3
-            static PYBIND11_DESCR name()
-            {
-                return _("xt::xtensor");
-            }
-#else
-            static constexpr auto name = _("xt::xtensor");
-#endif
-
-            template <typename T>
-            using cast_op_type = cast_op_type<T>;
         };
     }
 }