Removed allocation in stack_new_axis, renamed concatenate -> stack, stack -> stack_new_axis

Author: andrei.papou

src/doc/ndarray_for_numpy_users/mod.rs

@@ -532,8 +532,8 @@
 //! ------|-----------|------
 //! `a[:] = 3.` | [`a.fill(3.)`][.fill()] | set all array elements to the same scalar value
 //! `a[:] = b` | [`a.assign(&b)`][.assign()] | copy the data from array `b` into array `a`
-//! `np.concatenate((a,b), axis=1)` | [`concatenate![Axis(1), a, b]`][concatenate!] or [`concatenate(Axis(1), &[a.view(), b.view()])`][concatenate()] | concatenate arrays `a` and `b` along axis 1
-//! `np.stack((a,b), axis=1)` | [`stack![Axis(1), a, b]`][stack!] or [`stack(Axis(1), vec![a.view(), b.view()])`][stack()] | stack arrays `a` and `b` along axis 1
+//! `np.concatenate((a,b), axis=1)` | [`stack![Axis(1), a, b]`][stack!] or [`stack(Axis(1), &[a.view(), b.view()])`][stack()] | concatenate arrays `a` and `b` along axis 1
+//! `np.stack((a,b), axis=1)` | [`stack_new_axis![Axis(1), a, b]`][stack_new_axis!] or [`stack_new_axis(Axis(1), vec![a.view(), b.view()])`][stack_new_axis()] | stack arrays `a` and `b` along axis 1
 //! `a[:,np.newaxis]` or `np.expand_dims(a, axis=1)` | [`a.insert_axis(Axis(1))`][.insert_axis()] | create an array from `a`, inserting a new axis 1
 //! `a.transpose()` or `a.T` | [`a.t()`][.t()] or [`a.reversed_axes()`][.reversed_axes()] | transpose of array `a` (view for `.t()` or by-move for `.reversed_axes()`)
 //! `np.diag(a)` | [`a.diag()`][.diag()] | view the diagonal of `a`
@@ -641,10 +641,10 @@
 //! [.slice_move()]: ../../struct.ArrayBase.html#method.slice_move
 //! [.slice_mut()]: ../../struct.ArrayBase.html#method.slice_mut
 //! [.shape()]: ../../struct.ArrayBase.html#method.shape
-//! [concatenate!]: ../../macro.concatenate.html
-//! [concatenate()]: ../../fn.concatenate.html
 //! [stack!]: ../../macro.stack.html
 //! [stack()]: ../../fn.stack.html
+//! [stack_new_axis!]: ../../macro.stack_new_axis.html
+//! [stack_new_axis()]: ../../fn.stack_new_axis.html
 //! [.strides()]: ../../struct.ArrayBase.html#method.strides
 //! [.index_axis()]: ../../struct.ArrayBase.html#method.index_axis
 //! [.sum_axis()]: ../../struct.ArrayBase.html#method.sum_axis

src/impl_methods.rs

@@ -28,7 +28,7 @@ use crate::iter::{
     IndexedIter, IndexedIterMut, Iter, IterMut, Lanes, LanesMut, Windows,
 };
 use crate::slice::MultiSlice;
-use crate::stacking::concatenate;
+use crate::stacking::stack;
 use crate::{NdIndex, Slice, SliceInfo, SliceOrIndex};
 
 /// # Methods For All Array Types
@@ -840,7 +840,7 @@ where
             dim.set_axis(axis, 0);
             unsafe { Array::from_shape_vec_unchecked(dim, vec![]) }
         } else {
-            concatenate(axis, &subs).unwrap()
+            stack(axis, &subs).unwrap()
         }
     }
 

src/lib.rs

@@ -131,7 +131,7 @@ use crate::iterators::{ElementsBase, ElementsBaseMut, Iter, IterMut, Lanes, Lane
 
 pub use crate::arraytraits::AsArray;
 pub use crate::linalg_traits::{LinalgScalar, NdFloat};
-pub use crate::stacking::{concatenate, stack};
+pub use crate::stacking::{stack, stack_new_axis};
 
 pub use crate::impl_views::IndexLonger;
 pub use crate::shape_builder::ShapeBuilder;

src/stacking.rs

@@ -17,19 +17,19 @@ use crate::imp_prelude::*;
 /// if the result is larger than is possible to represent.
 ///
 /// ```
-/// use ndarray::{arr2, Axis, concatenate};
+/// use ndarray::{arr2, Axis, stack};
 ///
 /// let a = arr2(&[[2., 2.],
 ///                [3., 3.]]);
 /// assert!(
-///     concatenate(Axis(0), &[a.view(), a.view()])
+///     stack(Axis(0), &[a.view(), a.view()])
 ///     == Ok(arr2(&[[2., 2.],
 ///                  [3., 3.],
 ///                  [2., 2.],
 ///                  [3., 3.]]))
 /// );
 /// ```
-pub fn concatenate<A, D>(axis: Axis, arrays: &[ArrayView<A, D>]) -> Result<Array<A, D>, ShapeError>
+pub fn stack<A, D>(axis: Axis, arrays: &[ArrayView<A, D>]) -> Result<Array<A, D>, ShapeError>
 where
     A: Copy,
     D: RemoveAxis,
@@ -73,7 +73,7 @@ where
     Ok(res)
 }
 
