Fix Timestamp rounding

pandas/_libs/tslibs/timestamps.pyx

@@ -72,30 +72,50 @@ def round_ns(values, rounder, freq):
     -------
     int or :obj:`ndarray`
     """
+    def _round_non_int_multiple(value):
+        if unit < 1000:
+            # for nano rounding, work with the last 6 digits separately
+            # due to float precision
+            buff = 1000000
+            r = (buff * (value // buff) + unit *
+                 (rounder((value % 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 = (unit * rounder((value * (divisor / float(unit))) / divisor)
+                 .astype('i8'))
+
+        return r
+
+    # GH21262 If the Timestamp is multiple of the freq str
+    # then we don't apply _round_non_int_multiple
+
+    def _apply_round(value):
+        if value % unit == 0:
+            return value
+        else:
+            return _round_non_int_multiple(value)
+
     from pandas.tseries.frequencies import to_offset
     unit = to_offset(freq).nanos
-    if unit < 1000:
-        # for nano rounding, work with the last 6 digits separately
-        # due to float precision
-        buff = 1000000
-        r = (buff * (values // buff) + unit *
-             (rounder((values % 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 = (unit * rounder((values * (divisor / float(unit))) / divisor)
-             .astype('i8'))
+    if type(values) is int:
+        if values % unit == 0:
+            return values
+        else:
+            return _round_non_int_multiple(values)
 
-    return r
+    else:
+        return np.fromiter((_apply_round(item) for item in values), np.int64)
 
 
 # This is PITA. Because we inherit from datetime, which has very specific

pandas/tests/indexes/datetimes/test_scalar_compat.py

@@ -134,6 +134,21 @@ def test_round(self, tz):
             ts = '2016-10-17 12:00:00.001501031'
             DatetimeIndex([ts]).round('1010ns')
 
+    def test_no_rounding_occurs(self, tz):
+        # GH 21262
+        rng = date_range(start='2016-01-01', periods=5,
+                         freq='2Min', tz=tz)
+
+        expected_rng = DatetimeIndex([
+            Timestamp('2016-01-01 00:00:00', tz=tz, freq='2T'),
+            Timestamp('2016-01-01 00:02:00', tz=tz, freq='2T'),
+            Timestamp('2016-01-01 00:04:00', tz=tz, freq='2T'),
+            Timestamp('2016-01-01 00:06:00', tz=tz, freq='2T'),
+            Timestamp('2016-01-01 00:08:00', tz=tz, freq='2T'),
+        ])
+
+        tm.assert_index_equal(rng.round(freq='2T'), expected_rng)
+
     @pytest.mark.parametrize('test_input, rounder, freq, expected', [
         (['2117-01-01 00:00:45'], 'floor', '15s', ['2117-01-01 00:00:45']),
         (['2117-01-01 00:00:45'], 'ceil', '15s', ['2117-01-01 00:00:45']),
@@ -143,6 +158,10 @@ def test_round(self, tz):
          ['1823-01-01 00:00:01.000000020']),
         (['1823-01-01 00:00:01'], 'floor', '1s', ['1823-01-01 00:00:01']),
         (['1823-01-01 00:00:01'], 'ceil', '1s', ['1823-01-01 00:00:01']),
+        (['2018-01-01 00:15:00'], 'ceil', '15T', ['2018-01-01 00:15:00']),
+        (['2018-01-01 00:15:00'], 'floor', '15T', ['2018-01-01 00:15:00']),
+        (['1823-01-01 03:00:00'], 'ceil', '3H', ['1823-01-01 03:00:00']),
+        (['1823-01-01 03:00:00'], 'floor', '3H', ['1823-01-01 03:00:00']),
         (('NaT', '1823-01-01 00:00:01'), 'floor', '1s',
          ('NaT', '1823-01-01 00:00:01')),
         (('NaT', '1823-01-01 00:00:01'), 'ceil', '1s',

pandas/tests/scalar/timestamp/test_unary_ops.py

@@ -118,6 +118,27 @@ def test_ceil_floor_edge(self, test_input, rounder, freq, expected):
             expected = Timestamp(expected)
             assert result == expected
 
+    @pytest.mark.parametrize('test_input, freq, expected', [
+        ('2018-01-01 00:02:06', '2s', '2018-01-01 00:02:06'),
+        ('2018-01-01 00:02:00', '2T', '2018-01-01 00:02:00'),
+        ('2018-01-01 00:04:00', '4T', '2018-01-01 00:04:00'),
+        ('2018-01-01 00:15:00', '15T', '2018-01-01 00:15:00'),
+        ('2018-01-01 00:20:00', '20T', '2018-01-01 00:20:00'),
+        ('2018-01-01 03:00:00', '3H', '2018-01-01 03:00:00'),
+    ])
+    def test_round_minute_freq(self, test_input, freq, expected):
+        # Ensure timestamps that shouldnt round dont!
+        # GH#21262
+        dt = Timestamp(test_input)
+        expected = Timestamp(expected)
+
+        result_ceil = dt.ceil(freq)
+        assert result_ceil == expected
+        result_floor = dt.floor(freq)
+        assert result_floor == expected
+        result_round = dt.round(freq)
+        assert result_round == expected
+
     def test_ceil(self):
         dt = Timestamp('20130101 09:10:11')
         result = dt.ceil('D')
@@ -257,7 +278,6 @@ def test_timestamp(self):
         if PY3:
             # datetime.timestamp() converts in the local timezone
             with tm.set_timezone('UTC'):
-
                 # should agree with datetime.timestamp method
                 dt = ts.to_pydatetime()
                 assert dt.timestamp() == ts.timestamp()