Add .slice_axis*()

Author: jturner314

src/dimension/dimension_trait.rs

@@ -239,69 +239,6 @@ pub trait Dimension : Clone + Eq + Debug + Send + Sync + Default +
         self.slice_mut()[nd - 1] = i;
     }
 
-    #[doc(hidden)]
-    /// Modify dimension, strides and return data pointer offset
-    ///
-    /// **Panics** if `slices` does not correspond to the number of axes,
-    /// if any stride is 0, or if any index is out of bounds.
-    fn do_slices(dim: &mut Self, strides: &mut Self, slices: &Self::SliceArg) -> isize {
-        let slices = slices.as_ref();
-        let mut offset = 0;
-        ndassert!(slices.len() == dim.slice().len(),
-                  "SliceArg {:?}'s length does not match dimension {:?}",
-                  slices, dim);
-        for (dr, sr, &slc) in izip!(dim.slice_mut(), strides.slice_mut(), slices) {
-            let m = *dr;
-            let mi = m as Ixs;
-            let Si(b1, opt_e1, s1) = slc;
-            let e1 = opt_e1.unwrap_or(mi);
-
-            let b1 = abs_index(mi, b1);
-            let mut e1 = abs_index(mi, e1);
-            if e1 < b1 { e1 = b1; }
-
-            ndassert!(b1 <= m,
-                      concat!("Slice begin {} is past end of axis of length {}",
-                              " (for SliceArg {:?})"),
-                      b1, m, slices);
-            ndassert!(e1 <= m,
-                      concat!("Slice end {} is past end of axis of length {}",
-                              " (for SliceArg {:?})"),
-                      e1, m, slices);
-
-            let m = e1 - b1;
-            // stride
-            let s = (*sr) as Ixs;
-
-            // Data pointer offset
-            offset += stride_offset(b1, *sr);
-            // Adjust for strides
-            ndassert!(s1 != 0,
-                      concat!("Slice stride must not be none", 
-                              "(for SliceArg {:?})"),
-                      slices);
-            // How to implement negative strides:
-            //
-            // Increase start pointer by
-            // old stride * (old dim - 1)
-            // to put the pointer completely in the other end
-            if s1 < 0 {
-                offset += stride_offset(m - 1, *sr);
-            }
-
-            let s_prim = s * s1;
-
-            let d = m / s1.abs() as Ix;
-            let r = m % s1.abs() as Ix;
-            let m_prim = d + if r > 0 { 1 } else { 0 };
-
-            // Update dimension and stride coordinate
-            *dr = m_prim;
-            *sr = s_prim as Ix;
-        }
-        offset
-    }
-
     #[doc(hidden)]
     fn is_contiguous(dim: &Self, strides: &Self) -> bool {
         let defaults = dim.default_strides();
@@ -398,18 +335,6 @@ pub trait Dimension : Clone + Eq + Debug + Send + Sync + Default +
     private_decl!{}
 }
 
-// utility functions
-
-#[inline]
-fn abs_index(len: Ixs, index: Ixs) -> Ix {
-    if index < 0 {
-        (len + index) as Ix
-    } else {
-        index as Ix
-    }
-}
-
-
 // Dimension impls
 
 macro_rules! impl_insert_axis_array(

src/dimension/mod.rs

@@ -212,6 +212,77 @@ pub fn do_sub<A, D: Dimension>(dims: &mut D, ptr: &mut *mut A, strides: &D,
     }
 }
 
+/// Compute the equivalent unsigned index given the axis length and signed index.
+#[inline]
+fn abs_index(len: Ix, index: Ixs) -> Ix {
+    if index < 0 {
+        len - (-index as Ix)
+    } else {
+        index as Ix
+    }
+}
+
+/// Modify dimension, stride and return data pointer offset
+///
+/// **Panics** if stride is 0 or if any index is out of bounds.
+pub fn do_slice(
+    dim: &mut Ix,
+    stride: &mut Ix,
+    start: Ixs,
+    end: Option<Ixs>,
+    step: Ixs,
+) -> isize {
+    let mut offset = 0;
+
+    let axis_len = *dim;
+    let start = abs_index(axis_len, start);
+    let mut end = abs_index(axis_len, end.unwrap_or(axis_len as Ixs));
+    if end < start {
+        end = start;
+    }
+
+    ndassert!(
+        start <= axis_len,
+        "Slice begin {} is past end of axis of length {}",
+        start,
+        axis_len,
+    );
+    ndassert!(
+        end <= axis_len,
+        "Slice end {} is past end of axis of length {}",
+        end,
+        axis_len,
+    );
+
+    let m = end - start;
+    // stride
+    let s = (*stride) as Ixs;
+
+    // Data pointer offset
+    offset += stride_offset(start, *stride);
+    // Adjust for strides
+    ndassert!(step != 0, "Slice stride must not be zero");
+    // How to implement negative strides:
+    //
+    // Increase start pointer by
+    // old stride * (old dim - 1)
+    // to put the pointer completely in the other end
+    if step < 0 {
+        offset += stride_offset(m - 1, *stride);
+    }
+
+    let s_prim = s * step;
+
+    let d = m / step.abs() as Ix;
+    let r = m % step.abs() as Ix;
+    let m_prim = d + if r > 0 { 1 } else { 0 };
+
+    // Update dimension and stride coordinate
+    *dim = m_prim;
+    *stride = s_prim as Ix;
+
+    offset
+}
 
 pub fn merge_axes<D>(dim: &mut D, strides: &mut D, take: Axis, into: Axis) -> bool
     where D: Dimension,

