Make common impl. with Index.searchsorted

doc/source/whatsnew/v0.24.0.txt

@@ -496,6 +496,7 @@ Performance Improvements
   both when indexing by label (using .loc) and position(.iloc).
   Likewise, slicing a ``CategoricalIndex`` itself (i.e. ``ci[100:200]``) shows similar speed improvements (:issue:`21659`)
 - Improved performance of :func:`Series.searchsorted` (:issue:`22034`)
+- Improved performance of :func:`Index.searchsorted` when dtype is uint64, float64 or object (:issue:`22034`)
 - Improved performance of :func:`Series.describe` in case of numeric dtypes (:issue:`21274`)
 - Improved performance of :func:`pandas.core.groupby.GroupBy.rank` when dealing with tied rankings (:issue:`21237`)
 - Improved performance of :func:`DataFrame.set_index` with columns consisting of :class:`Period` objects (:issue:`21582`,:issue:`21606`)

pandas/core/base.py

@@ -15,7 +15,8 @@
     is_list_like,
     is_scalar,
     is_extension_type,
-    is_extension_array_dtype)
+    is_extension_array_dtype,
+    ensure_platform_int)
 
 from pandas.util._validators import validate_bool_kwarg
 from pandas.errors import AbstractMethodError
@@ -1230,7 +1231,9 @@ def factorize(self, sort=False, na_sentinel=-1):
     @Appender(_shared_docs['searchsorted'])
     @deprecate_kwarg(old_arg_name='key', new_arg_name='value')
     def searchsorted(self, value, side='left', sorter=None):
-        # needs coercion on the key (DatetimeIndex does already)
+        if sorter is not None:
+            sorter = ensure_platform_int(sorter)
+        value = com.maybe_convert_numeric_dtype(value, dtype=self.dtype)
         return self.values.searchsorted(value, side=side, sorter=sorter)
 
     def drop_duplicates(self, keep='first', inplace=False):

pandas/core/common.py

@@ -15,7 +15,9 @@
 from pandas import compat
 from pandas.compat import iteritems, PY36, OrderedDict
 from pandas.core.dtypes.generic import ABCSeries, ABCIndex, ABCIndexClass
-from pandas.core.dtypes.common import is_integer
+from pandas.core.dtypes.common import (is_integer, is_integer_dtype, is_float,
+                                       is_float_dtype, is_object_dtype,
+                                       is_scalar)
 from pandas.core.dtypes.inference import _iterable_not_string
 from pandas.core.dtypes.missing import isna, isnull, notnull  # noqa
 from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
@@ -430,3 +432,47 @@ def _pipe(obj, func, *args, **kwargs):
         return func(*args, **kwargs)
     else:
         return func(obj, *args, **kwargs)
+
+
+def maybe_convert_numeric_dtype(value, dtype):
+    """
+    Convert value to have dtype 'dtype' if 'dtype' is int or float.
+
+    :func:`numpy.searchsorted` is only fast if value is of same dtype
+    as the searched array. Below we ensure that value has the right
+    dtype for giving fast results for arr.searchsorted.
+
+    Notes
+    -----
+    We do not recast the value if it is a float and the array is dtype int.
+    This is because loc of float 2.1 should be behind loc of int 2,
+    *not* before it.
+
+    Parameters
+    ----------
+    value : scalar or list-like
+    dtype : a dtype
+
+    Returns
+    -------
+    return_value : value as array with appropriate dtype for fast calling
+        of numpy.searchsorted
+    """
+    if is_float_dtype(dtype):
+        value = np.asarray(value, dtype=dtype)
+    elif is_integer_dtype(dtype):
+        # check bounds
+        iinfo = np.iinfo(dtype)
+        iinfo_val = np.array([value]) if is_scalar(value) else value
+        if (iinfo_val < iinfo.min).any() or (iinfo_val > iinfo.max).any():
+            msg = "Value {} out of bound for dtype {}".format(value, dtype)
+            raise ValueError(msg)
+
+        # convert value
+        if is_integer(value) or is_integer_dtype(value):
+            value = np.asarray(value, dtype=dtype)
+        elif hasattr(value, 'is_integer') and value.is_integer():
+            # float 2.0 can be converted to int 2
+            # but float 2.2 should *not* be converted to int 2.0
+            value = np.asarray(value, dtype=dtype)
+    return value

pandas/core/series.py

@@ -19,6 +19,7 @@
     is_categorical_dtype,
     is_bool,
     is_integer, is_integer_dtype,
+    is_numeric_dtype,
     is_float_dtype,
     is_extension_type,
     is_extension_array_dtype,
@@ -264,7 +265,7 @@ def __init__(self, data=None, index=None, dtype=None, name=None,
                         raise ValueError(
                             'Length of passed values is {val}, '
                             'index implies {ind}'
-                            .format(val=len(data), ind=len(index)))
+                                .format(val=len(data), ind=len(index)))
                 except TypeError:
                     pass
 
@@ -667,9 +668,9 @@ def __array_prepare__(self, result, context=None):
             obj = context[1][0]
             raise TypeError("{obj} with dtype {dtype} cannot perform "
                             "the numpy op {op}".format(
-                                obj=type(obj).__name__,
-                                dtype=getattr(obj, 'dtype', None),
-                                op=context[0].__name__))
+                obj=type(obj).__name__,
+                dtype=getattr(obj, 'dtype', None),
+                op=context[0].__name__))
         return result
 
     # complex
@@ -2082,14 +2083,19 @@ def __rmatmul__(self, other):
     def searchsorted(self, value, side='left', sorter=None):
         if sorter is not None:
             sorter = ensure_platform_int(sorter)
-        if not is_extension_type(self._values):
-            # numpy searchsorted is only fast if value is of same dtype as the
-            # searched array. Below we ensure that value has the right dtype,
-            # and is not 0-dimensional.
-            value = np.asarray(value, dtype=self._values.dtype)
-            value = value[..., np.newaxis] if value.ndim == 0 else value
-
-        return self._values.searchsorted(value, side=side, sorter=sorter)
+
+        if is_numeric_dtype(self):
+            value = com.maybe_convert_numeric_dtype(value, dtype=self.dtype)
+        elif not (is_object_dtype(self) or is_categorical_dtype(self)):
+            value = Series(value)._values
+
+        result = self._values.searchsorted(value, side=side, sorter=sorter)
+
+        if is_scalar(result):
+            # ensure that a 1-dim array is returned
+            result = np.array([result])
+
+        return result
 
     # -------------------------------------------------------------------
     # Combination