complex 64 and 128 testing

Author: alimcmaster1

doc/source/whatsnew/v1.4.0.rst

@@ -92,7 +92,7 @@ Other enhancements
 - :meth:`Series.sample`, :meth:`DataFrame.sample`, and :meth:`.GroupBy.sample` now accept a ``np.random.Generator`` as input to ``random_state``. A generator will be more performant, especially with ``replace=False`` (:issue:`38100`)
 - :meth:`Series.ewm`, :meth:`DataFrame.ewm`, now support a ``method`` argument with a ``'table'`` option that performs the windowing operation over an entire :class:`DataFrame`. See :ref:`Window Overview <window.overview>` for performance and functional benefits (:issue:`42273`)
 - :meth:`.GroupBy.cummin` and :meth:`.GroupBy.cummax` now support the argument ``skipna`` (:issue:`34047`)
--
+- Methods that relied on hashmap based algos such as :meth:`DataFrameGroupBy.value_counts`, :meth:`DataFrameGroupBy.count` and :func:`factorize` ignored imaginary component for complex numbers (:issue:`17927`)
 
 .. ---------------------------------------------------------------------------
 

pandas/tests/groupby/test_groupby.py

@@ -1009,6 +1009,36 @@ def test_groupby_complex():
     tm.assert_series_equal(result, expected)
 
 
+@pytest.mark.parametrize(
+    "frame,expected",
+    [
+        (
+            DataFrame(
+                [
+                    {"a": 1, "b": 1 + 1j},
+                    {"a": 1, "b": 1 + 2j},
+                    {"a": 4, "b": 1},
+                ]
+            ),
+            DataFrame(
+                np.array([1, 1, 1], dtype=np.int64),
+                index=Index([(1 + 1j), (1 + 2j), (1 + 0j)], dtype="object", name="b"),
+                columns=Index(["a"], dtype="object"),
+            ),
+        )
+    ],
+)
+def test_groupby_complex_numbers(frame, expected):
+    result = frame.groupby("b", sort=False).count()
+    tm.assert_frame_equal(result, expected)
+
+    # Sorted by the magnitude of the complex numbers
+    # Complex Index dtype is cast to object
+    expected.index = Index([(1 + 0j), (1 + 1j), (1 + 2j)], dtype="object", name="b")
+    result = frame.groupby("b", sort=True).count()
+    tm.assert_frame_equal(result, expected)
+
+
 def test_groupby_series_indexed_differently():
     s1 = Series(
         [5.0, -9.0, 4.0, 100.0, -5.0, 55.0, 6.7],

pandas/tests/series/methods/test_value_counts.py

@@ -209,25 +209,15 @@ def test_value_counts_bool_with_nan(self, ser, dropna, exp):
         tm.assert_series_equal(out, exp)
 
     @pytest.mark.parametrize(
-        "input_array,expected,dtype",
+        "input_array,expected",
         [
             (
-                [1 + 1j, 0, 1 + 0j, 1j, 1 + 2j],
-                Series([1, 1, 1, 1, 1], index=[0, 1 + 0j, 1j, 1 + 1j, 1 + 2j]),
-                np.complex128
-            ),
-            (
-                [1 + 2j, 0, 1j, 1, 1j, 1 + 1j, 1 + 1j],
-                Series([2, 1, 1, 2, 1], index=pd.Index([1j, 0, 1, 1 + 1j, 1 + 2j], dtype=np.complex128)),
-                np.complex128
-            ),
-            (
-                [1 + 2j, 0, 1j, 1, 1j, 1 + 1j, 1 + 1j],
-                Series([2, 1, 1, 2, 1], index=pd.Index([1j, 0, 1, 1 + 1j, 1 + 2j], dtype=np.complex64)),
-                np.complex64
-            ),
+                [1 + 1j, 1 + 1j, 1, 3j, 3j, 3j],
+                Series([3, 2, 1], index=pd.Index([3j, 1 + 1j, 1])),
+            )
         ],
     )
-    def test_value_counts_complex_numbers(self, input_array, expected, dtype):
-        result = pd.Series(input_array, dtype=dtype).value_counts()
-        tm.assert_series_equal(result, expected)
+    def test_value_counts_complex_numbers(self, input_array, expected):
+        # Complex Index dtype is cast to object
+        result = Series(input_array).value_counts()
+        tm.assert_series_equal(result, expected, check_index_type=False)