Made the following changes

1. Minor changes to docs
2. Replaced swap with inplace_swap

Author: MechCoder

sklearn/utils/sparsefuncs.py

@@ -59,16 +59,25 @@ def inplace_column_scale(X, scale):
                 "Unsupported type; expected a CSR or CSC sparse matrix.")
 
 
-def swap_row_csc(X, m, n):
+def inplace_swap_row_csc(X, m, n):
     """
     Swaps two rows of a CSC matrix in-place.
 
     Parameters
     ----------
-    X : scipy.sparse.csc_matrix, shape=(n_samples, n_features)
-    m : int, index of first sample
-    n : int, index of second sample
+    X: scipy.sparse.csc_matrix, shape=(n_samples, n_features)
+        Matrix whose two rows are to be swapped.
+
+    m: int
+        Index of the row of X to be swapped.
+
+    n: int
+        Index of the row of X to be swapped.
     """
+    for t in [m, n]:
+        if isinstance(t, np.ndarray):
+            raise TypeError("m and n should be valid integers")
+
     if m < 0:
         m += X.shape[0]
     if n < 0:
@@ -79,20 +88,32 @@ def swap_row_csc(X, m, n):
     X.indices[m_mask] = n
 
 
-def swap_row_csr(X, m, n):
+def inplace_swap_row_csr(X, m, n):
     """
     Swaps two rows of a CSR matrix in-place.
 
     Parameters
     ----------
-    X : scipy.sparse.csc_matrix, shape=(n_samples, n_features)
-    m : int, index of first sample
-    n : int, index of second sample
+    X: scipy.sparse.csr_matrix, shape=(n_samples, n_features)
+        Matrix whose two rows are to be swapped.
+
+    m: int
+        Index of the row of X to be swapped.
+
+    n: int
+        Index of the row of X to be swapped.
     """
+    for t in [m, n]:
+        if isinstance(t, np.ndarray):
+            raise TypeError("m and n should be valid integers")
+
     if m < 0:
         m += X.shape[0]
     if n < 0:
         n += X.shape[0]
+
+    # The following swapping makes life easier since m is assumed to be the
+    # smaller integer below.
     if m > n:
         m, n = n, m
 
@@ -123,43 +144,53 @@ def swap_row_csr(X, m, n):
                              X.data[n_stop:]])
 
 
-def swap_row(X, m, n):
+def inplace_swap_row(X, m, n):
     """
     Swaps two rows of a CSC/CSR matrix in-place.
 
     Parameters
     ----------
-    X : scipy.sparse.csc_matrix, shape=(n_samples, n_features)
-    m : int, index of first sample
-    n : int, index of second sample
+    X : CSR or CSC sparse matrix, shape=(n_samples, n_features)
+        Matrix whose two rows are to be swapped.
+
+    m: int
+        Index of the row of X to be swapped.
+
+    n: int
+        Index of the row of X to be swapped.
     """
     if isinstance(X, sp.csc_matrix):
-        return swap_row_csc(X, m, n)
+        return inplace_swap_row_csc(X, m, n)
     elif isinstance(X, sp.csr_matrix):
-        return swap_row_csr(X, m, n)
+        return inplace_swap_row_csr(X, m, n)
     else:
         raise TypeError(
             "Unsupported type; expected a CSR or CSC sparse matrix.")
 
 
-def swap_column(X, m, n):
+def inplace_swap_column(X, m, n):
     """
     Swaps two columns of a CSC/CSR matrix in-place.
 
     Parameters
     ----------
-    X : scipy.sparse.csc_matrix, shape=(n_samples, n_features)
-    m : int, index of first sample
-    n : int, index of second sample
+    X : CSR or CSC sparse matrix, shape=(n_samples, n_features)
+        Matrix whose two columns are to be swapped.
+
+    m: int
+        Index of the column of X to be swapped.
+
+    n : int
+        Index of the column of X to be swapped.
     """
     if m < 0:
         m += X.shape[1]
     if n < 0:
         n += X.shape[1]
     if isinstance(X, sp.csc_matrix):
-        return swap_row_csr(X, m, n)
+        return inplace_swap_row_csr(X, m, n)
     elif isinstance(X, sp.csr_matrix):
-        return swap_row_csc(X, m, n)
+        return inplace_swap_row_csc(X, m, n)
     else:
         raise TypeError(
             "Unsupported type; expected a CSR or CSC sparse matrix.")

sklearn/utils/tests/test_sparsefuncs.py

@@ -7,7 +7,7 @@
 from sklearn.datasets import make_classification
 from sklearn.utils.sparsefuncs import (mean_variance_axis0,
                                        inplace_column_scale,
-                                       swap_row, swap_column)
+                                       inplace_swap_row, inplace_swap_column)
 from sklearn.utils.sparsefuncs_fast import assign_rows_csr
 from sklearn.utils.testing import assert_raises
 
@@ -65,7 +65,7 @@ def test_inplace_column_scale():
     assert_raises(TypeError, inplace_column_scale, X.tolil(), scale)
 
 
-def test_swap_row():
+def test_inplace_swap_row():
     X = np.array([[0, 3, 0],
                   [2, 4, 0],
                   [0, 0, 0],
@@ -77,21 +77,21 @@ def test_swap_row():
     swap = linalg.get_blas_funcs(('swap',), (X,))
     swap = swap[0]
     X[0], X[-1] = swap(X[0], X[-1])
-    swap_row(X_csr, 0, -1)
-    swap_row(X_csc, 0, -1)
+    inplace_swap_row(X_csr, 0, -1)
+    inplace_swap_row(X_csc, 0, -1)
     assert_array_equal(X_csr.toarray(), X_csc.toarray())
     assert_array_equal(X, X_csc.toarray())
     assert_array_equal(X, X_csr.toarray())
 
     X[2], X[3] = swap(X[2], X[3])
-    swap_row(X_csr, 2, 3)
-    swap_row(X_csc, 2, 3)
+    inplace_swap_row(X_csr, 2, 3)
+    inplace_swap_row(X_csc, 2, 3)
     assert_array_equal(X_csr.toarray(), X_csc.toarray())
     assert_array_equal(X, X_csc.toarray())
     assert_array_equal(X, X_csr.toarray())
 
 
-def test_swap_column():
+def test_inplace_swap_column():
     X = np.array([[0, 3, 0],
                   [2, 4, 0],
                   [0, 0, 0],
@@ -103,15 +103,15 @@ def test_swap_column():
     swap = linalg.get_blas_funcs(('swap',), (X,))
     swap = swap[0]
     X[:, 0], X[:, -1] = swap(X[:, 0], X[:, -1])
-    swap_column(X_csr, 0, -1)
-    swap_column(X_csc, 0, -1)
+    inplace_swap_column(X_csr, 0, -1)
+    inplace_swap_column(X_csc, 0, -1)
     assert_array_equal(X_csr.toarray(), X_csc.toarray())
     assert_array_equal(X, X_csc.toarray())
     assert_array_equal(X, X_csr.toarray())
 
     X[:, 0], X[:, 1] = swap(X[:, 0], X[:, 1])
-    swap_column(X_csr, 0, 1)
-    swap_column(X_csc, 0, 1)
+    inplace_swap_column(X_csr, 0, 1)
+    inplace_swap_column(X_csc, 0, 1)
     assert_array_equal(X_csr.toarray(), X_csc.toarray())
     assert_array_equal(X, X_csc.toarray())
     assert_array_equal(X, X_csr.toarray())