add Timedelta floordiv ops

provide out-of-bounds for julian dates

Author: jreback

doc/source/whatsnew/v0.20.0.txt

@@ -59,7 +59,7 @@ fixed-width text files, and :func:`read_excel` for parsing Excel files.
 to_datetime has gained an origin parameter
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-``pd.to_datetime`` has gained a new parameter, ``origin``, to define an offset
+``pd.to_datetime`` has gained a new parameter, ``origin``, to define a reference date
 from where to compute the resulting ``DatetimeIndex``. (:issue:`11276`, :issue:`11745`)
 
 Start with 1960-01-01 as the starting date
@@ -336,7 +336,7 @@ Other Enhancements
 - ``pd.DataFrame.to_latex`` and ``pd.DataFrame.to_string`` now allow optional header aliases. (:issue:`15536`)
 - Re-enable the ``parse_dates`` keyword of ``read_excel`` to parse string columns as dates (:issue:`14326`)
 - Added ``.empty`` property to subclasses of ``Index``. (:issue:`15270`)
-
+- Enabled floor division for ``Timedelta`` and ``TimedeltaIndex`` (:issue:`15828`)
 - ``pandas.io.json.json_normalize()`` gained the option ``errors='ignore'|'raise'``; the default is ``errors='raise'`` which is backward compatible. (:issue:`14583`)
 - ``pandas.io.json.json_normalize()`` with an empty ``list`` will return an empty ``DataFrame`` (:issue:`15534`)
 - ``pandas.io.json.json_normalize()`` has gained a ``sep`` option that accepts ``str`` to separate joined fields; the default is ".", which is backward compatible. (:issue:`14883`)

pandas/_libs/tslib.pyx

@@ -3073,6 +3073,7 @@ class Timedelta(_Timedelta):
         return np.timedelta64(self.value, 'ns')
 
     def _validate_ops_compat(self, other):
+
         # return True if we are compat with operating
         if _checknull_with_nat(other):
             return True
@@ -3179,11 +3180,41 @@ class Timedelta(_Timedelta):
         __div__ = __truediv__
         __rdiv__ = __rtruediv__
 
-    def _not_implemented(self, *args, **kwargs):
-        return NotImplemented
+    def __floordiv__(self, other):
+
+        if hasattr(other, 'dtype'):
+
+            # work with i8
+            other = other.astype('m8[ns]').astype('i8')
+
+            return self.value // other
 
-    __floordiv__ = _not_implemented
-    __rfloordiv__ = _not_implemented
+        # integers only
+        if is_integer_object(other):
+            return Timedelta(self.value // other, unit='ns')
+
+        if not self._validate_ops_compat(other):
+            return NotImplemented
+
+        other = Timedelta(other)
+        if other is NaT:
+            return np.nan
+        return self.value // other.value
+
+    def __rfloordiv__(self, other):
+        if hasattr(other, 'dtype'):
+
+            # work with i8
+            other = other.astype('m8[ns]').astype('i8')
+            return other // self.value
+
+        if not self._validate_ops_compat(other):
+            return NotImplemented
+
+        other = Timedelta(other)
+        if other is NaT:
+            return NaT
+        return other.value // self.value
 
     def _op_unary_method(func, name):
 

pandas/tests/indexes/datetimes/test_tools.py

@@ -1572,29 +1572,63 @@ def test_to_basic(self, julian_dates):
                            Timestamp('1970-01-03')])
         assert_series_equal(result, expected)
 
+    def test_julian_round_trip(self):
+        result = pd.to_datetime(2456658, origin='julian', unit='D')
+        assert result.to_julian_date() == 2456658
+
+        # out-of-bounds
+        with pytest.raises(ValueError):
+            pd.to_datetime(1, origin="julian", unit='D')
+
     def test_invalid_unit(self, units, julian_dates):
 
         # checking for invalid combination of origin='julian' and unit != D
         if units != 'D':
             with pytest.raises(ValueError):
                 pd.to_datetime(julian_dates, unit=units, origin='julian')
 
+    def test_invalid_origin(self):
+
+        # need to have a numeric specified
+        with pytest.raises(ValueError):
+            pd.to_datetime("2005-01-01", origin="1960-01-01")
+
+        with pytest.raises(ValueError):
+            pd.to_datetime("2005-01-01", origin="1960-01-01", unit='D')
+
     def test_epoch(self, units, epochs, epoch_1960, units_from_epochs):
 
         expected = Series(
             [pd.Timedelta(x, unit=units) +
              epoch_1960 for x in units_from_epochs])
+
         result = Series(pd.to_datetime(
             units_from_epochs, unit=units, origin=epochs))
         assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("origin, exc",
-                             [('random_string', 'cannot be converted'),
-                              ('epoch', 'cannot be converted'),
-                              ('13-24-1990', 'cannot be converted'),
-                              ('0001-01-01', 'Out of Bounds')])
+                             [('random_string', ValueError),
+                              ('epoch', ValueError),
+                              ('13-24-1990', ValueError),
+                              ('0001-01-01', tslib.OutOfBoundsDatetime)])
     def test_invalid_origins(self, origin, exc, units, units_from_epochs):
 
