content: import numpy as np
  import scipy.sparse as sp
  
  from scipy import linalg
  from numpy.testing import (assert_array_almost_equal,
                             assert_array_equal,
                             assert_equal)
  from numpy.random import RandomState
  
  from sklearn.datasets import make_classification
  from sklearn.utils.sparsefuncs import (mean_variance_axis,
                                         incr_mean_variance_axis,
                                         inplace_column_scale,
                                         inplace_row_scale,
                                         inplace_swap_row, inplace_swap_column,
                                         min_max_axis,
                                         count_nonzero, csc_median_axis_0)
  from sklearn.utils.sparsefuncs_fast import (assign_rows_csr,
                                              inplace_csr_row_normalize_l1,
                                              inplace_csr_row_normalize_l2)
  from sklearn.utils.testing import assert_raises
  
  
  def test_mean_variance_axis0():
      X, _ = make_classification(5, 4, random_state=0)
      # Sparsify the array a little bit
      X[0, 0] = 0
      X[2, 1] = 0
      X[4, 3] = 0
      X_lil = sp.lil_matrix(X)
      X_lil[1, 0] = 0
      X[1, 0] = 0
  
      assert_raises(TypeError, mean_variance_axis, X_lil, axis=0)
  
      X_csr = sp.csr_matrix(X_lil)
      X_csc = sp.csc_matrix(X_lil)
  
      expected_dtypes = [(np.float32, np.float32),
                         (np.float64, np.float64),
                         (np.int32, np.float64),
                         (np.int64, np.float64)]
  
      for input_dtype, output_dtype in expected_dtypes:
          X_test = X.astype(input_dtype)
          for X_sparse in (X_csr, X_csc):
              X_sparse = X_sparse.astype(input_dtype)
              X_means, X_vars = mean_variance_axis(X_sparse, axis=0)
              assert_equal(X_means.dtype, output_dtype)
              assert_equal(X_vars.dtype, output_dtype)
              assert_array_almost_equal(X_means, np.mean(X_test, axis=0))
              assert_array_almost_equal(X_vars, np.var(X_test, axis=0))
  
  
  def test_mean_variance_axis1():
      X, _ = make_classification(5, 4, random_state=0)
      # Sparsify the array a little bit
      X[0, 0] = 0
      X[2, 1] = 0
      X[4, 3] = 0
      X_lil = sp.lil_matrix(X)
      X_lil[1, 0] = 0
      X[1, 0] = 0
  
      assert_raises(TypeError, mean_variance_axis, X_lil, axis=1)
  
      X_csr = sp.csr_matrix(X_lil)
      X_csc = sp.csc_matrix(X_lil)
  
      expected_dtypes = [(np.float32, np.float32),
                         (np.float64, np.float64),
                         (np.int32, np.float64),
                         (np.int64, np.float64)]
  
      for input_dtype, output_dtype in expected_dtypes:
          X_test = X.astype(input_dtype)
          for X_sparse in (X_csr, X_csc):
              X_sparse = X_sparse.astype(input_dtype)
              X_means, X_vars = mean_variance_axis(X_sparse, axis=0)
              assert_equal(X_means.dtype, output_dtype)
              assert_equal(X_vars.dtype, output_dtype)
              assert_array_almost_equal(X_means, np.mean(X_test, axis=0))
              assert_array_almost_equal(X_vars, np.var(X_test, axis=0))
  
  
  def test_incr_mean_variance_axis():
      for axis in [0, 1]:
          rng = np.random.RandomState(0)
          n_features = 50
          n_samples = 10
          data_chunks = [rng.randint(0, 2, size=n_features)
                         for i in range(n_samples)]
  
          # default params for incr_mean_variance
          last_mean = np.zeros(n_features)
          last_var = np.zeros_like(last_mean)
          last_n = 0
  
          # Test errors
          X = np.array(data_chunks[0])
          X = np.atleast_2d(X)
          X_lil = sp.lil_matrix(X)
          X_csr = sp.csr_matrix(X_lil)
          assert_raises(TypeError, incr_mean_variance_axis, axis,
                        last_mean, last_var, last_n)
          assert_raises(TypeError, incr_mean_variance_axis, axis,
                        last_mean, last_var, last_n)
          assert_raises(TypeError, incr_mean_variance_axis, X_lil, axis,
                        last_mean, last_var, last_n)
  
          # Test _incr_mean_and_var with a 1 row input
          X_means, X_vars = mean_variance_axis(X_csr, axis)
          X_means_incr, X_vars_incr, n_incr = \
              incr_mean_variance_axis(X_csr, axis, last_mean, last_var, last_n)
          assert_array_almost_equal(X_means, X_means_incr)
          assert_array_almost_equal(X_vars, X_vars_incr)
          assert_equal(X.shape[axis], n_incr)  # X.shape[axis] picks # samples
  
          X_csc = sp.csc_matrix(X_lil)
          X_means, X_vars = mean_variance_axis(X_csc, axis)
          assert_array_almost_equal(X_means, X_means_incr)
          assert_array_almost_equal(X_vars, X_vars_incr)
          assert_equal(X.shape[axis], n_incr)
  
          # Test _incremental_mean_and_var with whole data
          X = np.vstack(data_chunks)
          X_lil = sp.lil_matrix(X)
          X_csr = sp.csr_matrix(X_lil)
          X_csc = sp.csc_matrix(X_lil)
  
          expected_dtypes = [(np.float32, np.float32),
                             (np.float64, np.float64),
                             (np.int32, np.float64),
                             (np.int64, np.float64)]
  
          for input_dtype, output_dtype in expected_dtypes:
              for X_sparse in (X_csr, X_csc):
                  X_sparse = X_sparse.astype(input_dtype)
                  X_means, X_vars = mean_variance_axis(X_sparse, axis)
                  X_means_incr, X_vars_incr, n_incr = \
                      incr_mean_variance_axis(X_sparse, axis, last_mean,
                                              last_var, last_n)
                  assert_equal(X_means_incr.dtype, output_dtype)
                  assert_equal(X_vars_incr.dtype, output_dtype)
                  assert_array_almost_equal(X_means, X_means_incr)
                  assert_array_almost_equal(X_vars, X_vars_incr)
                  assert_equal(X.shape[axis], n_incr)
  
  
  def test_mean_variance_illegal_axis():
      X, _ = make_classification(5, 4, random_state=0)
      # Sparsify the array a little bit
      X[0, 0] = 0
      X[2, 1] = 0
      X[4, 3] = 0
      X_csr = sp.csr_matrix(X)
      assert_raises(ValueError, mean_variance_axis, X_csr, axis=-3)
      assert_raises(ValueError, mean_variance_axis, X_csr, axis=2)
      assert_raises(ValueError, mean_variance_axis, X_csr, axis=-1)
  
      assert_raises(ValueError, incr_mean_variance_axis, X_csr, axis=-3,
                    last_mean=None, last_var=None, last_n=None)
      assert_raises(ValueError, incr_mean_variance_axis, X_csr, axis=2,
                    last_mean=None, last_var=None, last_n=None)
      assert_raises(ValueError, incr_mean_variance_axis, X_csr, axis=-1,
                    last_mean=None, last_var=None, last_n=None)
  
  
  def test_densify_rows():
      for dtype in (np.float32, np.float64):
          X = sp.csr_matrix([[0, 3, 0],
                          [2, 4, 0],
                          [0, 0, 0],
                          [9, 8, 7],
                          [4, 0, 5]], dtype=dtype)
          X_rows = np.array([0, 2, 3], dtype=np.intp)
          out = np.ones((6, X.shape[1]), dtype=dtype)
          out_rows = np.array([1, 3, 4], dtype=np.intp)
  
          expect = np.ones_like(out)
          expect[out_rows] = X[X_rows, :].toarray()
  
          assign_rows_csr(X, X_rows, out_rows, out)
          assert_array_equal(out, expect)
  
  
  def test_inplace_column_scale():
      rng = np.random.RandomState(0)
      X = sp.rand(100, 200, 0.05)
      Xr = X.tocsr()
      Xc = X.tocsc()
      XA = X.toarray()
      scale = rng.rand(200)
      XA *= scale
  
      inplace_column_scale(Xc, scale)
      inplace_column_scale(Xr, scale)
      assert_array_almost_equal(Xr.toarray(), Xc.toarray())
      assert_array_almost_equal(XA, Xc.toarray())
      assert_array_almost_equal(XA, Xr.toarray())
      assert_raises(TypeError, inplace_column_scale, X.tolil(), scale)
  
      X = X.astype(np.float32)
      scale = scale.astype(np.float32)
      Xr = X.tocsr()
      Xc = X.tocsc()
      XA = X.toarray()
      XA *= scale
      inplace_column_scale(Xc, scale)
      inplace_column_scale(Xr, scale)
      assert_array_almost_equal(Xr.toarray(), Xc.toarray())
      assert_array_almost_equal(XA, Xc.toarray())
      assert_array_almost_equal(XA, Xr.toarray())
      assert_raises(TypeError, inplace_column_scale, X.tolil(), scale)
  
  
  def test_inplace_row_scale():
      rng = np.random.RandomState(0)
      X = sp.rand(100, 200, 0.05)
      Xr = X.tocsr()
      Xc = X.tocsc()
      XA = X.toarray()
      scale = rng.rand(100)
      XA *= scale.reshape(-1, 1)
  
      inplace_row_scale(Xc, scale)
      inplace_row_scale(Xr, scale)
      assert_array_almost_equal(Xr.toarray(), Xc.toarray())
      assert_array_almost_equal(XA, Xc.toarray())
      assert_array_almost_equal(XA, Xr.toarray())
      assert_raises(TypeError, inplace_column_scale, X.tolil(), scale)
  
      X = X.astype(np.float32)
      scale = scale.astype(np.float32)
      Xr = X.tocsr()
      Xc = X.tocsc()
      XA = X.toarray()
      XA *= scale.reshape(-1, 1)
      inplace_row_scale(Xc, scale)
      inplace_row_scale(Xr, scale)
      assert_array_almost_equal(Xr.toarray(), Xc.toarray())
      assert_array_almost_equal(XA, Xc.toarray())
      assert_array_almost_equal(XA, Xr.toarray())
      assert_raises(TypeError, inplace_column_scale, X.tolil(), scale)
  
  
  def test_inplace_swap_row():
      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])
      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])
      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())
      assert_raises(TypeError, inplace_swap_row, X_csr.tolil())
  
      X = np.array([[0, 3, 0],
                    [2, 4, 0],
                    [0, 0, 0],
                    [9, 8, 7],
                    [4, 0, 5]], dtype=np.float32)
      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])
      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])
      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())
      assert_raises(TypeError, inplace_swap_row, X_csr.tolil())
  
  
  def test_inplace_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])
      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])
      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())
      assert_raises(TypeError, inplace_swap_column, X_csr.tolil())
  
      X = np.array([[0, 3, 0],
                    [2, 4, 0],
                    [0, 0, 0],
                    [9, 8, 7],
                    [4, 0, 5]], dtype=np.float32)
      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])
      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])
      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())
      assert_raises(TypeError, inplace_swap_column, X_csr.tolil())
  
  
  def test_min_max_axis0():
      X = np.array([[0, 3, 0],
                    [2, -1, 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)
  
      mins_csr, maxs_csr = min_max_axis(X_csr, axis=0)
      assert_array_equal(mins_csr, X.min(axis=0))
      assert_array_equal(maxs_csr, X.max(axis=0))
  
      mins_csc, maxs_csc = min_max_axis(X_csc, axis=0)
      assert_array_equal(mins_csc, X.min(axis=0))
      assert_array_equal(maxs_csc, X.max(axis=0))
  
      X = X.astype(np.float32)
      X_csr = sp.csr_matrix(X)
      X_csc = sp.csc_matrix(X)
      mins_csr, maxs_csr = min_max_axis(X_csr, axis=0)
      assert_array_equal(mins_csr, X.min(axis=0))
      assert_array_equal(maxs_csr, X.max(axis=0))
      mins_csc, maxs_csc = min_max_axis(X_csc, axis=0)
      assert_array_equal(mins_csc, X.min(axis=0))
      assert_array_equal(maxs_csc, X.max(axis=0))
  
  
  def test_min_max_axis1():
      X = np.array([[0, 3, 0],
                    [2, -1, 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)
  
      mins_csr, maxs_csr = min_max_axis(X_csr, axis=1)
      assert_array_equal(mins_csr, X.min(axis=1))
      assert_array_equal(maxs_csr, X.max(axis=1))
  
      mins_csc, maxs_csc = min_max_axis(X_csc, axis=1)
      assert_array_equal(mins_csc, X.min(axis=1))
      assert_array_equal(maxs_csc, X.max(axis=1))
  
      X = X.astype(np.float32)
      X_csr = sp.csr_matrix(X)
      X_csc = sp.csc_matrix(X)
      mins_csr, maxs_csr = min_max_axis(X_csr, axis=1)
      assert_array_equal(mins_csr, X.min(axis=1))
      assert_array_equal(maxs_csr, X.max(axis=1))
      mins_csc, maxs_csc = min_max_axis(X_csc, axis=1)
      assert_array_equal(mins_csc, X.min(axis=1))
      assert_array_equal(maxs_csc, X.max(axis=1))
  
  
  def test_min_max_axis_errors():
      X = np.array([[0, 3, 0],
                    [2, -1, 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)
      assert_raises(TypeError, min_max_axis, X_csr.tolil(), axis=0)
      assert_raises(ValueError, min_max_axis, X_csr, axis=2)
      assert_raises(ValueError, min_max_axis, X_csc, axis=-3)
  
  
  def test_count_nonzero():
      X = np.array([[0, 3, 0],
                    [2, -1, 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)
      X_nonzero = X != 0
      sample_weight = [.5, .2, .3, .1, .1]
      X_nonzero_weighted = X_nonzero * np.array(sample_weight)[:, None]
  
      for axis in [0, 1, -1, -2, None]:
          assert_array_almost_equal(count_nonzero(X_csr, axis=axis),
                                    X_nonzero.sum(axis=axis))
          assert_array_almost_equal(count_nonzero(X_csr, axis=axis,
                                                  sample_weight=sample_weight),
                                    X_nonzero_weighted.sum(axis=axis))
  
      assert_raises(TypeError, count_nonzero, X_csc)
      assert_raises(ValueError, count_nonzero, X_csr, axis=2)
  
  
  def test_csc_row_median():
      # Test csc_row_median actually calculates the median.
  
      # Test that it gives the same output when X is dense.
      rng = np.random.RandomState(0)
      X = rng.rand(100, 50)
      dense_median = np.median(X, axis=0)
      csc = sp.csc_matrix(X)
      sparse_median = csc_median_axis_0(csc)
      assert_array_equal(sparse_median, dense_median)
  
      # Test that it gives the same output when X is sparse
      X = rng.rand(51, 100)
      X[X < 0.7] = 0.0
      ind = rng.randint(0, 50, 10)
      X[ind] = -X[ind]
      csc = sp.csc_matrix(X)
      dense_median = np.median(X, axis=0)
      sparse_median = csc_median_axis_0(csc)
      assert_array_equal(sparse_median, dense_median)
  
      # Test for toy data.
      X = [[0, -2], [-1, -1], [1, 0], [2, 1]]
      csc = sp.csc_matrix(X)
      assert_array_equal(csc_median_axis_0(csc), np.array([0.5, -0.5]))
      X = [[0, -2], [-1, -5], [1, -3]]
      csc = sp.csc_matrix(X)
      assert_array_equal(csc_median_axis_0(csc), np.array([0., -3]))
  
      # Test that it raises an Error for non-csc matrices.
      assert_raises(TypeError, csc_median_axis_0, sp.csr_matrix(X))
  
  
  def test_inplace_normalize():
      ones = np.ones((10, 1))
      rs = RandomState(10)
  
      for inplace_csr_row_normalize in (inplace_csr_row_normalize_l1,
                                        inplace_csr_row_normalize_l2):
          for dtype in (np.float64, np.float32):
              X = rs.randn(10, 5).astype(dtype)
              X_csr = sp.csr_matrix(X)
              for index_dtype in [np.int32, np.int64]:
                  # csr_matrix will use int32 indices by default,
                  # up-casting those to int64 when necessary
                  if index_dtype is np.int64:
                      X_csr.indptr = X_csr.indptr.astype(index_dtype)
                      X_csr.indices = X_csr.indices.astype(index_dtype)
                  assert X_csr.indices.dtype == index_dtype
                  assert X_csr.indptr.dtype == index_dtype
                  inplace_csr_row_normalize(X_csr)
                  assert_equal(X_csr.dtype, dtype)
                  if inplace_csr_row_normalize is inplace_csr_row_normalize_l2:
                      X_csr.data **= 2
                  assert_array_almost_equal(np.abs(X_csr).sum(axis=1), ones)
  