Rename SliceOrIndex to AxisSliceInfo

Author: jturner314

blas-tests/tests/oper.rs

@@ -6,8 +6,8 @@ extern crate num_traits;
 use ndarray::linalg::general_mat_mul;
 use ndarray::linalg::general_mat_vec_mul;
 use ndarray::prelude::*;
+use ndarray::{AxisSliceInfo, Ix, Ixs, SliceInfo};
 use ndarray::{Data, LinalgScalar};
-use ndarray::{Ix, Ixs, SliceInfo, SliceOrIndex};
 use std::iter::FromIterator;
 
 use approx::{assert_abs_diff_eq, assert_relative_eq};
@@ -421,11 +421,11 @@ fn scaled_add_3() {
                 let mut answer = a.clone();
                 let cdim = if n == 1 { vec![q] } else { vec![n, q] };
                 let cslice = if n == 1 {
-                    vec![SliceOrIndex::from(..).step_by(s2)]
+                    vec![AxisSliceInfo::from(..).step_by(s2)]
                 } else {
                     vec![
-                        SliceOrIndex::from(..).step_by(s1),
-                        SliceOrIndex::from(..).step_by(s2),
+                        AxisSliceInfo::from(..).step_by(s1),
+                        AxisSliceInfo::from(..).step_by(s2),
                     ]
                 };
 

src/dimension/dimension_trait.rs

@@ -19,7 +19,7 @@ use crate::Axis;
 use crate::IntoDimension;
 use crate::RemoveAxis;
 use crate::{ArrayView1, ArrayViewMut1};
-use crate::{Dim, Ix, Ix0, Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn, IxDynImpl, Ixs, SliceOrIndex};
+use crate::{AxisSliceInfo, Dim, Ix, Ix0, Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn, IxDynImpl, Ixs};
 
 /// Array shape and index trait.
 ///
@@ -58,14 +58,14 @@ pub trait Dimension:
     /// size, which you pass by reference. For the dynamic dimension it is
     /// a slice.
     ///
-    /// - For `Ix1`: `[SliceOrIndex; 1]`
-    /// - For `Ix2`: `[SliceOrIndex; 2]`
+    /// - For `Ix1`: `[AxisSliceInfo; 1]`
+    /// - For `Ix2`: `[AxisSliceInfo; 2]`
     /// - and so on..
-    /// - For `IxDyn`: `[SliceOrIndex]`
+    /// - For `IxDyn`: `[AxisSliceInfo]`
     ///
     /// The easiest way to create a `&SliceInfo<SliceArg, Do>` is using the
     /// [`s![]`](macro.s!.html) macro.
-    type SliceArg: ?Sized + AsRef<[SliceOrIndex]>;
+    type SliceArg: ?Sized + AsRef<[AxisSliceInfo]>;
     /// Pattern matching friendly form of the dimension value.
     ///
     /// - For `Ix1`: `usize`,
@@ -394,7 +394,7 @@ macro_rules! impl_insert_axis_array(
 
 impl Dimension for Dim<[Ix; 0]> {
     const NDIM: Option<usize> = Some(0);
-    type SliceArg = [SliceOrIndex; 0];
+    type SliceArg = [AxisSliceInfo; 0];
     type Pattern = ();
     type Smaller = Self;
     type Larger = Ix1;
@@ -438,7 +438,7 @@ impl Dimension for Dim<[Ix; 0]> {
 
 impl Dimension for Dim<[Ix; 1]> {
     const NDIM: Option<usize> = Some(1);
-    type SliceArg = [SliceOrIndex; 1];
+    type SliceArg = [AxisSliceInfo; 1];
     type Pattern = Ix;
     type Smaller = Ix0;
     type Larger = Ix2;
@@ -554,7 +554,7 @@ impl Dimension for Dim<[Ix; 1]> {
 
 impl Dimension for Dim<[Ix; 2]> {
     const NDIM: Option<usize> = Some(2);
-    type SliceArg = [SliceOrIndex; 2];
+    type SliceArg = [AxisSliceInfo; 2];
     type Pattern = (Ix, Ix);
     type Smaller = Ix1;
     type Larger = Ix3;
@@ -711,7 +711,7 @@ impl Dimension for Dim<[Ix; 2]> {
 
 impl Dimension for Dim<[Ix; 3]> {
     const NDIM: Option<usize> = Some(3);
-    type SliceArg = [SliceOrIndex; 3];
+    type SliceArg = [AxisSliceInfo; 3];
     type Pattern = (Ix, Ix, Ix);
     type Smaller = Ix2;
     type Larger = Ix4;
@@ -834,7 +834,7 @@ macro_rules! large_dim {
     ($n:expr, $name:ident, $pattern:ty, $larger:ty, { $($insert_axis:tt)* }) => (
         impl Dimension for Dim<[Ix; $n]> {
             const NDIM: Option<usize> = Some($n);
-            type SliceArg = [SliceOrIndex; $n];
+            type SliceArg = [AxisSliceInfo; $n];
             type Pattern = $pattern;
             type Smaller = Dim<[Ix; $n - 1]>;
             type Larger = $larger;
@@ -885,7 +885,7 @@ large_dim!(6, Ix6, (Ix, Ix, Ix, Ix, Ix, Ix), IxDyn, {
 /// and memory wasteful, but it allows an arbitrary and dynamic number of axes.
 impl Dimension for IxDyn {
     const NDIM: Option<usize> = None;
-    type SliceArg = [SliceOrIndex];
+    type SliceArg = [AxisSliceInfo];
     type Pattern = Self;
     type Smaller = Self;
     type Larger = Self;

src/dimension/mod.rs

@@ -7,7 +7,7 @@
 // except according to those terms.
 
 use crate::error::{from_kind, ErrorKind, ShapeError};
-use crate::{Ix, Ixs, Slice, SliceOrIndex};
+use crate::{AxisSliceInfo, Ix, Ixs, Slice};
 use num_integer::div_floor;
 
 pub use self::axes::{axes_of, Axes, AxisDescription};
@@ -599,15 +599,15 @@ pub fn slices_intersect<D: Dimension>(
 ) -> bool {
     debug_assert_eq!(indices1.as_ref().len(), indices2.as_ref().len());
     for (&axis_len, &si1, &si2) in izip!(dim.slice(), indices1.as_ref(), indices2.as_ref()) {
-        // The slices do not intersect iff any pair of `SliceOrIndex` does not intersect.
+        // The slices do not intersect iff any pair of `AxisSliceInfo` does not intersect.
         match (si1, si2) {
             (
-                SliceOrIndex::Slice {
+                AxisSliceInfo::Slice {
                     start: start1,
                     end: end1,
                     step: step1,
                 },
-                SliceOrIndex::Slice {
+                AxisSliceInfo::Slice {
                     start: start2,
                     end: end2,
                     step: step2,
@@ -628,8 +628,8 @@ pub fn slices_intersect<D: Dimension>(
                     return false;
                 }
             }
-            (SliceOrIndex::Slice { start, end, step }, SliceOrIndex::Index(ind))
-            | (SliceOrIndex::Index(ind), SliceOrIndex::Slice { start, end, step }) => {
+            (AxisSliceInfo::Slice { start, end, step }, AxisSliceInfo::Index(ind))
+            | (AxisSliceInfo::Index(ind), AxisSliceInfo::Slice { start, end, step }) => {
                 let ind = abs_index(axis_len, ind);
                 let (min, max) = match slice_min_max(axis_len, Slice::new(start, end, step)) {
                     Some(m) => m,
@@ -639,7 +639,7 @@ pub fn slices_intersect<D: Dimension>(
                     return false;
                 }
             }
-            (SliceOrIndex::Index(ind1), SliceOrIndex::Index(ind2)) => {
+            (AxisSliceInfo::Index(ind1), AxisSliceInfo::Index(ind2)) => {
                 let ind1 = abs_index(axis_len, ind1);
                 let ind2 = abs_index(axis_len, ind2);
                 if ind1 != ind2 {

src/impl_methods.rs

@@ -32,7 +32,7 @@ use crate::iter::{
 };
 use crate::slice::MultiSlice;
 use crate::stacking::concatenate;
-use crate::{NdIndex, Slice, SliceInfo, SliceOrIndex};
+use crate::{AxisSliceInfo, NdIndex, Slice, SliceInfo};
 
 /// # Methods For All Array Types
 impl<A, S, D> ArrayBase<S, D>
@@ -415,16 +415,16 @@ where
         // Slice and collapse in-place without changing the number of dimensions.
         self.slice_collapse(&*info);
 
-        let indices: &[SliceOrIndex] = (**info).as_ref();
+        let indices: &[AxisSliceInfo] = (**info).as_ref();
 
         // Copy the dim and strides that remain after removing the subview axes.
         let out_ndim = info.out_ndim();
         let mut new_dim = Do::zeros(out_ndim);
         let mut new_strides = Do::zeros(out_ndim);
         izip!(self.dim.slice(), self.strides.slice(), indices)
             .filter_map(|(d, s, slice_or_index)| match slice_or_index {
-                SliceOrIndex::Slice { .. } => Some((d, s)),
-                SliceOrIndex::Index(_) => None,
+                AxisSliceInfo::Slice { .. } => Some((d, s)),
+                AxisSliceInfo::Index(_) => None,
             })
             .zip(izip!(new_dim.slice_mut(), new_strides.slice_mut()))
             .for_each(|((d, s), (new_d, new_s))| {
@@ -453,16 +453,16 @@ where
     /// **Panics** if an index is out of bounds or step size is zero.<br>
     /// (**Panics** if `D` is `IxDyn` and `indices` does not match the number of array axes.)
     pub fn slice_collapse(&mut self, indices: &D::SliceArg) {
-        let indices: &[SliceOrIndex] = indices.as_ref();
+        let indices: &[AxisSliceInfo] = indices.as_ref();
         assert_eq!(indices.len(), self.ndim());
         indices
             .iter()
             .enumerate()
             .for_each(|(axis, &slice_or_index)| match slice_or_index {
-                SliceOrIndex::Slice { start, end, step } => {
+                AxisSliceInfo::Slice { start, end, step } => {
                     self.slice_axis_inplace(Axis(axis), Slice { start, end, step })
                 }
-                SliceOrIndex::Index(index) => {
+                AxisSliceInfo::Index(index) => {
                     let i_usize = abs_index(self.len_of(Axis(axis)), index);
                     self.collapse_axis(Axis(axis), i_usize)
                 }

src/lib.rs

@@ -140,7 +140,7 @@ pub use crate::dimension::IxDynImpl;
 pub use crate::dimension::NdIndex;
 pub use crate::error::{ErrorKind, ShapeError};
 pub use crate::indexes::{indices, indices_of};
-pub use crate::slice::{Slice, SliceInfo, SliceNextDim, SliceOrIndex};
+pub use crate::slice::{AxisSliceInfo, Slice, SliceInfo, SliceNextDim};
 
 use crate::iterators::Baseiter;
 use crate::iterators::{ElementsBase, ElementsBaseMut, Iter, IterMut, Lanes, LanesMut};