Implement IntoPyArray for ndarray::ArrayBase<OwnedRepr..>

Author: kngwyu

src/array.rs

@@ -9,7 +9,7 @@ use std::mem;
 use std::os::raw::c_int;
 use std::ptr;
 
-use convert::{NpyIndex, ToNpyDims};
+use convert::{IntoPyArray, NpyIndex, ToNpyDims, ToPyArray};
 use error::{ErrorKind, IntoPyResult};
 use slice_box::SliceBox;
 use types::{NpyDataType, TypeNum};
@@ -265,6 +265,10 @@ impl<T, D> PyArray<T, D> {
         let ptr = self.as_array_ptr();
         (*ptr).data as *mut T
     }
+
+    pub(crate) unsafe fn copy_ptr(&self, other: *const T, len: usize) {
+        ptr::copy_nonoverlapping(other, self.data(), len)
+    }
 }
 
 impl<T: TypeNum, D: Dimension> PyArray<T, D> {
@@ -306,7 +310,7 @@ impl<T: TypeNum, D: Dimension> PyArray<T, D> {
         unsafe { PyArray::new_(py, dims, ptr::null_mut(), flags) }
     }
 
-    unsafe fn new_<'py, ID>(
+    pub(crate) unsafe fn new_<'py, ID>(
         py: Python<'py>,
         dims: ID,
         strides: *mut npy_intp,
@@ -330,16 +334,17 @@ impl<T: TypeNum, D: Dimension> PyArray<T, D> {
         Self::from_owned_ptr(py, ptr)
     }
 
-    pub(crate) unsafe fn new_with_data<'py, ID>(
+    pub(crate) unsafe fn from_boxed_slice<'py, ID>(
         py: Python<'py>,
         dims: ID,
         strides: *mut npy_intp,
-        slice: &SliceBox<T>,
+        slice: Box<[T]>,
     ) -> &'py Self
     where
         ID: IntoDimension<Dim = D>,
     {
         let dims = dims.into_dimension();
+        let slice = SliceBox::new(slice);
         let ptr = PY_ARRAY_API.PyArray_New(
             PY_ARRAY_API.get_type_object(npyffi::ArrayType::PyArray_Type),
             dims.ndim_cint(),
@@ -388,7 +393,7 @@ impl<T: TypeNum, D: Dimension> PyArray<T, D> {
         }
     }
 
-    /// Construct PyArray from ndarray::Array.
+    /// Construct PyArray from `ndarray::ArrayBase`.
     ///
     /// This method allocates memory in Python's heap via numpy api, and then copies all elements
     /// of the array there.
@@ -398,25 +403,32 @@ impl<T: TypeNum, D: Dimension> PyArray<T, D> {
     /// # extern crate pyo3; extern crate numpy; #[macro_use] extern crate ndarray; fn main() {
     /// use numpy::PyArray;
     /// let gil = pyo3::Python::acquire_gil();
-    /// let pyarray = PyArray::from_ndarray(gil.python(), &array![[1, 2], [3, 4]]);
+    /// let pyarray = PyArray::from_array(gil.python(), &array![[1, 2], [3, 4]]);
     /// assert_eq!(pyarray.as_array().unwrap(), array![[1, 2], [3, 4]]);
     /// # }
     /// ```
-    pub fn from_ndarray<'py, S>(py: Python<'py>, arr: &ArrayBase<S, D>) -> &'py Self
+    pub fn from_array<'py, S>(py: Python<'py>, arr: &ArrayBase<S, D>) -> &'py Self
     where
         S: Data<Elem = T>,
     {
-        let len = arr.len();
-        let mut strides: Vec<_> = arr
-            .strides()
-            .into_iter()
-            .map(|n| n * mem::size_of::<T>() as npy_intp)
-            .collect();
-        unsafe {
-            let array = PyArray::new_(py, arr.raw_dim(), strides.as_mut_ptr() as *mut npy_intp, 0);
-            ptr::copy_nonoverlapping(arr.as_ptr(), array.data(), len);
-            array
-        }
+        ToPyArray::to_pyarray(arr, py)
+    }
+
+    /// Construct PyArray from `ndarray::Array`.
+    ///
+    /// This method uses internal `Vec` of `ndarray::Array` as numpy array.
+    ///
+    /// # Example
+    /// ```
+    /// # extern crate pyo3; extern crate numpy; #[macro_use] extern crate ndarray; fn main() {
+    /// use numpy::PyArray;
+    /// let gil = pyo3::Python::acquire_gil();
+    /// let pyarray = PyArray::from_owned_array(gil.python(), array![[1, 2], [3, 4]]);
+    /// assert_eq!(pyarray.as_array().unwrap(), array![[1, 2], [3, 4]]);
+    /// # }
+    /// ```
+    pub fn from_owned_array<'py>(py: Python<'py>, arr: Array<T, D>) -> &'py Self {
+        IntoPyArray::into_pyarray(arr, py)
     }
 
     /// Get the immutable view of the internal data of `PyArray`, as `ndarray::ArrayView`.
