CLN: Cleanup tests for .rank()

Work in Progress

1. Created new `pandas/tests/series/test_rank` and `pandas/tests/frame/test_rank`
2. Moved tests from `pandas/tests/test_stats` to `series` or `frame`
version of `test_rank`

See pandas-dev#15640

Author: rouzazari

pandas/tests/frame/test_rank.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+from pandas import compat
+
+from distutils.version import LooseVersion
+from numpy import nan
+import numpy as np
+
+from pandas import Series, DataFrame
+
+from pandas.compat import product
+from pandas.util.testing import assert_frame_equal
+import pandas.util.testing as tm
+
+
+class TestRank(tm.TestCase):
+    s = Series([1, 3, 4, 2, nan, 2, 1, 5, nan, 3])
+    df = DataFrame({'A': s, 'B': s})
+
+    results = {
+        'average': np.array([1.5, 5.5, 7.0, 3.5, nan,
+                             3.5, 1.5, 8.0, nan, 5.5]),
+        'min': np.array([1, 5, 7, 3, nan, 3, 1, 8, nan, 5]),
+        'max': np.array([2, 6, 7, 4, nan, 4, 2, 8, nan, 6]),
+        'first': np.array([1, 5, 7, 3, nan, 4, 2, 8, nan, 6]),
+        'dense': np.array([1, 3, 4, 2, nan, 2, 1, 5, nan, 3]),
+    }
+
+    def test_rank_methods_frame(self):
+        tm.skip_if_no_package('scipy', '0.13', 'scipy.stats.rankdata')
+        import scipy
+        from scipy.stats import rankdata
+
+        xs = np.random.randint(0, 21, (100, 26))
+        xs = (xs - 10.0) / 10.0
+        cols = [chr(ord('z') - i) for i in range(xs.shape[1])]
+
+        for vals in [xs, xs + 1e6, xs * 1e-6]:
+            df = DataFrame(vals, columns=cols)
+
+            for ax in [0, 1]:
+                for m in ['average', 'min', 'max', 'first', 'dense']:
+                    result = df.rank(axis=ax, method=m)
+                    sprank = np.apply_along_axis(
+                        rankdata, ax, vals,
+                        m if m != 'first' else 'ordinal')
+                    sprank = sprank.astype(np.float64)
+                    expected = DataFrame(sprank, columns=cols)
+
+                    if LooseVersion(scipy.__version__) >= '0.17.0':
+                        expected = expected.astype('float64')
+                    tm.assert_frame_equal(result, expected)
+
+    def test_rank_descending(self):
+        dtypes = ['O', 'f8', 'i8']
+
+        for dtype, method in product(dtypes, self.results):
+            if 'i' in dtype:
+                df = self.df.dropna()
+            else:
+                df = self.df.astype(dtype)
+
+            res = df.rank(ascending=False)
+            expected = (df.max() - df).rank()
+            assert_frame_equal(res, expected)
+
+            if method == 'first' and dtype == 'O':
+                continue
+
+            expected = (df.max() - df).rank(method=method)
+
+            if dtype != 'O':
+                res2 = df.rank(method=method, ascending=False,
+                               numeric_only=True)
+                assert_frame_equal(res2, expected)
+
+            res3 = df.rank(method=method, ascending=False,
+                           numeric_only=False)
+            assert_frame_equal(res3, expected)
+
+    def test_rank_2d_tie_methods(self):
+        df = self.df
+
+        def _check2d(df, expected, method='average', axis=0):
+            exp_df = DataFrame({'A': expected, 'B': expected})
+
+            if axis == 1:
+                df = df.T
+                exp_df = exp_df.T
+
+            result = df.rank(method=method, axis=axis)
+            assert_frame_equal(result, exp_df)
+
+        dtypes = [None, object]
+        disabled = set([(object, 'first')])
+        results = self.results
+
+        for method, axis, dtype in product(results, [0, 1], dtypes):
+            if (dtype, method) in disabled:
+                continue
+            frame = df if dtype is None else df.astype(dtype)
+            _check2d(frame, results[method], method=method, axis=axis)            
+
+

pandas/tests/test_stats.py renamed to pandas/tests/series/test_rank.py

@@ -5,16 +5,15 @@
 from numpy import nan
 import numpy as np
 
-from pandas import Series, DataFrame
+from pandas import Series
 
 from pandas.compat import product
