Add support for slicing with inclusive ranges

Rust 1.26 added support for inclusive ranges, which can be created
with syntax `start..=end` or `..=end`. This commit bumps the required
Rust version to 1.27 because the `.start()` and `.end()` methods of
`RangeInclusive` were added only in 1.27.

Author: jturner314

.travis.yml

@@ -4,7 +4,7 @@ sudo: required
 dist: trusty
 matrix:
   include:
-    - rust: 1.26.0
+    - rust: 1.27.0
       env:
        - FEATURES='test docs'
     - rust: stable

README.rst

@@ -92,9 +92,10 @@ Recent Changes (ndarray)
 
   - Add ``var_axis`` method for computing variance by @LukeMathWalker.
   - Add support for 128-bit integer scalars (``i128`` and ``u128``).
+  - Add support for slicing with inclusive ranges (``start..=end`` and ``..=end``).
   - Bump ``num-traits`` and ``num-complex`` to version ``0.2``.
   - Bump ``blas-src`` to version ``0.2``.
-  - Bump minimum required Rust version to 1.26.
+  - Bump minimum required Rust version to 1.27.
   - Additional contributors to this release: @ExpHP, @jturner314, @alexbool, @messense, @danmack, @nbro
 
 - 0.11.2

src/lib.rs

@@ -53,7 +53,7 @@
 //!   + Efficient floating point matrix multiplication even for very large
 //!     matrices; can optionally use BLAS to improve it further.
 //!   + See also the [`ndarray-parallel`] crate for integration with rayon.
-//! - **Requires Rust 1.26**
+//! - **Requires Rust 1.27**
 //!
 //! [`ndarray-parallel`]: https://docs.rs/ndarray-parallel
 //!

src/slice.rs

@@ -6,15 +6,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 use error::{ShapeError, ErrorKind};
-use std::ops::{Deref, Range, RangeFrom, RangeFull, RangeTo};
+use std::ops::{Deref, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive};
 use std::fmt;
 use std::marker::PhantomData;
 use super::Dimension;
 
 /// A slice (range with step size).
 ///
-/// Negative `begin` or `end` indexes are counted from the back of the axis. If
-/// `end` is `None`, the slice extends to the end of the axis.
+/// `end` is an exclusive index. Negative `begin` or `end` indexes are counted
+/// from the back of the axis. If `end` is `None`, the slice extends to the end
+/// of the axis.
 ///
 /// See also the [`s![]`](macro.s.html) macro.
 ///
@@ -79,6 +80,18 @@ macro_rules! impl_slice_from_index_type {
             }
         }
 
+        impl From<RangeInclusive<$index>> for Slice {
+            #[inline]
+            fn from(r: RangeInclusive<$index>) -> Slice {
+                let end = *r.end() as isize;
+                Slice {
+                    start: *r.start() as isize,
+                    end: if end == -1 { None } else { Some(end + 1) },
+                    step: 1,
+                }
+            }
+        }
+
         impl From<RangeFrom<$index>> for Slice {
             #[inline]
             fn from(r: RangeFrom<$index>) -> Slice {
@@ -100,7 +113,19 @@ macro_rules! impl_slice_from_index_type {
                 }
             }
         }
-    }
+
+        impl From<RangeToInclusive<$index>> for Slice {
+            #[inline]
+            fn from(r: RangeToInclusive<$index>) -> Slice {
+                let end = r.end as isize;
+                Slice {
+                    start: 0,
+                    end: if end == -1 { None } else { Some(end + 1) },
+                    step: 1,
+                }
+            }
+        }
+    };
 }
 
 impl_slice_from_index_type!(isize);
@@ -144,9 +169,9 @@ impl From<RangeFull> for Slice {
 /// The macro equivalent is `s![a..;-1]`.
 #[derive(Debug, PartialEq, Eq, Hash)]
 pub enum SliceOrIndex {
-    /// A range with step size. Negative `begin` or `end` indexes are counted
-    /// from the back of the axis. If `end` is `None`, the slice extends to the
-    /// end of the axis.
+    /// A range with step size. `end` is an exclusive index. Negative `begin`
+    /// or `end` indexes are counted from the back of the axis. If `end` is
+    /// `None`, the slice extends to the end of the axis.
     Slice {
         start: isize,
         end: Option<isize>,
@@ -250,6 +275,18 @@ macro_rules! impl_sliceorindex_from_index_type {
             }
         }
 
+        impl From<RangeInclusive<$index>> for SliceOrIndex {
+            #[inline]
+            fn from(r: RangeInclusive<$index>) -> SliceOrIndex {
+                let end = *r.end() as isize;
+                SliceOrIndex::Slice {
+                    start: *r.start() as isize,
+                    end: if end == -1 { None } else { Some(end + 1) },
+                    step: 1,
+                }
+            }
+        }
+
         impl From<RangeFrom<$index>> for SliceOrIndex {
             #[inline]
             fn from(r: RangeFrom<$index>) -> SliceOrIndex {
@@ -271,7 +308,19 @@ macro_rules! impl_sliceorindex_from_index_type {
                 }
             }
         }
-    }
+
+        impl From<RangeToInclusive<$index>> for SliceOrIndex {
+            #[inline]
+            fn from(r: RangeToInclusive<$index>) -> SliceOrIndex {
+                let end = r.end as isize;
+                SliceOrIndex::Slice {
+                    start: 0,
+                    end: if end == -1 { None } else { Some(end + 1) },
+                    step: 1,
+                }
+            }
+        }
+    };
 }
 
 impl_sliceorindex_from_index_type!(isize);
@@ -453,6 +502,12 @@ impl<D1: Dimension, T> SliceNextDim<D1, D1::Larger> for Range<T> {
     }
 }
 
+impl<D1: Dimension, T> SliceNextDim<D1, D1::Larger> for RangeInclusive<T> {
+    fn next_dim(&self, _: PhantomData<D1>) -> PhantomData<D1::Larger> {
+        PhantomData
+    }
+}
+
 impl<D1: Dimension, T> SliceNextDim<D1, D1::Larger> for RangeFrom<T> {
     fn next_dim(&self, _: PhantomData<D1>) -> PhantomData<D1::Larger> {
         PhantomData
@@ -465,6 +520,12 @@ impl<D1: Dimension, T> SliceNextDim<D1, D1::Larger> for RangeTo<T> {
     }
 }
 
+impl<D1: Dimension, T> SliceNextDim<D1, D1::Larger> for RangeToInclusive<T> {
+    fn next_dim(&self, _: PhantomData<D1>) -> PhantomData<D1::Larger> {
+        PhantomData
+    }
+}
+
 impl<D1: Dimension> SliceNextDim<D1, D1::Larger> for RangeFull {
     fn next_dim(&self, _: PhantomData<D1>) -> PhantomData<D1::Larger> {
         PhantomData

tests/array.rs

@@ -82,6 +82,14 @@ fn test_slice()
     assert!(vi.iter().zip(A.iter()).all(|(a, b)| a == b));
 }
 
+#[test]
+fn test_slice_inclusive_range() {
+    let arr = array![[1, 2, 3], [4, 5, 6]];
+    assert_eq!(arr.slice(s![1..=1, 1..=2]), array![[5, 6]]);
+    assert_eq!(arr.slice(s![1..=-1, -2..=2;-1]), array![[6, 5]]);
+    assert_eq!(arr.slice(s![0..=-1, 0..=2;2]), array![[1, 3], [4, 6]]);
+}
+
 /// Test that the compiler can infer a type for a sliced array from the
 /// arguments to `s![]`.
 ///