BUG: TimedeltaIndex.intersection

Fixes #17391

Author: kirkhansen

pandas/core/indexes/base.py

@@ -1206,6 +1206,12 @@ def is_monotonic(self):
         """ alias for is_monotonic_increasing (deprecated) """
         return self.is_monotonic_increasing
 
+    @property
+    def is_strictly_monotonic(self):
+        """ Checks if the index is sorted """
+        return (self._is_strictly_monotonic_increasing or
+                self._is_strictly_monotonic_decreasing)
+
     @property
     def is_monotonic_increasing(self):
         """

pandas/core/indexes/datetimelike.py

@@ -854,6 +854,108 @@ def _concat_same_dtype(self, to_concat, name):
             new_data = np.concatenate([c.asi8 for c in to_concat])
         return self._simple_new(new_data, **attribs)
 
+    def _slice_by_value(self, start, end):
+        sliced = self.values[slice(*self.slice_locs(start, end))]
+        return self._shallow_copy(sliced)
+
+    def _intersect_ascending(self, other, **empty_params):
+        # to make our life easier, "sort" the two ranges
+        if self[0] <= other[0]:
+            left, right = self, other
+        else:
+            left, right = other, self
+
+        end = min(left[-1], right[-1])
+        start = right[0]
+
+        if end < start:
+            return type(self)(data=[], **empty_params)
+        return left._slice_by_value(start, end)
+
+    def _intersect_descending(self, other, **empty_params):
+        # this is essentially a flip of _intersect_ascending
+        if self[0] >= other[0]:
+            left, right = self, other
+        else:
+            left, right = other, self
+
+        start = min(left[0], right[0])
+        end = left[-1]
+
+        if end > start:
+            return type(self)(data=[], **empty_params)
+        return left._slice_by_value(start, end)
+
+    def _offsets_equal(self, other):
+        offsets_equal = True
+        self_offset = getattr(self, 'offset', None)
+        other_offset = getattr(other, 'offset', None)
+        if self_offset is None or other_offset is None or \
+                self_offset != other_offset or other_offset.isAnchored():
+            offsets_equal = False
+        return offsets_equal
+
+    def intersection(self, other):
+        """
+        Specialized intersection for DateTimeIndexOpsMixin objects.
+        May be much faster than Index.intersection.
+
+        Parameters
+        ----------
+        other : Index or array-like
+
+        Returns
+        -------
+        Index
+            A shallow copied intersection between the two things passed in
+        """
+        self._assert_can_do_setop(other)
+
+        if self.equals(other):
+            return self._get_consensus_name(other)
+
+        if not isinstance(other, DatetimeIndexOpsMixin):
+            try:
+                other = DatetimeIndexOpsMixin(other)
+            except (TypeError, ValueError):
+                pass
+            result = Index.intersection(self, other)
+            return result
+        elif (self._offsets_equal(other) or
+              (not self.is_strictly_monotonic or
+                not other.is_strictly_monotonic)):
+            result = Index.intersection(self, other)
+            tz = getattr(self, 'tz', None)
+            result = self._shallow_copy(result._values, name=result.name,
+                                        tz=tz, freq=None)
+            if result.freq is None:
+                result.offset = frequencies.to_offset(result.inferred_freq)
+            return result
+
+        if len(self) == 0:
+            return self
+        if len(other) == 0:
+            return other
+
+        # coerce into same order
+        self_ascending = self.is_monotonic_increasing
+        if self_ascending != other.is_monotonic_increasing:
+            other = other.sort_values(ascending=self_ascending)
+
+        # Thanks, PeriodIndex
+        empty_params = {'freq': getattr(self, 'freq', None)}
+
+        if self_ascending:
+            intersected = self._intersect_ascending(other, **empty_params)
+        else:
+            intersected = self._intersect_descending(other, **empty_params)
+
+        name = self.name
+        if self.name != other.name:
+            name = None
+        intersected.name = name
+        return intersected
+
 
 def _ensure_datetimelike_to_i8(other):
     """ helper for coercing an input scalar or array to i8 """

pandas/core/indexes/datetimes.py

@@ -1189,62 +1189,6 @@ def _wrap_union_result(self, other, result):
             raise ValueError('Passed item and index have different timezone')
         return self._simple_new(result, name=name, freq=None, tz=self.tz)
 
-    def intersection(self, other):
-        """
-        Specialized intersection for DatetimeIndex objects. May be much faster
-        than Index.intersection
-
-        Parameters
-        ----------
-        other : DatetimeIndex or array-like
-
-        Returns
-        -------
-        y : Index or DatetimeIndex
-        """
-        self._assert_can_do_setop(other)
-        if not isinstance(other, DatetimeIndex):
-            try:
-                other = DatetimeIndex(other)
-            except (TypeError, ValueError):
-                pass
-            result = Index.intersection(self, other)
-            if isinstance(result, DatetimeIndex):
-                if result.freq is None:
-                    result.offset = to_offset(result.inferred_freq)
-            return result
-
-        elif (other.offset is None or self.offset is None or
-              other.offset != self.offset or
-              not other.offset.isAnchored() or
-              (not self.is_monotonic or not other.is_monotonic)):
-            result = Index.intersection(self, other)
-            result = self._shallow_copy(result._values, name=result.name,
-                                        tz=result.tz, freq=None)
-            if result.freq is None:
-                result.offset = to_offset(result.inferred_freq)
-            return result
-
-        if len(self) == 0:
-            return self
-        if len(other) == 0:
-            return other
-        # to make our life easier, "sort" the two ranges
-        if self[0] <= other[0]:
-            left, right = self, other
-        else:
-            left, right = other, self
-
-        end = min(left[-1], right[-1])
-        start = right[0]
-
-        if end < start:
-            return type(self)(data=[])
-        else:
-            lslice = slice(*left.slice_locs(start, end))
-            left_chunk = left.values[lslice]
-            return self._shallow_copy(left_chunk)
-
     def _parsed_string_to_bounds(self, reso, parsed):
         """
         Calculate datetime bounds for parsed time string and its resolution.

