implement int64 rounding function round_nsint64

The old `round_ns` is replaced by `round_nsint64`;
`round_nsint64` is based on integer arithmetic
while `round_ns` was based on floating point numbers.

Rounding mode is explicitly defined by RoundTo enum class:

- RoundTo.MINUS_INFTY rounds to -∞ (floor)
- RountTo.PLUS_INFTY rounds to +∞ (ceil)
- RoundTo.NEAREST_HALF_MINUS_INFTY rounds to nearest multiple,
  and breaks tie to -∞
- RoundTo.NEAREST_HALF_PLUS_INFTY rounds to nearest multiple,
  and breaks tie to +∞
- RoundTo.NEAREST_HALF_EVEN rounds to nearest multiple,
  and breaks tie to even multiple

Author: miccoli

pandas/_libs/tslibs/timestamps.pyx

@@ -22,6 +22,7 @@ cimport ccalendar
 from conversion import tz_localize_to_utc, normalize_i8_timestamps
 from conversion cimport (tz_convert_single, _TSObject,
                          convert_to_tsobject, convert_datetime_to_tsobject)
+import enum
 from fields import get_start_end_field, get_date_name_field
 from nattype import NaT
 from nattype cimport NPY_NAT
@@ -57,50 +58,56 @@ cdef inline object create_timestamp_from_ts(int64_t value,
     return ts_base
 
 
-def round_ns(values, rounder, freq):
+@enum.unique
+class RoundTo(enum.Enum):
+    MINUS_INFTY = 0
+    PLUS_INFTY = 1
+    NEAREST_HALF_EVEN = 2
+    NEAREST_HALF_PLUS_INFTY = 3
+    NEAREST_HALF_MINUS_INFTY = 4
+
+
+def round_nsint64(values, mode: RoundTo, freq):
     """
-    Applies rounding function at given frequency
+    Applies rounding mode at given frequency
 
     Parameters
     ----------
     values : :obj:`ndarray`
-    rounder : function, eg. 'ceil', 'floor', 'round'
+    mode : instance of `RoundTo` enumeration
     freq : str, obj
 
     Returns
     -------
     :obj:`ndarray`
     """
+
+    if not isinstance(mode, RoundTo):
+        raise ValueError('mode should be a RoundTo member')
+
     unit = to_offset(freq).nanos
 
-    # GH21262 If the Timestamp is multiple of the freq str
-    # don't apply any rounding
-    mask = values % unit == 0
-    if mask.all():
-        return values
-    r = values.copy()
-
-    if unit < 1000:
-        # for nano rounding, work with the last 6 digits separately
-        # due to float precision
-        buff = 1000000
-        r[~mask] = (buff * (values[~mask] // buff) +
-                    unit * (rounder((values[~mask] % buff) *
-                            (1 / float(unit)))).astype('i8'))
-    else:
-        if unit % 1000 != 0:
-            msg = 'Precision will be lost using frequency: {}'
-            warnings.warn(msg.format(freq))
-        # GH19206
-        # to deal with round-off when unit is large
-        if unit >= 1e9:
-            divisor = 10 ** int(np.log10(unit / 1e7))
-        else:
-            divisor = 10
-        r[~mask] = (unit * rounder((values[~mask] *
-                    (divisor / float(unit))) / divisor)
-                    .astype('i8'))
-    return r
+    if mode is RoundTo.MINUS_INFTY:
+        return values - (values % unit)
+    elif mode is RoundTo.PLUS_INFTY:
+        return values + (-values % unit)
+    elif mode is RoundTo.NEAREST_HALF_MINUS_INFTY:
+        return round_nsint64(values - unit//2, RoundTo.PLUS_INFTY, freq)
+    elif mode is RoundTo.NEAREST_HALF_PLUS_INFTY:
+        return round_nsint64(values + unit//2, RoundTo.MINUS_INFTY, freq)
+    elif mode is RoundTo.NEAREST_HALF_EVEN:
+        # for odd unit there is n need of a tie break
+        if unit % 2:
+            return round_nsint64(values, RoundTo.NEAREST_HALF_MINUS_INFTY, freq)
+        d, r = np.divmod(values, unit)
+        mask = np.logical_or(
+            r > (unit // 2),
+            np.logical_and(r == (unit // 2), d % 2)
+        )
+        d[mask] += 1
+        return d * unit
+
+    raise NotImplementedError(mode)
 
 
 # This is PITA. Because we inherit from datetime, which has very specific
@@ -656,7 +663,7 @@ class Timestamp(_Timestamp):
 
         return create_timestamp_from_ts(ts.value, ts.dts, ts.tzinfo, freq)
 
-    def _round(self, freq, rounder):
+    def _round(self, freq, mode):
         if self.tz is not None:
             value = self.tz_localize(None).value
         else:
@@ -665,7 +672,7 @@ class Timestamp(_Timestamp):
         value = np.array([value], dtype=np.int64)
 
         # Will only ever contain 1 element for timestamp
-        r = round_ns(value, rounder, freq)[0]
+        r = round_nsint64(value, mode, freq)[0]
         result = Timestamp(r, unit='ns')
         if self.tz is not None:
             result = result.tz_localize(self.tz)
@@ -687,7 +694,7 @@ class Timestamp(_Timestamp):
         ------
         ValueError if the freq cannot be converted
         """
-        return self._round(freq, np.round)
+        return self._round(freq, RoundTo.NEAREST_HALF_EVEN)
 
     def floor(self, freq):
         """
@@ -697,7 +704,7 @@ class Timestamp(_Timestamp):
         ----------
         freq : a freq string indicating the flooring resolution
         """
-        return self._round(freq, np.floor)
+        return self._round(freq, RoundTo.MINUS_INFTY)
 
     def ceil(self, freq):
         """
@@ -707,7 +714,7 @@ class Timestamp(_Timestamp):
         ----------
         freq : a freq string indicating the ceiling resolution
         """
-        return self._round(freq, np.ceil)
+        return self._round(freq, RoundTo.PLUS_INFTY)
 
     @property
     def tz(self):

pandas/core/indexes/datetimelike.py

@@ -11,7 +11,7 @@
 import numpy as np
 
 from pandas._libs import lib, iNaT, NaT
-from pandas._libs.tslibs.timestamps import round_ns
+from pandas._libs.tslibs.timestamps import round_nsint64, RoundTo
 
 from pandas.core.dtypes.common import (
     ensure_int64,
@@ -168,10 +168,10 @@ class TimelikeOps(object):
         """
     )
 
-    def _round(self, freq, rounder):
+    def _round(self, freq, mode):
         # round the local times
         values = _ensure_datetimelike_to_i8(self)
-        result = round_ns(values, rounder, freq)
+        result = round_nsint64(values, mode, freq)
         result = self._maybe_mask_results(result, fill_value=NaT)
 
         attribs = self._get_attributes_dict()
@@ -184,15 +184,15 @@ def _round(self, freq, rounder):
 
     @Appender((_round_doc + _round_example).format(op="round"))
     def round(self, freq, *args, **kwargs):
-        return self._round(freq, np.round)
+        return self._round(freq, RoundTo.NEAREST_HALF_EVEN)
 
     @Appender((_round_doc + _floor_example).format(op="floor"))
     def floor(self, freq):
-        return self._round(freq, np.floor)
+        return self._round(freq, RoundTo.MINUS_INFTY)
 
     @Appender((_round_doc + _ceil_example).format(op="ceil"))
     def ceil(self, freq):
-        return self._round(freq, np.ceil)
+        return self._round(freq, RoundTo.PLUS_INFTY)
 
 
 class DatetimeIndexOpsMixin(DatetimeLikeArrayMixin):