@@ -565,8 +577,7 @@ impl<T: TypeNum> PyArray<T, Ix1> {
     pub fn from_slice<'py>(py: Python<'py>, slice: &[T]) -> &'py Self {
         let array = PyArray::new(py, [slice.len()], false);
         unsafe {
-            let src = slice.as_ptr() as *mut T;
-            ptr::copy_nonoverlapping(src, array.data(), slice.len());
+            array.copy_ptr(slice.as_ptr(), slice.len());
         }
         array
     }

src/convert.rs

@@ -1,14 +1,14 @@
 //! Defines conversion traits between rust types and numpy data types.
 
-use ndarray::{ArrayBase, Data, Dimension, IntoDimension, Ix1};
+use ndarray::{ArrayBase, Data, Dimension, IntoDimension, Ix1, OwnedRepr};
 use pyo3::Python;
-use slice_box::SliceBox;
 
 use std::mem;
 use std::os::raw::c_int;
 use std::ptr;
 
 use super::*;
+use npyffi::npy_intp;
 
 /// Covnersion trait from some rust types to `PyArray`.
 ///
@@ -34,10 +34,7 @@ impl<T: TypeNum> IntoPyArray for Box<[T]> {
     type Dim = Ix1;
     fn into_pyarray<'py>(self, py: Python<'py>) -> &'py PyArray<Self::Item, Self::Dim> {
         let len = self.len();
-        unsafe {
-            let slice = SliceBox::new(self);
-            PyArray::new_with_data(py, [len], ptr::null_mut(), slice)
-        }
+        unsafe { PyArray::from_boxed_slice(py, [len], ptr::null_mut(), self) }
     }
 }
 
@@ -49,6 +46,21 @@ impl<T: TypeNum> IntoPyArray for Vec<T> {
     }
 }
 
+impl<A, D> IntoPyArray for ArrayBase<OwnedRepr<A>, D>
+where
+    A: TypeNum,
+    D: Dimension,
+{
+    type Item = A;
+    type Dim = D;
+    fn into_pyarray<'py>(self, py: Python<'py>) -> &'py PyArray<Self::Item, Self::Dim> {
+        let mut strides = npy_strides(&self);
+        let dim = self.raw_dim();
+        let boxed = self.into_raw_vec().into_boxed_slice();
+        unsafe { PyArray::from_boxed_slice(py, dim, strides.as_mut_ptr() as *mut npy_intp, boxed) }
+    }
+}
+
 /// Conversion trait from rust types to `PyArray`.
 ///
 /// This trait takes `&self`, which means **it alocates in Python heap and then copies
@@ -85,10 +97,29 @@ where
     type Item = A;
     type Dim = D;
     fn to_pyarray<'py>(&self, py: Python<'py>) -> &'py PyArray<Self::Item, Self::Dim> {
-        PyArray::from_ndarray(py, self)
+        let len = self.len();
+        let mut strides = npy_strides(self);
+        unsafe {
+            let array = PyArray::new_(py, self.raw_dim(), strides.as_mut_ptr() as *mut npy_intp, 0);
+            array.copy_ptr(self.as_ptr(), len);
+            array
+        }
     }
 }
 
+fn npy_strides<S, D, A>(array: &ArrayBase<S, D>) -> Vec<npyffi::npy_intp>
+where
+    S: Data<Elem = A>,
+    D: Dimension,
+    A: TypeNum,
+{
+    array
+        .strides()
+        .into_iter()
+        .map(|n| n * mem::size_of::<A>() as npyffi::npy_intp)
+        .collect()
+}
+
 /// Utility trait to specify the dimention of array
 pub trait ToNpyDims: Dimension {
     fn ndim_cint(&self) -> c_int {

src/slice_box.rs

@@ -68,8 +68,8 @@ impl<T> PyObjectAlloc<SliceBox<T>> for SliceBox<T> {
     /// Calls the rust destructor for the object.
     unsafe fn drop(py: Python, obj: *mut ffi::PyObject) {
         let data = (*(obj as *mut SliceBox<T>)).inner;
-        let box_ = Box::from_raw(data);
-        drop(box_);
+        let boxed_slice = Box::from_raw(data);
+        drop(boxed_slice);
         <Self as typeob::PyTypeInfo>::BaseType::drop(py, obj);
     }
     unsafe fn dealloc(py: Python, obj: *mut ffi::PyObject) {

tests/array.rs

@@ -214,3 +214,14 @@ fn into_pyarray_vec() {
     let arr = a.into_pyarray(gil.python());
     assert_eq!(arr.as_slice().unwrap(), &[1, 2, 3])
 }
+
+#[test]
+fn into_pyarray_array() {
+    let gil = pyo3::Python::acquire_gil();
+    let arr = Array3::<f64>::zeros((3, 4, 2));
+    let shape = arr.shape().iter().cloned().collect::<Vec<_>>();
+    let strides = arr.strides().iter().map(|d| d * 8).collect::<Vec<_>>();
+    let py_arr = arr.into_pyarray(gil.python());
+    assert_eq!(py_arr.shape(), shape.as_slice());
+    assert_eq!(py_arr.strides(), strides.as_slice());
+}