Rename subview_mut to index_axis_mut

Author: jturner314

examples/sort-axis.rs

@@ -109,7 +109,7 @@ impl<A, D> PermuteArray for Array<A, D>
             result = Array::from_shape_vec_unchecked(self.dim(), v);
             for i in 0..axis_len {
                 let perm_i = perm.indices[i];
-                Zip::from(result.subview_mut(axis, perm_i))
+                Zip::from(result.index_axis_mut(axis, perm_i))
                     .and(self.subview(axis, i))
                     .apply(|to, from| {
                         copy_nonoverlapping(from, to, 1)

src/impl_2d.rs

@@ -28,7 +28,7 @@ impl<A, S> ArrayBase<S, Ix2>
     pub fn row_mut(&mut self, index: Ix) -> ArrayViewMut1<A>
         where S: DataMut
     {
-        self.subview_mut(Axis(0), index)
+        self.index_axis_mut(Axis(0), index)
     }
 
     /// Return the number of rows (length of `Axis(0)`) in the two-dimensional array.
@@ -50,7 +50,7 @@ impl<A, S> ArrayBase<S, Ix2>
     pub fn column_mut(&mut self, index: Ix) -> ArrayViewMut1<A>
         where S: DataMut
     {
-        self.subview_mut(Axis(1), index)
+        self.index_axis_mut(Axis(1), index)
     }
 
     /// Return the number of columns (length of `Axis(1)`) in the two-dimensional array.

src/impl_methods.rs

@@ -542,6 +542,38 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
         }
     }
 
+    /// Along `axis`, select the subview `index` and return a read-write view
+    /// with the axis removed.
+    ///
+    /// **Panics** if `axis` or `index` is out of bounds.
+    ///
+    /// ```
+    /// use ndarray::{arr2, aview2, Axis};
+    ///
+    /// let mut a = arr2(&[[1., 2. ],
+    ///                    [3., 4. ]]);
+    /// //                   .   \
+    /// //                    .   axis 1, column 1
+    /// //                     axis 1, column 0
+    ///
+    /// {
+    ///     let mut column1 = a.index_axis_mut(Axis(1), 1);
+    ///     column1 += 10.;
+    /// }
+    ///
+    /// assert!(
+    ///     a == aview2(&[[1., 12.],
+    ///                   [3., 14.]])
+    /// );
+    /// ```
+    pub fn index_axis_mut(&mut self, axis: Axis, index: usize) -> ArrayViewMut<A, D::Smaller>
+    where
+        S: DataMut,
+        D: RemoveAxis,
+    {
+        self.view_mut().into_subview(axis, index)
+    }
+
     /// Collapse the axis into length one, selecting the subview at the given
     /// `index` along the axis.
     ///
@@ -582,32 +614,13 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
     /// with the axis removed.
     ///
     /// **Panics** if `axis` or `index` is out of bounds.
-    ///
-    /// ```
-    /// use ndarray::{arr2, aview2, Axis};
-    ///
-    /// let mut a = arr2(&[[1., 2. ],
-    ///                    [3., 4. ]]);
-    /// //                   .   \
-    /// //                    .   axis 1, column 1
-    /// //                     axis 1, column 0
-    ///
-    /// {
-    ///     let mut column1 = a.subview_mut(Axis(1), 1);
-    ///     column1 += 10.;
-    /// }
-    ///
-    /// assert!(
-    ///     a == aview2(&[[1., 12.],
-    ///                   [3., 14.]])
-    /// );
-    /// ```
+    #[deprecated(note="renamed to `index_axis_mut`", since="0.12.1")]
     pub fn subview_mut(&mut self, axis: Axis, index: Ix)
         -> ArrayViewMut<A, D::Smaller>
         where S: DataMut,
               D: RemoveAxis,
     {
-        self.view_mut().into_subview(axis, index)
+        self.index_axis_mut(axis, index)
     }
 
     /// Collapse dimension `axis` into length one,
@@ -1894,7 +1907,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
         let view_stride = self.strides.axis(axis);
         // use the 0th subview as a map to each 1d array view extended from
         // the 0th element.
-        self.subview_mut(axis, 0).map_mut(|first_elt: &mut A| {
+        self.index_axis_mut(axis, 0).map_mut(|first_elt: &mut A| {
             unsafe {
                 mapping(ArrayViewMut::new_(first_elt, Ix1(view_len), Ix1(view_stride)))
             }

src/lib.rs

@@ -521,14 +521,14 @@ pub type Ixs = isize;
 ///
 /// Subview methods allow you to restrict the array view while removing one
 /// axis from the array. Subview methods include [`.subview()`],
-/// [`.subview_mut()`], [`.into_subview()`], and [`.collapse_axis()`]. You
+/// [`.index_axis_mut()`], [`.into_subview()`], and [`.collapse_axis()`]. You
 /// can also take a subview by using a single index instead of a range when
 /// slicing.
 ///
 /// Subview takes two arguments: `axis` and `index`.
 ///
 /// [`.subview()`]: #method.subview
-/// [`.subview_mut()`]: #method.subview_mut
+/// [`.index_axis_mut()`]: #method.index_axis_mut
 /// [`.into_subview()`]: #method.into_subview
 /// [`.collapse_axis()`]: #method.collapse_axis
 ///