src/impl_methods.rs

@@ -19,7 +19,7 @@ use dimension;
 use iterators;
 use error::{self, ShapeError, ErrorKind};
 use dimension::IntoDimension;
-use dimension::{axes_of, Axes, merge_axes, stride_offset};
+use dimension::{axes_of, Axes, do_slice, merge_axes, stride_offset};
 use iterators::{
     new_lanes,
     new_lanes_mut,
@@ -31,6 +31,7 @@ use zip::Zip;
 
 use {
     NdIndex,
+    Si,
 };
 use iter::{
     AxisChunksIter,
@@ -246,7 +247,69 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
     /// **Panics** if an index is out of bounds or stride is zero.<br>
     /// (**Panics** if `D` is `IxDyn` and `indexes` does not match the number of array axes.)
     pub fn slice_inplace(&mut self, indexes: &D::SliceArg) {
-        let offset = D::do_slices(&mut self.dim, &mut self.strides, indexes);
+        let indexes: &[Si] = indexes.as_ref();
+        assert_eq!(indexes.len(), self.ndim());
+        indexes
+            .iter()
+            .enumerate()
+            .for_each(|(axis, &Si(start, end, step))| {
+                self.slice_axis_inplace(Axis(axis), start, end, step)
+            });
+    }
+
+    /// Return a view of the array, sliced along the specified axis.
+    ///
+    /// **Panics** if an index is out of bounds or step size is zero.<br>
+    /// **Panics** if `axis` is out of bounds.
+    pub fn slice_axis(
+        &self,
+        axis: Axis,
+        start: Ixs,
+        end: Option<Ixs>,
+        step: Ixs,
+    ) -> ArrayView<A, D> {
+        let mut view = self.view();
+        view.slice_axis_inplace(axis, start, end, step);
+        view
+    }
+
+    /// Return a mutable view of the array, sliced along the specified axis.
+    ///
+    /// **Panics** if an index is out of bounds or step size is zero.<br>
+    /// **Panics** if `axis` is out of bounds.
+    pub fn slice_axis_mut(
+        &mut self,
+        axis: Axis,
+        start: Ixs,
+        end: Option<Ixs>,
+        step: Ixs,
+    ) -> ArrayViewMut<A, D>
+    where
+        S: DataMut,
+    {
+        let mut view_mut = self.view_mut();
+        view_mut.slice_axis_inplace(axis, start, end, step);
+        view_mut
+    }
+
+    /// Slice the array in place along the specified axis.
+    ///
+    /// **Panics** if an index is out of bounds or step size is zero.<br>
+    /// **Panics** if `axis` is out of bounds.
+    pub fn slice_axis_inplace(
+        &mut self,
+        axis: Axis,
+        start: Ixs,
+        end: Option<Ixs>,
+        step: Ixs,
+    ) {
+        let offset = do_slice(
+            &mut self.dim.slice_mut()[axis.index()],
+            &mut self.strides.slice_mut()[axis.index()],
+            start,
+            end,
+            step,
+        );
         unsafe {
             self.ptr = self.ptr.offset(offset);
         }

tests/array.rs

@@ -82,6 +82,13 @@ fn slice_oob()
     let _vi = a.slice(&[Si(0, Some(10), 1), S]);
 }
 
+#[should_panic]
+#[test]
+fn slice_axis_oob() {
+    let a = RcArray::<i32, _>::zeros((3, 4));
+    let _vi = a.slice_axis(Axis(0), 0, Some(10), 1);
+}
+
 #[should_panic]
 #[test]
 fn slice_wrong_dim()