As standard layout method

src/impl_methods.rs

@@ -14,14 +14,14 @@ use itertools::{izip, zip};
 
 use crate::imp_prelude::*;
 
-use crate::arraytraits;
 use crate::dimension;
 use crate::dimension::IntoDimension;
 use crate::dimension::{
     abs_index, axes_of, do_slice, merge_axes, size_of_shape_checked, stride_offset, Axes,
 };
 use crate::error::{self, ErrorKind, ShapeError};
 use crate::zip::Zip;
+use crate::{arraytraits, CowArray};
 
 use crate::iter::{
     AxisChunksIter, AxisChunksIterMut, AxisIter, AxisIterMut, ExactChunks, ExactChunksMut,
@@ -1218,6 +1218,23 @@ where
         D::is_contiguous(&self.dim, &self.strides)
     }
 
+    pub fn as_standard_layout(&self) -> CowArray<'_, A, D>
+    where
+        S: Data<Elem = A>,
+        A: Clone,
+    {
+        if self.is_standard_layout() {
+            CowArray::from(self.view())
+        } else {
+            let v = self.iter().cloned().collect::<Vec<A>>();
+            let owned_array: Array<A, D> = unsafe {
+                // Safe because we use shape and content of existing array here.
+                ArrayBase::from_shape_vec_unchecked(self.raw_dim(), v)
+            };
+            CowArray::from(owned_array)
+        }
+    }
+
     /// Return a pointer to the first element in the array.
     ///
     /// Raw access to array elements needs to follow the strided indexing

tests/array.rs

@@ -1970,6 +1970,77 @@ fn array_macros() {
     assert_eq!(empty2, array![[]]);
 }
 
+#[cfg(test)]
+mod as_standard_layout_tests {
+    use super::*;
+
+    #[test]
+    fn test_f_layout() {
+        let shape = Ix2(2, 2).strides(Ix2(1, 2));
+        let arr = Array::<i32, Ix2>::from_shape_vec(shape, vec![1, 2, 3, 4]).unwrap();
+        assert!(!arr.is_standard_layout());
+        let cont_arr = arr.as_standard_layout();
+        assert!(cont_arr.is_standard_layout());
+        assert_eq!(arr, cont_arr);
+        assert!(cont_arr.is_owned());
+    }
+
+    #[test]
+    fn test_c_layout() {
+        let arr = Array::<i32, Ix2>::from_shape_vec((2, 2), vec![1, 2, 3, 4]).unwrap();
+        assert!(arr.is_standard_layout());
+        let cont_arr = arr.as_standard_layout();
+        assert!(cont_arr.is_standard_layout());
+        assert_eq!(arr, cont_arr);
+        assert!(cont_arr.is_view());
+    }
+
+    #[test]
+    fn test_f_layout_view() {
+        let shape = Ix2(2, 2).strides(Ix2(1, 2));
+        let arr = Array::<i32, Ix2>::from_shape_vec(shape, vec![1, 2, 3, 4]).unwrap();
+        let arr_view = arr.view();
+        assert!(!arr_view.is_standard_layout());
+        let cont_arr = arr.as_standard_layout();
+        assert!(cont_arr.is_standard_layout());
+        assert_eq!(arr, cont_arr);
+        assert!(cont_arr.is_owned());
+    }
+
+    #[test]
+    fn test_c_layout_view() {
+        let arr = Array::<i32, Ix2>::from_shape_vec((2, 2), vec![1, 2, 3, 4]).unwrap();
+        let arr_view = arr.view();
+        assert!(arr_view.is_standard_layout());
+        let cont_arr = arr_view.as_standard_layout();
+        assert!(cont_arr.is_standard_layout());
+        assert_eq!(arr, cont_arr);
+        assert!(cont_arr.is_view());
+    }
+
+    #[test]
+    fn test_zero_dimensional_array() {
+        let arr_view = ArrayView1::<i32>::from(&[]);
+        assert!(arr_view.is_standard_layout());
+        let cont_arr = arr_view.as_standard_layout();
+        assert!(cont_arr.is_standard_layout());
+        assert_eq!(arr_view, cont_arr);
+        assert!(cont_arr.is_view());
+    }
+
+    #[test]
+    fn test_custom_layout() {
+        let shape = Ix4(1, 2, 3, 2).strides(Ix4(12, 1, 2, 6));
+        let arr_data: Vec<i32> = (0..12).collect();
+        let arr = Array::<i32, Ix4>::from_shape_vec(shape, arr_data).unwrap();
+        assert!(!arr.is_standard_layout());
+        let cont_arr = arr.as_standard_layout();
+        assert!(cont_arr.is_standard_layout());
+        assert_eq!(arr, cont_arr);
+        assert!(cont_arr.is_owned());
+    }
+}
+
 #[cfg(test)]
 mod array_cow_tests {
     use super::*;