BUG: Timestamp.round precision error for ns (#15578)

Author: mroeschke

doc/source/whatsnew/v0.20.0.txt

@@ -652,7 +652,7 @@ Bug Fixes
 - Bug in ``Index`` power operations with reversed operands (:issue:`14973`)
 - Bug in ``TimedeltaIndex`` addition where overflow was being allowed without error (:issue:`14816`)
 - Bug in ``TimedeltaIndex`` raising a ``ValueError`` when boolean indexing with ``loc`` (:issue:`14946`)
-- Bug in ``DatetimeIndex.round()`` and ``Timestamp.round()`` floating point accuracy when rounding by milliseconds (:issue: `14440`)
+- Bug in ``DatetimeIndex.round()`` and ``Timestamp.round()`` floating point accuracy when rounding by milliseconds or less (:issue: `14440`, :issue:`15578`)
 - Bug in ``astype()`` where ``inf`` values were incorrectly converted to integers. Now raises error now with ``astype()`` for Series and DataFrames (:issue:`14265`)
 - Bug in ``DataFrame(..).apply(to_numeric)`` when values are of type decimal.Decimal. (:issue:`14827`)
 - Bug in ``describe()`` when passing a numpy array which does not contain the median to the ``percentiles`` keyword argument (:issue:`14908`)

pandas/tests/indexes/datetimes/test_ops.py

@@ -175,17 +175,25 @@ def test_round(self):
             tm.assertRaisesRegexp(ValueError, msg, rng.round, freq='M')
             tm.assertRaisesRegexp(ValueError, msg, elt.round, freq='M')
 
-            # GH 14440
+            # GH 14440 & 15578
             index = pd.DatetimeIndex(['2016-10-17 12:00:00.0015'], tz=tz)
             result = index.round('ms')
             expected = pd.DatetimeIndex(['2016-10-17 12:00:00.002000'], tz=tz)
             tm.assert_index_equal(result, expected)
 
+            for freq in ['us', 'ns']:
+                tm.assert_index_equal(index, index.round(freq))
+
             index = pd.DatetimeIndex(['2016-10-17 12:00:00.00149'], tz=tz)
             result = index.round('ms')
             expected = pd.DatetimeIndex(['2016-10-17 12:00:00.001000'], tz=tz)
             tm.assert_index_equal(result, expected)
 
+            index = pd.DatetimeIndex(['2016-10-17 12:00:00.001501031'])
+            result = index.round('10ns')
+            expected = pd.DatetimeIndex(['2016-10-17 12:00:00.001501030'])
+            tm.assert_index_equal(result, expected)
+
     def test_repeat_range(self):
         rng = date_range('1/1/2000', '1/1/2001')
 

pandas/tests/scalar/test_timestamp.py

@@ -732,7 +732,7 @@ def test_round(self):
         for freq in ['Y', 'M', 'foobar']:
             self.assertRaises(ValueError, lambda: dti.round(freq))
 
-        # GH 14440
+        # GH 14440 & 15578
         result = pd.Timestamp('2016-10-17 12:00:00.0015').round('ms')
         expected = pd.Timestamp('2016-10-17 12:00:00.002000')
         self.assertEqual(result, expected)
@@ -741,6 +741,14 @@ def test_round(self):
         expected = pd.Timestamp('2016-10-17 12:00:00.001000')
         self.assertEqual(result, expected)
 
+        ts = pd.Timestamp('2016-10-17 12:00:00.0015')
+        for freq in ['us', 'ns']:
+            self.assertEqual(ts, ts.round(freq))
+
+        result = pd.Timestamp('2016-10-17 12:00:00.001501031').round('10ns')
+        expected = pd.Timestamp('2016-10-17 12:00:00.001501030')
+        self.assertEqual(result, expected)
+
     def test_class_ops_pytz(self):
         tm._skip_if_no_pytz()
         from pytz import timezone

pandas/tseries/base.py

@@ -78,12 +78,19 @@ class TimelikeOps(object):
     def _round(self, freq, rounder):
 
         from pandas.tseries.frequencies import to_offset
-        unit = to_offset(freq).nanos
-
+        offset = to_offset(freq)
+        unit = offset.nanos
+        time_unit = offset.rule_code
         # round the local times
         values = _ensure_datetimelike_to_i8(self)
-
-        result = (unit * rounder(values / float(unit)).astype('i8'))
+        if time_unit == 'N':
+            # for nano rounding, work with the last 6 digits separately
+            # due to float precision
+            buff = 1000000
+            result = (buff * (values // buff) + unit *
+                      (rounder((values % buff) / float(unit))).astype('i8'))
+        else:
+            result = (unit * rounder(values / float(unit)).astype('i8'))
         result = self._maybe_mask_results(result, fill_value=tslib.NaT)
         attribs = self._get_attributes_dict()
         if 'freq' in attribs:

pandas/tslib.pyx

@@ -416,12 +416,21 @@ class Timestamp(_Timestamp):
         cdef object result, value
 
         from pandas.tseries.frequencies import to_offset
-        unit = to_offset(freq).nanos
+        offset = to_offset(freq)
+        unit = offset.nanos
+        time_unit = offset.rule_code
         if self.tz is not None:
             value = self.tz_localize(None).value
         else:
             value = self.value
-        result = (unit * rounder(value / float(unit)).astype('i8'))
+        if time_unit == 'N':
+            # for nano rounding, work with the last 6 digits separately
+            # due to float precision
+            buff = 1000000
+            result = (buff * (value // buff) + unit *
+                      (rounder((value % buff) / float(unit))).astype('i8'))
+        else:
+            result = (unit * rounder(value / float(unit)).astype('i8'))
         result = Timestamp(result, unit='ns')
         if self.tz is not None:
             result = result.tz_localize(self.tz)