-        with tm.assertRaisesRegexp(ValueError, exc):
+        with pytest.raises(exc):
             pd.to_datetime(units_from_epochs, unit=units,
                            origin=origin)
+
+    def test_processing_order(self):
+        # make sure we handle out-of-bounds *before*
+        # constructing the dates
+
+        result = pd.to_datetime(200 * 365, unit='D')
+        expected = Timestamp('2169-11-13 00:00:00')
+        assert result == expected
+
+        result = pd.to_datetime(200 * 365, unit='D', origin='1870-01-01')
+        expected = Timestamp('2069-11-13 00:00:00')
+        assert result == expected
+
+        result = pd.to_datetime(300 * 365, unit='D', origin='1870-01-01')
+        expected = Timestamp('2169-10-20 00:00:00')
+        assert result == expected

pandas/tests/indexes/timedeltas/test_ops.py

@@ -284,6 +284,12 @@ def test_ops_compat(self):
             result = rng / offset
             tm.assert_index_equal(result, expected, exact=False)
 
+        # floor divide
+        expected = Int64Index((np.arange(10) + 1) * 12, name='foo')
+        for offset in offsets:
+            result = rng // offset
+            tm.assert_index_equal(result, expected, exact=False)
+
         # divide with nats
         rng = TimedeltaIndex(['1 days', pd.NaT, '2 days'], name='foo')
         expected = Float64Index([12, np.nan, 24], name='foo')
@@ -867,20 +873,19 @@ def test_ops(self):
         self.assertEqual(td * 2, Timedelta(20, unit='d'))
         self.assertTrue((td * pd.NaT) is pd.NaT)
         self.assertEqual(td / 2, Timedelta(5, unit='d'))
