Fixed some bugs with the new intersection logic

Added some additional tests for those cases.

Author: kirkhansen

pandas/core/indexes/datetimelike.py

@@ -880,7 +880,7 @@ def _intersect_descending(self, other, **empty_params):
             left, right = other, self
 
         start = min(left[0], right[0])
-        end = left[-1]
+        end = right[-1]
 
         if end > start:
             return type(self)(data=[], **empty_params)
@@ -932,11 +932,19 @@ def intersection(self, other):
                 result.offset = frequencies.to_offset(result.inferred_freq)
             return result
 
-        if len(self) == 0:
+        lenghts = len(self), len(other)
+        if lenghts[0] == 0:
             return self
-        if len(other) == 0:
+        if lenghts[1] == 0:
             return other
 
+        # handle intersecting things like this
+        # idx1 = pd.to_timedelta((1, 2, 3, 4, 5, 6, 7, 8), unit='s')
+        # idx2 = pd.to_timedelta((2, 3, 4, 8), unit='s')
+        if lenghts[0] != lenghts[1] and (
+                    max(self) != max(other) or min(self) != min(other)):
+            return Index.intersection(self, other)
+
         # coerce into same order
         self_ascending = self.is_monotonic_increasing
         if self_ascending != other.is_monotonic_increasing:

pandas/tests/indexes/timedeltas/test_setops.py

@@ -1,4 +1,5 @@
 import numpy as np
+import pytest
 
 import pandas as pd
 import pandas.util.testing as tm
@@ -145,3 +146,28 @@ def test_intersection_not_unique():
     result = idx2.intersection(idx1)
     expected = pd.to_timedelta((1, 2, 2, 3, 3), unit='s')
     tm.assert_index_equal(result, expected)
+
+
+@pytest.mark.parametrize("index1, index2, expected", [
+    (pd.to_timedelta((1, 2, 3, 4, 5, 6, 7, 8), unit='s'),
+     pd.to_timedelta((2, 3, 4, 8), unit='s'),
+     pd.to_timedelta((2, 3, 4, 8), unit='s')),
+    (pd.to_timedelta((1, 2, 3, 4, 5), unit='s'),
+     pd.to_timedelta((2, 3, 4), unit='s'),
+     pd.to_timedelta((2, 3, 4), unit='s')),
+    (pd.to_timedelta((2, 4, 5, 6), unit='s'),
+     pd.to_timedelta((2, 3, 4), unit='s'),
+     pd.to_timedelta((2, 4), unit='s')),
+])
+def test_intersection_different_lengths(index1, index2, expected):
+    def intersect(idx1, idx2, expected):
+        result = idx1.intersection(idx2)
+        tm.assert_index_equal(result, expected)
+        result = idx2.intersection(idx1)
+        tm.assert_index_equal(result, expected)
+
+    intersect(index1, index2, expected)
+    intersect(index1.sort_values(ascending=False),
+              index2.sort_values(ascending=False),
+              expected.sort_values(ascending=False)
+              )