-from pandas.util.testing import (assert_frame_equal, assert_series_equal)
+from pandas.util.testing import assert_series_equal
 import pandas.util.testing as tm
 
 
-class TestRank(tm.TestCase):
+class TestSeriesRank(tm.TestCase):
     s = Series([1, 3, 4, 2, nan, 2, 1, 5, nan, 3])
-    df = DataFrame({'A': s, 'B': s})
 
     results = {
         'average': np.array([1.5, 5.5, 7.0, 3.5, nan,
@@ -42,6 +41,7 @@ def _check(s, expected, method='average'):
             series = s if dtype is None else s.astype(dtype)
             _check(series, results[method], method=method)
 
+
     def test_rank_methods_series(self):
         tm.skip_if_no_package('scipy', '0.13', 'scipy.stats.rankdata')
         import scipy
@@ -65,31 +65,6 @@ def test_rank_methods_series(self):
                     expected = expected.astype('float64')
                 tm.assert_series_equal(result, expected)
 
-    def test_rank_methods_frame(self):
-        tm.skip_if_no_package('scipy', '0.13', 'scipy.stats.rankdata')
-        import scipy
-        from scipy.stats import rankdata
-
-        xs = np.random.randint(0, 21, (100, 26))
-        xs = (xs - 10.0) / 10.0
-        cols = [chr(ord('z') - i) for i in range(xs.shape[1])]
-
-        for vals in [xs, xs + 1e6, xs * 1e-6]:
-            df = DataFrame(vals, columns=cols)
-
-            for ax in [0, 1]:
-                for m in ['average', 'min', 'max', 'first', 'dense']:
-                    result = df.rank(axis=ax, method=m)
-                    sprank = np.apply_along_axis(
-                        rankdata, ax, vals,
-                        m if m != 'first' else 'ordinal')
-                    sprank = sprank.astype(np.float64)
-                    expected = DataFrame(sprank, columns=cols)
-
-                    if LooseVersion(scipy.__version__) >= '0.17.0':
-                        expected = expected.astype('float64')
-                    tm.assert_frame_equal(result, expected)
-
     def test_rank_dense_method(self):
         dtypes = ['O', 'f8', 'i8']
         in_out = [([1], [1]),
@@ -106,67 +81,28 @@ def test_rank_dense_method(self):
                 s = Series(ser).astype(dtype)
                 result = s.rank(method='dense')
                 expected = Series(exp).astype(result.dtype)
-                assert_series_equal(result, expected)
+                assert_series_equal(result, expected)                
 
     def test_rank_descending(self):
         dtypes = ['O', 'f8', 'i8']
 
         for dtype, method in product(dtypes, self.results):
             if 'i' in dtype:
                 s = self.s.dropna()
-                df = self.df.dropna()
             else:
                 s = self.s.astype(dtype)
-                df = self.df.astype(dtype)
 
             res = s.rank(ascending=False)
             expected = (s.max() - s).rank()
             assert_series_equal(res, expected)
 
-            res = df.rank(ascending=False)
-            expected = (df.max() - df).rank()
-            assert_frame_equal(res, expected)
-
             if method == 'first' and dtype == 'O':
                 continue
 
             expected = (s.max() - s).rank(method=method)
             res2 = s.rank(method=method, ascending=False)
             assert_series_equal(res2, expected)
 
-            expected = (df.max() - df).rank(method=method)
-
-            if dtype != 'O':
-                res2 = df.rank(method=method, ascending=False,
-                               numeric_only=True)
-                assert_frame_equal(res2, expected)
-
-            res3 = df.rank(method=method, ascending=False,
-                           numeric_only=False)
-            assert_frame_equal(res3, expected)
-
-    def test_rank_2d_tie_methods(self):
-        df = self.df
-
-        def _check2d(df, expected, method='average', axis=0):
-            exp_df = DataFrame({'A': expected, 'B': expected})
-
-            if axis == 1:
-                df = df.T
-                exp_df = exp_df.T
-
-            result = df.rank(method=method, axis=axis)
-            assert_frame_equal(result, exp_df)
-
-        dtypes = [None, object]
-        disabled = set([(object, 'first')])
-        results = self.results
-
-        for method, axis, dtype in product(results, [0, 1], dtypes):
-            if (dtype, method) in disabled:
-                continue
-            frame = df if dtype is None else df.astype(dtype)
-            _check2d(frame, results[method], method=method, axis=axis)
 
     def test_rank_int(self):
         s = self.s.dropna().astype('i8')