-pub fn stack<A, D>(
+pub fn stack_new_axis<A, D>(
     axis: Axis,
     arrays: Vec<ArrayView<A, D>>,
 ) -> Result<Array<A, D::Larger>, ShapeError>
@@ -82,36 +82,59 @@ where
     D: Dimension,
     D::Larger: RemoveAxis,
 {
-    if let Some(ndim) = D::NDIM {
-        if axis.index() > ndim {
-            return Err(from_kind(ErrorKind::OutOfBounds));
-        }
+    if arrays.is_empty() {
+        return Err(from_kind(ErrorKind::Unsupported));
+    }
+    let common_dim = arrays[0].raw_dim();
+    // Avoid panic on `insert_axis` call, return an Err instead of it.
+    if axis.index() > common_dim.ndim() {
+        return Err(from_kind(ErrorKind::OutOfBounds));
+    }
+    let mut res_dim = common_dim.insert_axis(axis);
+
+    if arrays.iter().any(|a| a.raw_dim() != common_dim) {
+        return Err(from_kind(ErrorKind::IncompatibleShape));
     }
-    let arrays: Vec<ArrayView<A, D::Larger>> =
-        arrays.into_iter().map(|a| a.insert_axis(axis)).collect();
-    concatenate(axis, &arrays)
+
+    res_dim.set_axis(axis, arrays.len());
+
+    // we can safely use uninitialized values here because they are Copy
+    // and we will only ever write to them
+    let size = res_dim.size();
+    let mut v = Vec::with_capacity(size);
+    unsafe {
+        v.set_len(size);
+    }
+    let mut res = Array::from_shape_vec(res_dim, v)?;
+
+    res.axis_iter_mut(axis).zip(arrays.into_iter())
+        .for_each(|(mut assign_view, array)| {
+            assign_view.assign(&array);
+        });
+
+    Ok(res)
 }
 
 /// Concatenate arrays along the given axis.
 ///
-/// Uses the [`concatenate`][1] function, calling `ArrayView::from(&a)` on each
+/// Uses the [`stack`][1] function, calling `ArrayView::from(&a)` on each
 /// argument `a`.
 ///
-/// [1]: fn.concatenate.html
+/// [1]: fn.stack.html
 ///
 /// ***Panics*** if the `concatenate` function would return an error.
 ///
 /// ```
 /// extern crate ndarray;
 ///
-/// use ndarray::{arr2, concatenate, Axis};
+/// use ndarray::{arr2, stack, Axis};
 ///
 /// # fn main() {
 ///
 /// let a = arr2(&[[2., 2.],
 ///                [3., 3.]]);
 /// assert!(
-///     concatenate![Axis(0), a, a]
+///     stack![Axis(0), a, a]
 ///     == arr2(&[[2., 2.],
 ///               [3., 3.],
 ///               [2., 2.],
@@ -120,32 +143,32 @@ where
 /// # }
 /// ```
 #[macro_export]
-macro_rules! concatenate {
+macro_rules! stack {
     ($axis:expr, $( $array:expr ),+ ) => {
-        $crate::concatenate($axis, &[ $($crate::ArrayView::from(&$array) ),* ]).unwrap()
+        $crate::stack($axis, &[ $($crate::ArrayView::from(&$array) ),* ]).unwrap()
     }
 }
 
 /// Stack arrays along the new axis.
 ///
-/// Uses the [`stack`][1] function, calling `ArrayView::from(&a)` on each
+/// Uses the [`stack_new_axis`][1] function, calling `ArrayView::from(&a)` on each
 /// argument `a`.
 ///
-/// [1]: fn.concatenate.html
+/// [1]: fn.stack_new_axis.html
 ///
 /// ***Panics*** if the `stack` function would return an error.
 ///
 /// ```
 /// extern crate ndarray;
 ///
-/// use ndarray::{arr2, arr3, stack, Axis};
+/// use ndarray::{arr2, arr3, stack_new_axis, Axis};
 ///
 /// # fn main() {
 ///
 /// let a = arr2(&[[2., 2.],
 ///                [3., 3.]]);
 /// assert!(
-///     stack![Axis(0), a, a]
+///     stack_new_axis![Axis(0), a, a]
 ///     == arr3(&[[[2., 2.],
 ///                [3., 3.]],
 ///               [[2., 2.],
@@ -154,8 +177,8 @@ macro_rules! concatenate {
 /// # }
 /// ```
 #[macro_export]
-macro_rules! stack {
+macro_rules! stack_new_axis {
     ($axis:expr, $( $array:expr ),+ ) => {
-        $crate::stack($axis, vec![ $($crate::ArrayView::from(&$array) ),* ]).unwrap()
+        $crate::stack_new_axis($axis, vec![ $($crate::ArrayView::from(&$array) ),* ]).unwrap()
     }
 }

tests/stacking.rs

@@ -1,43 +1,43 @@
-use ndarray::{arr2, arr3, aview1, concatenate, Array2, Axis, ErrorKind, Ix1};
+use ndarray::{arr2, arr3, aview1, stack, Array2, Axis, ErrorKind, Ix1};
 
 #[test]
 fn concatenating() {
     let a = arr2(&[[2., 2.], [3., 3.]]);
-    let b = ndarray::concatenate(Axis(0), &[a.view(), a.view()]).unwrap();
+    let b = ndarray::stack(Axis(0), &[a.view(), a.view()]).unwrap();
     assert_eq!(b, arr2(&[[2., 2.], [3., 3.], [2., 2.], [3., 3.]]));
 
-    let c = concatenate![Axis(0), a, b];
+    let c = stack![Axis(0), a, b];
     assert_eq!(
         c,
         arr2(&[[2., 2.], [3., 3.], [2., 2.], [3., 3.], [2., 2.], [3., 3.]])
     );
 
-    let d = concatenate![Axis(0), a.row(0), &[9., 9.]];
+    let d = stack![Axis(0), a.row(0), &[9., 9.]];
     assert_eq!(d, aview1(&[2., 2., 9., 9.]));
 
-    let res = ndarray::concatenate(Axis(1), &[a.view(), c.view()]);
+    let res = ndarray::stack(Axis(1), &[a.view(), c.view()]);
     assert_eq!(res.unwrap_err().kind(), ErrorKind::IncompatibleShape);
 
-    let res = ndarray::concatenate(Axis(2), &[a.view(), c.view()]);
+    let res = ndarray::stack(Axis(2), &[a.view(), c.view()]);
     assert_eq!(res.unwrap_err().kind(), ErrorKind::OutOfBounds);
 
-    let res: Result<Array2<f64>, _> = ndarray::concatenate(Axis(0), &[]);
+    let res: Result<Array2<f64>, _> = ndarray::stack(Axis(0), &[]);
     assert_eq!(res.unwrap_err().kind(), ErrorKind::Unsupported);
 }
 
 #[test]
 fn stacking() {
     let a = arr2(&[[2., 2.], [3., 3.]]);
-    let b = ndarray::stack(Axis(0), vec![a.view(), a.view()]).unwrap();
+    let b = ndarray::stack_new_axis(Axis(0), vec![a.view(), a.view()]).unwrap();
     assert_eq!(b, arr3(&[[[2., 2.], [3., 3.]], [[2., 2.], [3., 3.]]]));
 
     let c = arr2(&[[3., 2., 3.], [2., 3., 2.]]);
-    let res = ndarray::stack(Axis(1), vec![a.view(), c.view()]);
+    let res = ndarray::stack_new_axis(Axis(1), vec![a.view(), c.view()]);
     assert_eq!(res.unwrap_err().kind(), ErrorKind::IncompatibleShape);
 
-    let res = ndarray::stack(Axis(3), vec![a.view(), a.view()]);
+    let res = ndarray::stack_new_axis(Axis(3), vec![a.view(), a.view()]);
     assert_eq!(res.unwrap_err().kind(), ErrorKind::OutOfBounds);
 
-    let res: Result<Array2<f64>, _> = ndarray::stack::<_, Ix1>(Axis(0), vec![]);
+    let res: Result<Array2<f64>, _> = ndarray::stack_new_axis::<_, Ix1>(Axis(0), vec![]);
     assert_eq!(res.unwrap_err().kind(), ErrorKind::Unsupported);
 }