getting rid of complex_group/float_group

realead · realead · commit 1e62a59f83b5 · 2020-11-30T10:26:03.000+01:00
diff --git a/pandas/_libs/hashtable.pyx b/pandas/_libs/hashtable.pyx
@@ -15,8 +15,10 @@ cnp.import_array()
 from pandas._libs cimport util
 from pandas._libs.khash cimport (
     KHASH_TRACE_DOMAIN,
-    are_equal_khcomplex64_t,
-    are_equal_khcomplex128_t,
+    are_equivalent_float32_t,
+    are_equivalent_float64_t,
+    are_equivalent_khcomplex64_t,
+    are_equivalent_khcomplex128_t,
     kh_str_t,
     khcomplex64_t,
     khcomplex128_t,
diff --git a/pandas/_libs/hashtable_class_helper.pxi.in b/pandas/_libs/hashtable_class_helper.pxi.in
@@ -30,6 +30,44 @@ cdef bint is_nan_kh{{name}}_t(kh{{name}}_t val) nogil:
 {{endfor}}
 
 
+{{py:
+
+# name
+float_types = ['float64_t',
+               'float32_t']
+}}
+
+{{for c_type in float_types}}
+
+cdef bint is_nan_{{c_type}}({{c_type}} val) nogil:
+    return val != val
+{{endfor}}
+
+
+{{py:
+
+
+# name
+int_types = ['int64_t',
+             'int32_t',
+             'int16_t',
+             'int8_t',
+             'uint64_t',
+             'uint32_t',
+             'uint16_t',
+             'uint8_t',]
+}}
+
+{{for c_type in int_types}}
+
+cdef bint is_nan_{{c_type}}({{c_type}} val) nogil:
+    return False
+
+cdef bint are_equivalent_{{c_type}}({{c_type}} val1, {{c_type}} val2) nogil:
+    return val1 == val2
+{{endfor}}
+
+
 {{py:
 
 # name
@@ -336,24 +374,24 @@ cdef class HashTable:
 
 {{py:
 
-# name, dtype, c_type, float_group, complex_group, to_c_type
-dtypes = [('Complex128', 'complex128', 'khcomplex128_t', True, True, "to_khcomplex128_t"),
-          ('Float64', 'float64', 'float64_t', True, False, ""),
-          ('UInt64', 'uint64', 'uint64_t', False, False, ""),
-          ('Int64', 'int64', 'int64_t', False, False, ""),
-          ('Complex64', 'complex64', 'khcomplex64_t', True, True, "to_khcomplex64_t"),
-          ('Float32', 'float32', 'float32_t', True, False, ""),
-          ('UInt32', 'uint32', 'uint32_t', False, False, ""),
-          ('Int32', 'int32', 'int32_t', False, False, ""),
-          ('UInt16', 'uint16', 'uint16_t', False, False, ""),
-          ('Int16', 'int16', 'int16_t', False, False, ""),
-          ('UInt8', 'uint8', 'uint8_t', False, False, ""),
-          ('Int8', 'int8', 'int8_t', False, False, "")]
+# name, dtype, c_type, to_c_type
+dtypes = [('Complex128', 'complex128', 'khcomplex128_t', "to_khcomplex128_t"),
+          ('Float64', 'float64', 'float64_t', ""),
+          ('UInt64', 'uint64', 'uint64_t', ""),
+          ('Int64', 'int64', 'int64_t', ""),
+          ('Complex64', 'complex64', 'khcomplex64_t', "to_khcomplex64_t"),
+          ('Float32', 'float32', 'float32_t', ""),
+          ('UInt32', 'uint32', 'uint32_t', ""),
+          ('Int32', 'int32', 'int32_t', ""),
+          ('UInt16', 'uint16', 'uint16_t', ""),
+          ('Int16', 'int16', 'int16_t', ""),
+          ('UInt8', 'uint8', 'uint8_t', ""),
+          ('Int8', 'int8', 'int8_t', "")]
 
 }}
 
 
-{{for name, dtype, c_type, float_group, complex_group, to_c_type in dtypes}}
+{{for name, dtype, c_type, to_c_type in dtypes}}
 
 cdef class {{name}}HashTable(HashTable):
 
@@ -539,14 +577,8 @@ cdef class {{name}}HashTable(HashTable):
                         labels[i] = na_sentinel
                         continue
                 elif ignore_na and (
-                {{if complex_group}}
-                not is_nan_{{c_type}}(val) or 
-                (use_na_value and are_equal_{{c_type}}(val,na_value2))
-                {{elif float_group}}
-                val != val or (use_na_value and val == na_value2)
-                {{else}}
-                (use_na_value and val == na_value2)
-                {{endif}}             
+                    is_nan_{{c_type}}(val) or 
+                    (use_na_value and are_equivalent_{{c_type}}(val,na_value2))               
                 ):
                     # if missing values do not count as unique values (i.e. if
                     # ignore_na is True), skip the hashtable entry for them,
diff --git a/pandas/_libs/hashtable_func_helper.pxi.in b/pandas/_libs/hashtable_func_helper.pxi.in
@@ -6,24 +6,24 @@ WARNING: DO NOT edit .pxi FILE directly, .pxi is generated from .pxi.in
 
 {{py:
 
-# dtype, ttype, c_type, complex_group, to_c_type
-dtypes = [('complex128', 'complex128', 'khcomplex128_t', True, "to_khcomplex128_t"),
-          ('complex64', 'complex64', 'khcomplex64_t', True, "to_khcomplex64_t"),
-          ('float64', 'float64', 'float64_t', False, ""),
-          ('float32', 'float32', 'float32_t', False, ""),
-          ('uint64', 'uint64', 'uint64_t', False, ""),
-          ('uint32', 'uint32', 'uint32_t', False, ""),
-          ('uint16', 'uint16', 'uint16_t', False, ""),
-          ('uint8', 'uint8', 'uint8_t', False, ""),
-          ('object', 'pymap', 'object', False, ""),
-          ('int64', 'int64', 'int64_t', False, ""),
-          ('int32', 'int32', 'int32_t', False, ""),
-          ('int16', 'int16', 'int16_t', False, ""),
-          ('int8', 'int8', 'int8_t', False, "")]
+# dtype, ttype, c_type, to_c_type, to_dtype
+dtypes = [('complex128', 'complex128', 'khcomplex128_t', "to_khcomplex128_t", "to_complex128"),
+          ('complex64', 'complex64', 'khcomplex64_t', "to_khcomplex64_t", "to_complex64"),
+          ('float64', 'float64', 'float64_t', "", ""),
+          ('float32', 'float32', 'float32_t', "", ""),
+          ('uint64', 'uint64', 'uint64_t', "", ""),
+          ('uint32', 'uint32', 'uint32_t', "", ""),
+          ('uint16', 'uint16', 'uint16_t', "", ""),
+          ('uint8', 'uint8', 'uint8_t', "", ""),
+          ('object', 'pymap', 'object', "", ""),
+          ('int64', 'int64', 'int64_t', "", ""),
+          ('int32', 'int32', 'int32_t', "", ""),
+          ('int16', 'int16', 'int16_t', "", ""),
+          ('int8', 'int8', 'int8_t', "", "")]
 
 }}
 
-{{for dtype, ttype, c_type, complex_group, to_c_type in dtypes}}
+{{for dtype, ttype, c_type, to_c_type, to_dtype in dtypes}}
 
 
 @cython.wraparound(False)
@@ -62,13 +62,7 @@ cdef build_count_table_{{dtype}}(const {{dtype}}_t[:] values,
         for i in range(n):
             val = {{to_c_type}}(values[i])
 
-            {{if dtype == 'float64' or dtype == 'float32'}}
-            if val == val or not dropna:
-            {{elif complex_group}}
             if not is_nan_{{c_type}}(val) or not dropna:
-            {{else}}
-            if True:
-            {{endif}}
                 k = kh_get_{{ttype}}(table, val)
                 if k != table.n_buckets:
                     table.vals[k] += 1
@@ -117,11 +111,7 @@ cpdef value_count_{{dtype}}(const {{dtype}}_t[:] values, bint dropna):
     with nogil:
         for k in range(table.n_buckets):
             if kh_exist_{{ttype}}(table, k):
-                {{if complex_group}}
-                result_keys[i] = to_{{dtype}}(table.keys[k])
-                {{else}}
-                result_keys[i] = table.keys[k]
-                {{endif}}         
+                result_keys[i] = {{to_dtype}}(table.keys[k])     
                 result_counts[i] = table.vals[k]
                 i += 1
     {{endif}}
diff --git a/pandas/_libs/khash.pxd b/pandas/_libs/khash.pxd
@@ -25,13 +25,16 @@ cdef extern from "khash_python.h":
         double real
         double imag
 
-    bint are_equal_khcomplex128_t "kh_complex_hash_equal" (khcomplex128_t a, khcomplex128_t b) nogil
+    bint are_equivalent_khcomplex128_t "kh_complex_hash_equal" (khcomplex128_t a, khcomplex128_t b) nogil
 
     ctypedef struct khcomplex64_t:
         float real
         float imag
 
-    bint are_equal_khcomplex64_t "kh_complex_hash_equal" (khcomplex64_t a, khcomplex64_t b) nogil
+    bint are_equivalent_khcomplex64_t "kh_complex_hash_equal" (khcomplex64_t a, khcomplex64_t b) nogil
+
+    bint are_equivalent_float64_t "kh_floats_hash_equal" (float64_t a, float64_t b) nogil
+    bint are_equivalent_float32_t "kh_floats_hash_equal" (float32_t a, float32_t b) nogil
 
     ctypedef struct kh_pymap_t:
         khint_t n_buckets, size, n_occupied, upper_bound
