REF: collect tests by method

pandas/tests/frame/methods/test_matmul.py

@@ -0,0 +1,82 @@
+import operator
+
+import numpy as np
+import pytest
+
+from pandas import DataFrame, Index, Series
+import pandas._testing as tm
+
+
+class TestMatMul:
+    def test_matmul(self):
+        # matmul test is for GH#10259
+        a = DataFrame(
+            np.random.randn(3, 4), index=["a", "b", "c"], columns=["p", "q", "r", "s"]
+        )
+        b = DataFrame(
+            np.random.randn(4, 2), index=["p", "q", "r", "s"], columns=["one", "two"]
+        )
+
+        # DataFrame @ DataFrame
+        result = operator.matmul(a, b)
+        expected = DataFrame(
+            np.dot(a.values, b.values), index=["a", "b", "c"], columns=["one", "two"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # DataFrame @ Series
+        result = operator.matmul(a, b.one)
+        expected = Series(np.dot(a.values, b.one.values), index=["a", "b", "c"])
+        tm.assert_series_equal(result, expected)
+
+        # np.array @ DataFrame
+        result = operator.matmul(a.values, b)
+        assert isinstance(result, DataFrame)
+        assert result.columns.equals(b.columns)
+        assert result.index.equals(Index(range(3)))
+        expected = np.dot(a.values, b.values)
+        tm.assert_almost_equal(result.values, expected)
+
+        # nested list @ DataFrame (__rmatmul__)
+        result = operator.matmul(a.values.tolist(), b)
+        expected = DataFrame(
+            np.dot(a.values, b.values), index=["a", "b", "c"], columns=["one", "two"]
+        )
+        tm.assert_almost_equal(result.values, expected.values)
+
+        # mixed dtype DataFrame @ DataFrame
+        a["q"] = a.q.round().astype(int)
+        result = operator.matmul(a, b)
+        expected = DataFrame(
+            np.dot(a.values, b.values), index=["a", "b", "c"], columns=["one", "two"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # different dtypes DataFrame @ DataFrame
+        a = a.astype(int)
+        result = operator.matmul(a, b)
+        expected = DataFrame(
+            np.dot(a.values, b.values), index=["a", "b", "c"], columns=["one", "two"]
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # unaligned
+        df = DataFrame(np.random.randn(3, 4), index=[1, 2, 3], columns=range(4))
+        df2 = DataFrame(np.random.randn(5, 3), index=range(5), columns=[1, 2, 3])
+
+        with pytest.raises(ValueError, match="aligned"):
+            operator.matmul(df, df2)
+
+    def test_matmul_message_shapes(self):
+        # GH#21581 exception message should reflect original shapes,
+        #  not transposed shapes
+        a = np.random.rand(10, 4)
+        b = np.random.rand(5, 3)
+
+        df = DataFrame(b)
+
+        msg = r"shapes \(10, 4\) and \(5, 3\) not aligned"
+        with pytest.raises(ValueError, match=msg):
+            a @ df
+        with pytest.raises(ValueError, match=msg):
+            a.tolist() @ df

pandas/tests/frame/test_analytics.py

@@ -1,6 +1,5 @@
 from datetime import timedelta
 from decimal import Decimal
-import operator
 
 import numpy as np
 import pytest
@@ -1115,82 +1114,6 @@ def test_any_all_level_axis_none_raises(self, method):
         with pytest.raises(ValueError, match=xpr):
             getattr(df, method)(axis=None, level="out")
 
-    # ---------------------------------------------------------------------
-    # Matrix-like
-
-    def test_matmul(self):
-        # matmul test is for GH 10259
-        a = DataFrame(
-            np.random.randn(3, 4), index=["a", "b", "c"], columns=["p", "q", "r", "s"]
-        )
-        b = DataFrame(
-            np.random.randn(4, 2), index=["p", "q", "r", "s"], columns=["one", "two"]
-        )
-
-        # DataFrame @ DataFrame
-        result = operator.matmul(a, b)
-        expected = DataFrame(
-            np.dot(a.values, b.values), index=["a", "b", "c"], columns=["one", "two"]
-        )
-        tm.assert_frame_equal(result, expected)
-
-        # DataFrame @ Series
-        result = operator.matmul(a, b.one)
-        expected = Series(np.dot(a.values, b.one.values), index=["a", "b", "c"])
-        tm.assert_series_equal(result, expected)
-
-        # np.array @ DataFrame
-        result = operator.matmul(a.values, b)
-        assert isinstance(result, DataFrame)
-        assert result.columns.equals(b.columns)
-        assert result.index.equals(pd.Index(range(3)))
-        expected = np.dot(a.values, b.values)
-        tm.assert_almost_equal(result.values, expected)
-
-        # nested list @ DataFrame (__rmatmul__)
-        result = operator.matmul(a.values.tolist(), b)
-        expected = DataFrame(
-            np.dot(a.values, b.values), index=["a", "b", "c"], columns=["one", "two"]
-        )
-        tm.assert_almost_equal(result.values, expected.values)
-
-        # mixed dtype DataFrame @ DataFrame
-        a["q"] = a.q.round().astype(int)
-        result = operator.matmul(a, b)
-        expected = DataFrame(
-            np.dot(a.values, b.values), index=["a", "b", "c"], columns=["one", "two"]
-        )
-        tm.assert_frame_equal(result, expected)
-
-        # different dtypes DataFrame @ DataFrame
-        a = a.astype(int)
-        result = operator.matmul(a, b)
-        expected = DataFrame(
-            np.dot(a.values, b.values), index=["a", "b", "c"], columns=["one", "two"]
-        )
-        tm.assert_frame_equal(result, expected)
-
-        # unaligned
-        df = DataFrame(np.random.randn(3, 4), index=[1, 2, 3], columns=range(4))
-        df2 = DataFrame(np.random.randn(5, 3), index=range(5), columns=[1, 2, 3])
-
-        with pytest.raises(ValueError, match="aligned"):
-            operator.matmul(df, df2)
-
-    def test_matmul_message_shapes(self):
-        # GH#21581 exception message should reflect original shapes,
-        #  not transposed shapes
-        a = np.random.rand(10, 4)
-        b = np.random.rand(5, 3)
-
-        df = DataFrame(b)
-
-        msg = r"shapes \(10, 4\) and \(5, 3\) not aligned"
-        with pytest.raises(ValueError, match=msg):
-            a @ df
-        with pytest.raises(ValueError, match=msg):
-            a.tolist() @ df
-
     # ---------------------------------------------------------------------
     # Unsorted
 

pandas/tests/frame/test_period.py

@@ -31,10 +31,3 @@ def test_frame_setitem(self):
         rs = df.reset_index().set_index("index")
         assert isinstance(rs.index, PeriodIndex)
         tm.assert_index_equal(rs.index, rng)
-
-    def test_frame_index_to_string(self):
-        index = PeriodIndex(["2011-1", "2011-2", "2011-3"], freq="M")
-        frame = DataFrame(np.random.randn(3, 4), index=index)
-
-        # it works!
-        frame.to_string()

pandas/tests/frame/test_repr_info.py

@@ -8,6 +8,7 @@
 from pandas import (
     Categorical,
     DataFrame,
+    PeriodIndex,
     Series,
     date_range,
     option_context,
@@ -218,3 +219,10 @@ def test_frame_datetime64_pre1900_repr(self):
         df = DataFrame({"year": date_range("1/1/1700", periods=50, freq="A-DEC")})
         # it works!
         repr(df)
+
+    def test_frame_to_string_with_periodindex(self):
+        index = PeriodIndex(["2011-1", "2011-2", "2011-3"], freq="M")
+        frame = DataFrame(np.random.randn(3, 4), index=index)
+
+        # it works!
+        frame.to_string()

pandas/tests/series/methods/test_matmul.py

@@ -0,0 +1,75 @@
+import operator
+
+import numpy as np
+import pytest
+
+from pandas import DataFrame, Series
+import pandas._testing as tm
+
+
+class TestMatmul:
+    def test_matmul(self):
+        # matmul test is for GH#10259
+        a = Series(np.random.randn(4), index=["p", "q", "r", "s"])
+        b = DataFrame(
+            np.random.randn(3, 4), index=["1", "2", "3"], columns=["p", "q", "r", "s"]
+        ).T
+
+        # Series @ DataFrame -> Series
+        result = operator.matmul(a, b)
+        expected = Series(np.dot(a.values, b.values), index=["1", "2", "3"])
+        tm.assert_series_equal(result, expected)
+
+        # DataFrame @ Series -> Series
+        result = operator.matmul(b.T, a)
+        expected = Series(np.dot(b.T.values, a.T.values), index=["1", "2", "3"])
+        tm.assert_series_equal(result, expected)
+
+        # Series @ Series -> scalar
+        result = operator.matmul(a, a)
+        expected = np.dot(a.values, a.values)
+        tm.assert_almost_equal(result, expected)
+
+        # GH#21530
+        # vector (1D np.array) @ Series (__rmatmul__)
+        result = operator.matmul(a.values, a)
+        expected = np.dot(a.values, a.values)
+        tm.assert_almost_equal(result, expected)
+
+        # GH#21530
+        # vector (1D list) @ Series (__rmatmul__)
+        result = operator.matmul(a.values.tolist(), a)
+        expected = np.dot(a.values, a.values)
+        tm.assert_almost_equal(result, expected)
+
+        # GH#21530
+        # matrix (2D np.array) @ Series (__rmatmul__)
+        result = operator.matmul(b.T.values, a)
+        expected = np.dot(b.T.values, a.values)
+        tm.assert_almost_equal(result, expected)
+
+        # GH#21530
+        # matrix (2D nested lists) @ Series (__rmatmul__)
+        result = operator.matmul(b.T.values.tolist(), a)
+        expected = np.dot(b.T.values, a.values)
+        tm.assert_almost_equal(result, expected)
+
+        # mixed dtype DataFrame @ Series
+        a["p"] = int(a.p)
+        result = operator.matmul(b.T, a)
+        expected = Series(np.dot(b.T.values, a.T.values), index=["1", "2", "3"])
+        tm.assert_series_equal(result, expected)
+
+        # different dtypes DataFrame @ Series
+        a = a.astype(int)
+        result = operator.matmul(b.T, a)
+        expected = Series(np.dot(b.T.values, a.T.values), index=["1", "2", "3"])
+        tm.assert_series_equal(result, expected)
+
+        msg = r"Dot product shape mismatch, \(4,\) vs \(3,\)"
+        # exception raised is of type Exception
+        with pytest.raises(Exception, match=msg):
+            a.dot(a.values[:3])
+        msg = "matrices are not aligned"
+        with pytest.raises(ValueError, match=msg):
+            a.dot(b.T)

pandas/tests/series/methods/test_repeat.py

@@ -0,0 +1,30 @@
+import numpy as np
+import pytest
+
+from pandas import Series
+import pandas._testing as tm
+
+
+class TestRepeat:
+    def test_repeat(self):
+        ser = Series(np.random.randn(3), index=["a", "b", "c"])
+
+        reps = ser.repeat(5)
+        exp = Series(ser.values.repeat(5), index=ser.index.values.repeat(5))
+        tm.assert_series_equal(reps, exp)
+
+        to_rep = [2, 3, 4]
+        reps = ser.repeat(to_rep)
+        exp = Series(ser.values.repeat(to_rep), index=ser.index.values.repeat(to_rep))
+        tm.assert_series_equal(reps, exp)
+
+    def test_numpy_repeat(self):
+        ser = Series(np.arange(3), name="x")
+        expected = Series(
+            ser.values.repeat(2), name="x", index=ser.index.values.repeat(2)
+        )
+        tm.assert_series_equal(np.repeat(ser, 2), expected)
+
+        msg = "the 'axis' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            np.repeat(ser, 2, axis=0)