Made the following changes

a] Replaced numpy slicing with concatanate
b] Added swap_sparse_column

Author: MechCoder

sklearn/utils/sparsefuncs.py

@@ -2,6 +2,7 @@
 
 # License: BSD 3 clause
 import scipy.sparse as sp
+import numpy as np
 
 from .sparsefuncs_fast import (csr_mean_variance_axis0,
                                csc_mean_variance_axis0,
@@ -66,7 +67,7 @@ def swap_row_csc(X, m, n):
     ----------
     X : scipy.sparse.csc_matrix, shape=(n_samples, n_features)
     m : int, index of first sample
-    m : int, index of second sample
+    n : int, index of second sample
     """
     if m < 0:
         m += X.shape[0]
@@ -86,7 +87,7 @@ def swap_row_csr(X, m, n):
     ----------
     X : scipy.sparse.csc_matrix, shape=(n_samples, n_features)
     m : int, index of first sample
-    m : int, index of second sample
+    n : int, index of second sample
     """
     if m < 0:
         m += X.shape[0]
@@ -96,43 +97,27 @@ def swap_row_csr(X, m, n):
         m, n = n, m
 
     indptr = X.indptr
-    indices = X.indices.copy()
-    data = X.data.copy()
-
-    nz_m = indptr[m + 1] - indptr[m]
-    nz_n = indptr[n + 1] - indptr[n]
     m_ptr1 = indptr[m]
     m_ptr2 = indptr[m + 1]
     n_ptr1 = indptr[n]
     n_ptr2 = indptr[n + 1]
+    nz_m = m_ptr2 - m_ptr1
+    nz_n = n_ptr2 - n_ptr1
 
-    # If non zero rows are equal in mth and nth row, then swapping becomes
-    # easy.
-    if nz_m == nz_n:
-        mask = X.indices[m_ptr1: m_ptr2].copy()
-        X.indices[m_ptr1: m_ptr2] = X.indices[n_ptr1: n_ptr2]
-        X.indices[n_ptr1: n_ptr2] = mask
-        mask = X.data[m_ptr1: m_ptr2].copy()
-        X.data[m_ptr1: m_ptr2] = X.data[n_ptr1: n_ptr2]
-        X.data[n_ptr1: n_ptr2] = mask
 
-    else:
+    if nz_m != nz_n:
         # Modify indptr first
-        X.indptr[m + 2: n] += nz_n - nz_m
+        X.indptr[m + 2:n] += nz_n - nz_m
         X.indptr[m + 1] = X.indptr[m] + nz_n
         X.indptr[n] = X.indptr[n + 1] - nz_m
 
-        mask1 = X.indices[m_ptr1: m_ptr2].copy()
-        mask2 = X.indices[n_ptr1: n_ptr2].copy()
-        X.indices[m_ptr1: m_ptr1 + nz_n] = mask2
-        X.indices[n_ptr2 - nz_m: n_ptr2] = mask1
-        X.indices[m_ptr1 + nz_n: n_ptr2 - nz_m] = indices[m_ptr2: n_ptr1]
-
-        mask1 = X.data[m_ptr1: m_ptr2].copy()
-        mask2 = X.data[n_ptr1: n_ptr2].copy()
-        X.data[m_ptr1: m_ptr1 + nz_n] = mask2
-        X.data[n_ptr2 - nz_m: n_ptr2] = mask1
-        X.data[m_ptr1 + nz_n: n_ptr2 - nz_m] = data[m_ptr2: n_ptr1]
+    X.indices = np.concatenate([X.indices[:m_ptr1], X.indices[n_ptr1:n_ptr2],
+                                X.indices[m_ptr2:n_ptr1],
+                                X.indices[m_ptr1:m_ptr2],
+                                X.indices[n_ptr2:]])
+    X.data = np.concatenate([X.data[:m_ptr1], X.data[n_ptr1:n_ptr2],
+                             X.data[m_ptr2:n_ptr1], X.data[m_ptr1:m_ptr2],
+                             X.data[n_ptr2:]])
 
 
 def swap_row(X, m, n):
@@ -143,7 +128,7 @@ def swap_row(X, m, n):
     ----------
     X : scipy.sparse.csc_matrix, shape=(n_samples, n_features)
     m : int, index of first sample
-    m : int, index of second sample
+    n : int, index of second sample
     """
     if isinstance(X, sp.csc_matrix):
         return swap_row_csc(X, m, n)
@@ -152,3 +137,26 @@ def swap_row(X, m, n):
     else:
         raise TypeError(
             "Unsupported type; expected a CSR or CSC sparse matrix.")
+
+
+def 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
+    """
+    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)
+    elif isinstance(X, sp.csr_matrix):
+        return 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_row, swap_column)
 from sklearn.utils.sparsefuncs_fast import assign_rows_csr
 from sklearn.utils.testing import assert_raises
 
@@ -89,3 +89,29 @@ def test_swap_row():
     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():
+    X = np.array([[0, 3, 0],
+                  [2, 4, 0],
+                  [0, 0, 0],
+                  [9, 8, 7],
+                  [4, 0, 5]], dtype=np.float64)
+    X_csr = sp.csr_matrix(X)
+    X_csc = sp.csc_matrix(X)
+
+    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)
+    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)
+    assert_array_equal(X_csr.toarray(), X_csc.toarray())
+    assert_array_equal(X, X_csc.toarray())
+    assert_array_equal(X, X_csr.toarray())