Drop PyArray::copy_ptr is somewhat obscures what is happening at the call sites.

Author: adamreichold

src/array.rs

@@ -356,10 +356,6 @@ impl<T, D> PyArray<T, D> {
         let ptr = self.as_array_ptr();
         (*ptr).data as *mut _
     }
-
-    pub(crate) unsafe fn copy_ptr(&self, other: *const T, len: usize) {
-        ptr::copy_nonoverlapping(other, self.data(), len)
-    }
 }
 
 struct InvertedAxes(u32);
@@ -959,7 +955,7 @@ impl<T: Element> PyArray<T, Ix1> {
         unsafe {
             let array = PyArray::new(py, [slice.len()], false);
             if T::IS_COPY {
-                array.copy_ptr(slice.as_ptr(), slice.len());
+                ptr::copy_nonoverlapping(slice.as_ptr(), array.data(), slice.len());
             } else {
                 let data_ptr = array.data();
                 for (i, item) in slice.iter().enumerate() {

src/convert.rs

@@ -1,7 +1,7 @@
 //! Defines conversion traits between Rust types and NumPy data types.
 #![deny(missing_docs)]
 
-use std::{mem, os::raw::c_int};
+use std::{mem, os::raw::c_int, ptr};
 
 use ndarray::{ArrayBase, Data, Dimension, IntoDimension, Ix1, OwnedRepr};
 use pyo3::Python;
@@ -143,12 +143,12 @@ where
         let len = self.len();
         match self.order() {
             Some(order) if A::IS_COPY => {
-                // if the array is contiguous, copy it by `copy_ptr`.
+                // if the array is contiguous, copy it by `copy_nonoverlapping`.
                 let strides = self.npy_strides();
                 unsafe {
                     let array =
                         PyArray::new_(py, self.raw_dim(), strides.as_ptr(), order.to_flag());
-                    array.copy_ptr(self.as_ptr(), len);
+                    ptr::copy_nonoverlapping(self.as_ptr(), array.data(), len);
                     array
                 }
             }