Rename .islice() -> .slice_inplace()

Author: jturner314

examples/axis_ops.rs

@@ -47,7 +47,7 @@ fn main() {
     }
     a.swap_axes(0, 1);
     a.swap_axes(0, 2);
-    a.islice(s![.., ..;-1, ..]);
+    a.slice_inplace(s![.., ..;-1, ..]);
     regularize(&mut a).ok();
 
     let mut b = Array::<u8, _>::zeros((2, 3, 4));
@@ -64,6 +64,6 @@ fn main() {
     for (i, elt) in (0..).zip(&mut a) {
         *elt = i;
     }
-    a.islice(s![..;-1, ..;2, ..]);
+    a.slice_inplace(s![..;-1, ..;2, ..]);
     regularize(&mut a).ok();
 }

serialization-tests/tests/serialize.rs

@@ -53,7 +53,7 @@ fn serial_many_dim()
     {
         // Test a sliced array.
         let mut a = RcArray::linspace(0., 31., 32).reshape((2, 2, 2, 4));
-        a.islice(s![..;-1, .., .., ..2]);
+        a.slice_inplace(s![..;-1, .., .., ..2]);
         let serial = json::encode(&a).unwrap();
         println!("Encode {:?} => {:?}", a, serial);
         let res = json::decode::<RcArray<f32, _>>(&serial);
@@ -114,7 +114,7 @@ fn serial_many_dim_serde()
     {
         // Test a sliced array.
         let mut a = RcArray::linspace(0., 31., 32).reshape((2, 2, 2, 4));
-        a.islice(s![..;-1, .., .., ..2]);
+        a.slice_inplace(s![..;-1, .., .., ..2]);
         let serial = serde_json::to_string(&a).unwrap();
         println!("Encode {:?} => {:?}", a, serial);
         let res = serde_json::from_str::<RcArray<f32, _>>(&serial);
@@ -221,7 +221,7 @@ fn serial_many_dim_serde_msgpack()
     {
         // Test a sliced array.
         let mut a = RcArray::linspace(0., 31., 32).reshape((2, 2, 2, 4));
-        a.islice(s![..;-1, .., .., ..2]);
+        a.slice_inplace(s![..;-1, .., .., ..2]);
 
         let mut buf = Vec::new();
         serde::Serialize::serialize(&a, &mut rmp_serde::Serializer::new(&mut buf)).ok().unwrap();
@@ -273,7 +273,7 @@ fn serial_many_dim_ron()
     {
         // Test a sliced array.
         let mut a = RcArray::linspace(0., 31., 32).reshape((2, 2, 2, 4));
-        a.islice(s![..;-1, .., .., ..2]);
+        a.slice_inplace(s![..;-1, .., .., ..2]);
 
         let a_s = ron_serialize(&a).unwrap();
 

src/impl_methods.rs

@@ -217,7 +217,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
     /// (**Panics** if `D` is `IxDyn` and `indexes` does not match the number of array axes.)
     pub fn slice(&self, indexes: &D::SliceArg) -> ArrayView<A, D> {
         let mut arr = self.view();
-        arr.islice(indexes);
+        arr.slice_inplace(indexes);
         arr
     }
 
@@ -233,7 +233,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
         where S: DataMut
     {
         let mut arr = self.view_mut();
-        arr.islice(indexes);
+        arr.slice_inplace(indexes);
         arr
     }
 
@@ -245,7 +245,7 @@ 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 islice(&mut self, indexes: &D::SliceArg) {
+    pub fn slice_inplace(&mut self, indexes: &D::SliceArg) {
         let offset = D::do_slices(&mut self.dim, &mut self.strides, indexes);
         unsafe {
             self.ptr = self.ptr.offset(offset);

src/lib.rs

@@ -421,14 +421,18 @@ pub type Ixs = isize;
 /// ## Slicing
 ///
 /// You can use slicing to create a view of a subset of the data in
-/// the array. Slicing methods include `.slice()`, `.islice()`,
-/// `.slice_mut()`.
+/// the array. Slicing methods include [`.slice()`], [`.slice_mut()`],
+/// and [`.slice_inplace()`].
 ///
 /// The slicing argument can be passed using the macro [`s![]`](macro.s!.html),
 /// which will be used in all examples. (The explicit form is a reference
 /// to a fixed size array of [`Si`]; see its docs for more information.)
 /// [`Si`]: struct.Si.html
 ///
+/// [`.slice()`]: #method.slice
+/// [`.slice_mut()`]: #method.slice_mut
+/// [`.slice_inplace()`]: #method.slice_inplace
+///
 /// ```
 /// // import the s![] macro
 /// #[macro_use(s)]

tests/array.rs

@@ -203,7 +203,7 @@ fn test_cow()
     assert_eq!(n[[0, 1]], 0);
     assert_eq!(n.get((0, 1)), Some(&0));
     let mut rev = mat.reshape(4);
-    rev.islice(&[Si(0, None, -1)]);
+    rev.slice_inplace(&[Si(0, None, -1)]);
     assert_eq!(rev[0], 4);
     assert_eq!(rev[1], 3);
     assert_eq!(rev[2], 2);
@@ -228,7 +228,7 @@ fn test_cow_shrink()
     // mutation shrinks the array and gives it different strides
     //
     let mut mat = RcArray::zeros((2, 3));
-    //mat.islice(s![.., ..;2]);
+    //mat.slice_inplace(s![.., ..;2]);
     mat[[0, 0]] = 1;
     let n = mat.clone();
     mat[[0, 1]] = 2;
@@ -243,7 +243,7 @@ fn test_cow_shrink()
     assert_eq!(n.get((0, 1)), Some(&0));
     // small has non-C strides this way
     let mut small = mat.reshape(6);
-    small.islice(s![4..;-1]);
+    small.slice_inplace(s![4..;-1]);
     assert_eq!(small[0], 6);
     assert_eq!(small[1], 5);
     let before = small.clone();
@@ -367,7 +367,7 @@ fn assign()
     let mut a = arr2(&[[1, 2], [3, 4]]);
     {
         let mut v = a.view_mut();
-        v.islice(&[Si(0, Some(1), 1), S]);
+        v.slice_inplace(&[Si(0, Some(1), 1), S]);
         v.fill(0);
     }
     assert_eq!(a, arr2(&[[0, 0], [3, 4]]));
@@ -1073,7 +1073,7 @@ fn to_owned_memory_order() {
 fn to_owned_neg_stride() {
     let mut c = arr2(&[[1, 2, 3],
                        [4, 5, 6]]);
-    c.islice(s![.., ..;-1]);
+    c.slice_inplace(s![.., ..;-1]);
     let co = c.to_owned();
     assert_eq!(c, co);
 }
@@ -1238,10 +1238,10 @@ fn test_to_vec() {
                        [7, 8, 9],
                        [10,11,12]]);
 
-    a.islice(s![..;-1, ..]);
+    a.slice_inplace(s![..;-1, ..]);
     assert_eq!(a.row(3).to_vec(), vec![1, 2, 3]);
     assert_eq!(a.column(2).to_vec(), vec![12, 9, 6, 3]);
-    a.islice(s![.., ..;-1]);
+    a.slice_inplace(s![.., ..;-1]);
     assert_eq!(a.row(3).to_vec(), vec![3, 2, 1]);
 }
 
@@ -1257,7 +1257,7 @@ fn test_array_clone_unalias() {
 #[test]
 fn test_array_clone_same_view() {
     let mut a = Array::from_iter(0..9).into_shape((3, 3)).unwrap();
-    a.islice(s![..;-1, ..;-1]);
+    a.slice_inplace(s![..;-1, ..;-1]);
     let b = a.clone();
     assert_eq!(a, b);
 }