+        self.assertEqual(td // 2, Timedelta(5, unit='d'))
         self.assertEqual(abs(td), td)
         self.assertEqual(abs(-td), td)
         self.assertEqual(td / td, 1)
         self.assertTrue((td / pd.NaT) is np.nan)
+        self.assertTrue((td // pd.NaT) is np.nan)
 
         # invert
         self.assertEqual(-td, Timedelta('-10d'))
         self.assertEqual(td * -1, Timedelta('-10d'))
         self.assertEqual(-1 * td, Timedelta('-10d'))
         self.assertEqual(abs(-td), Timedelta('10d'))
 
-        # invalid
-        self.assertRaises(TypeError, lambda: Timedelta(11, unit='d') // 2)
-
         # invalid multiply with another timedelta
         self.assertRaises(TypeError, lambda: td * td)
 
@@ -991,7 +996,7 @@ class Other:
         self.assertTrue(td.__sub__(other) is NotImplemented)
         self.assertTrue(td.__truediv__(other) is NotImplemented)
         self.assertTrue(td.__mul__(other) is NotImplemented)
-        self.assertTrue(td.__floordiv__(td) is NotImplemented)
+        self.assertTrue(td.__floordiv__(other) is NotImplemented)
 
     def test_ops_error_str(self):
         # GH 13624

pandas/tests/scalar/test_timedelta.py

@@ -216,6 +216,7 @@ def test_conversion(self):
 
     def test_freq_conversion(self):
 
+        # truediv
         td = Timedelta('1 days 2 hours 3 ns')
         result = td / np.timedelta64(1, 'D')
         self.assertEqual(result, td.value / float(86400 * 1e9))
@@ -224,6 +225,15 @@ def test_freq_conversion(self):
         result = td / np.timedelta64(1, 'ns')
         self.assertEqual(result, td.value)
 
+        # floordiv
+        td = Timedelta('1 days 2 hours 3 ns')
+        result = td // np.timedelta64(1, 'D')
+        self.assertEqual(result, 1)
+        result = td // np.timedelta64(1, 's')
+        self.assertEqual(result, 93600)
+        result = td // np.timedelta64(1, 'ns')
+        self.assertEqual(result, td.value)
+
     def test_fields(self):
         def check(value):
             # that we are int/long like

pandas/tseries/tdi.py

@@ -326,15 +326,15 @@ def _add_delta(self, delta):
     def _evaluate_with_timedelta_like(self, other, op, opstr):
 
         # allow division by a timedelta
-        if opstr in ['__div__', '__truediv__']:
+        if opstr in ['__div__', '__truediv__', '__floordiv__']:
             if _is_convertible_to_td(other):
                 other = Timedelta(other)
                 if isnull(other):
                     raise NotImplementedError(
                         "division by pd.NaT not implemented")
 
                 i8 = self.asi8
-                result = i8 / float(other.value)
+                result = op(i8, other.value)
                 result = self._maybe_mask_results(result, convert='float64')
                 return Index(result, name=self.name, copy=False)
 

pandas/tseries/tools.py

@@ -9,7 +9,11 @@
                                  is_datetime64_dtype,
                                  is_datetime64tz_dtype,
                                  is_integer_dtype,
-                                 is_list_like)
+                                 is_integer,
+                                 is_float,
+                                 is_list_like,
+                                 is_scalar,
+                                 is_numeric_dtype)
 from pandas.types.generic import (ABCIndexClass, ABCSeries,
                                   ABCDataFrame)
 from pandas.types.missing import notnull
@@ -238,10 +242,8 @@ def to_datetime(arg, errors='raise', dayfirst=False, yearfirst=False,
         datetime strings, and if it can be inferred, switch to a faster
         method of parsing them. In some cases this can increase the parsing
         speed by ~5-10x.
-    origin : scalar convertible to Timestamp / string ('julian', 'unix'),
-        default 'unix'.
-        Define reference date. The numeric values would be parsed as number
-        of units (defined by `unit`) since this reference date.
+    origin : scalar, default is 'unix'
+        convertible to Timestamp / string ('julian', 'unix')
 
         - If 'unix' (or POSIX) time; origin is set to 1970-01-01.
         - If 'julian', unit must be 'D', and origin is set to beginning of
@@ -312,8 +314,10 @@ def to_datetime(arg, errors='raise', dayfirst=False, yearfirst=False,
     >>> %timeit pd.to_datetime(s,infer_datetime_format=False)
     1 loop, best of 3: 471 ms per loop
 
-    Using non-epoch origins to parse date
-    >>> pd.to_datetime([1,2,3], unit='D', origin=pd.Timestamp('1960-01-01'))
+    Using a non-unix epoch origin
+
+    >>> pd.to_datetime([1, 2, 3], unit='D',
+                       origin=pd.Timestamp('1960-01-01'))
     0    1960-01-02
     1    1960-01-03
     2    1960-01-04
@@ -429,18 +433,68 @@ def _convert_listlike(arg, box, format, name=None, tz=tz):
             except (ValueError, TypeError):
                 raise e
 
-    # perform the conversion
+    if arg is None:
+        return None
+
+    # handle origin
     if origin == 'julian':
+
+        original = arg
+        j0 = tslib.Timestamp(0).to_julian_date()
         if unit != 'D':
             raise ValueError("unit must be 'D' for origin='julian'")
         try:
-            arg = arg - tslib.Timestamp(0).to_julian_date()
+            arg = arg - j0
         except:
             raise ValueError("incompatible 'arg' type for given "
                              "'origin'='julian'")
-    if arg is None:
-        result = arg
-    elif isinstance(arg, tslib.Timestamp):
+
+        # premptively check this for a nice range
+        j_max = tslib.Timestamp.max.to_julian_date() - j0
+        j_min = tslib.Timestamp.min.to_julian_date() - j0
+        if np.any(arg > j_max) or np.any(arg < j_min):
+            raise tslib.OutOfBoundsDatetime(
+                "{original} is Out of Bounds for "
+                "origin='julian'".format(original=original))
+
+    elif origin not in ['unix', 'julian']:
+
+        # arg must be a numeric
+        original = arg
+        if not ((is_scalar(arg) and (is_integer(arg) or is_float(arg))) or
+                is_numeric_dtype(np.asarray(arg))):
+            raise ValueError(
+                "'{arg}' is not compatible with origin='{origin}'; "
+                "it must be numeric with a unit specified ".format(
+                    arg=arg,
+                    origin=origin))
+
+        # we are going to offset back to unix / epoch time
+        try:
+            offset = tslib.Timestamp(origin) - tslib.Timestamp(0)
+        except tslib.OutOfBoundsDatetime:
+            raise tslib.OutOfBoundsDatetime(
+                "origin {} is Out of Bounds".format(origin))
+        except ValueError:
+            raise ValueError("origin {} cannot be converted "
+                             "to a Timestamp".format(origin))
+
+        # convert the offset to the unit of the arg
+        # this should be lossless in terms of precision
+        offset = offset // tslib.Timedelta(1, unit=unit)
+
+        arg = np.asarray(arg)
+        arg = arg + offset
+
+        # convert to the tenor of the original arg
+        if is_scalar(original):
+            arg = arg.item()
+        elif isinstance(original, ABCSeries):
+            arg = type(original)(arg, index=original.index, name=original.name)
+        elif isinstance(original, ABCIndexClass):
+            arg = type(original)(arg)
+
+    if isinstance(arg, tslib.Timestamp):
         result = arg
     elif isinstance(arg, ABCSeries):
         from pandas import Series
@@ -455,20 +509,6 @@ def _convert_listlike(arg, box, format, name=None, tz=tz):
     else:
         result = _convert_listlike(np.array([arg]), box, format)[0]
 
-    # handle origin
-    if origin not in ['unix', 'julian']:
-        try:
-            offset = tslib.Timestamp(origin) - tslib.Timestamp(0)
-        except tslib.OutOfBoundsDatetime:
-            raise ValueError(
-                "origin {} is Out of Bounds".format(origin))
-        except ValueError:
-            raise ValueError("origin {} cannot be converted "
-                             "to a Timestamp".format(origin))
-
-        if offset is not None:
-            result = result + offset
-
     return result