pandas/core/indexes/period.py

@@ -843,7 +843,7 @@ def _maybe_cast_slice_bound(self, label, side, kind):
         Value of `side` parameter should be validated in caller.
 
         """
-        assert kind in ['ix', 'loc', 'getitem']
+        assert kind in ['ix', 'loc', 'getitem', None]
 
         if isinstance(label, datetime):
             return Period(label, freq=self.freq)

pandas/core/indexes/timedeltas.py

@@ -596,48 +596,6 @@ def _wrap_union_result(self, other, result):
         name = self.name if self.name == other.name else None
         return self._simple_new(result, name=name, freq=None)
 
-    def intersection(self, other):
-        """
-        Specialized intersection for TimedeltaIndex objects. May be much faster
-        than Index.intersection
-
-        Parameters
-        ----------
-        other : TimedeltaIndex or array-like
-
-        Returns
-        -------
-        y : Index or TimedeltaIndex
-        """
-        self._assert_can_do_setop(other)
-        if not isinstance(other, TimedeltaIndex):
-            try:
-                other = TimedeltaIndex(other)
-            except (TypeError, ValueError):
-                pass
-            result = Index.intersection(self, other)
-            return result
-
-        if len(self) == 0:
-            return self
-        if len(other) == 0:
-            return other
-        # to make our life easier, "sort" the two ranges
-        if self[0] <= other[0]:
-            left, right = self, other
-        else:
-            left, right = other, self
-
-        end = min(left[-1], right[-1])
-        start = right[0]
-
-        if end < start:
-            return type(self)(data=[])
-        else:
-            lslice = slice(*left.slice_locs(start, end))
-            left_chunk = left.values[lslice]
-            return self._shallow_copy(left_chunk)
-
     def _maybe_promote(self, other):
         if other.inferred_type == 'timedelta':
             other = TimedeltaIndex(other)

pandas/tests/indexes/timedeltas/test_setops.py

@@ -74,3 +74,74 @@ def test_intersection_bug_1708(self):
         result = index_1 & index_2
         expected = timedelta_range('1 day 01:00:00', periods=3, freq='h')
         tm.assert_index_equal(result, expected)
+
+
+def test_intersection_intersects_ascending():
+    idx1 = pd.to_timedelta(range(2, 6), unit='s')
+    idx2 = pd.to_timedelta(range(3), unit='s')
+    result = idx1.intersection(idx2)
+    assert result.equals(TimedeltaIndex(['00:00:02']))
+
+    # test that it works both ways
+    idx1 = pd.to_timedelta(range(3), unit='s')
+    idx2 = pd.to_timedelta(range(2, 6), unit='s')
+    result = idx1.intersection(idx2)
+    assert result.equals(TimedeltaIndex(['00:00:02']))
+
+
+def test_intersection_intersects_descending():
+    # GH 17391
+    idx1 = pd.to_timedelta(range(6, 3, -1), unit='s')
+    idx2 = pd.to_timedelta(range(5, 1, -1), unit='s')
+    result = idx1.intersection(idx2)
+    expected = TimedeltaIndex(['00:00:05', '00:00:04'],
+                              dtype='timedelta64[ns]')
+    assert result.equals(expected)
+
+    # test it works both ways
+    idx1 = pd.to_timedelta(range(5, 1, -1), unit='s')
+    idx2 = pd.to_timedelta(range(6, 3, -1), unit='s')
+    result = idx1.intersection(idx2)
+    assert result.equals(expected)
+
+
+def test_intersection_intersects_descending_no_intersect():
+    idx1 = pd.to_timedelta(range(6, 4, -1), unit='s')
+    idx2 = pd.to_timedelta(range(4, 1, -1), unit='s')
+    result = idx1.intersection(idx2)
+    assert len(result) == 0
+
+
+def test_intersection_intersects_len_1():
+    idx1 = pd.to_timedelta(range(1, 2), unit='s')
+    idx2 = pd.to_timedelta(range(1, 0, -1), unit='s')
+    intersection = idx1.intersection(idx2)
+    expected = TimedeltaIndex(['00:00:01'],
+                              dtype='timedelta64[ns]')
+    tm.assert_index_equal(intersection, expected)
+
+
+def test_intersection_can_intersect_self():
+    idx = pd.to_timedelta(range(1, 2), unit='s')
+    result = idx.intersection(idx)
+    tm.assert_index_equal(idx, result)
+
+
+def test_intersection_not_sorted():
+    idx1 = pd.to_timedelta((1, 3, 2, 5, 4), unit='s')
+    idx2 = pd.to_timedelta((1, 2, 3, 5, 4), unit='s')
+    result = idx1.intersection(idx2)
+    expected = idx1
+    tm.assert_index_equal(result, expected)
+
+
+def test_intersection_not_unique():
+    idx1 = pd.to_timedelta((1, 2, 2, 3, 3, 5), unit='s')
+    idx2 = pd.to_timedelta((1, 2, 3, 4), unit='s')
+    result = idx1.intersection(idx2)
+    expected = pd.to_timedelta((1, 2, 2, 3, 3), unit='s')
+    tm.assert_index_equal(result, expected)
+
+    result = idx2.intersection(idx1)
+    expected = pd.to_timedelta((1, 2, 2, 3, 3), unit='s')
+    tm.assert_index_equal(result, expected)