From fdd289d9ccb38bd2972adfdc1c6856f67123b32f Mon Sep 17 00:00:00 2001 From: Alexander Lenail Date: Thu, 28 Dec 2017 11:16:07 -0800 Subject: [PATCH 01/11] add back old overlaps / covers tests --- .../indexes/interval/test_interval_new.py | 194 ++++++++++++++++++ 1 file changed, 194 insertions(+) diff --git a/pandas/tests/indexes/interval/test_interval_new.py b/pandas/tests/indexes/interval/test_interval_new.py index c8b30e19daa02..db311f893884f 100644 --- a/pandas/tests/indexes/interval/test_interval_new.py +++ b/pandas/tests/indexes/interval/test_interval_new.py @@ -314,3 +314,197 @@ def test_contains_method(self): assert not index.contains(20) assert not index.contains(-20) + + def test_interval_covers_interval(self): + + # class Interval: + # def covers(self, other: Interval) -> bool + + assert Interval(1, 3).covers(Interval(1.5, 2.5)) + assert Interval(1, 3).covers(Interval(1, 2)) + assert Interval(1, 3).covers(Interval(2, 3)) + assert not Interval(1, 3).covers(Interval(0.5, 2.5)) + assert not Interval(1, 3).covers(Interval(1.5, 3.5)) + + assert Interval(1, 3, closed='right').covers(Interval(1, 3, closed='right')) + assert not Interval(1, 3, closed='right').covers(Interval(1, 3, closed='left')) + assert not Interval(1, 3, closed='right').covers(Interval(1, 3, closed='both')) + + assert not Interval(1, 3, closed='left').covers(Interval(1, 3, closed='right')) + assert Interval(1, 3, closed='left').covers(Interval(1, 3, closed='left')) + assert not Interval(1, 3, closed='left').covers(Interval(1, 3, closed='both')) + + assert Interval(1, 3, closed='both').covers(Interval(1, 3, closed='right')) + assert Interval(1, 3, closed='both').covers(Interval(1, 3, closed='left')) + assert Interval(1, 3, closed='both').covers(Interval(1, 3, closed='both')) + + @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) + def test_interval_covers_intervalIndex(self): + + # class Interval: + # def covers(self, other: IntervalIndex) -> IntegerArray1D + + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') + + tm.assert_numpy_array_equal(Interval(1, 3, closed='right').covers(idx), np.array([1, 2])) + tm.assert_numpy_array_equal(Interval(0, 3, closed='right').covers(idx), np.array([0, 1, 2])) + tm.assert_numpy_array_equal(Interval(0, 2, closed='right').covers(idx), np.array([0])) + tm.assert_numpy_array_equal(Interval(2, 4, closed='right').covers(idx), np.array([1])) + + tm.assert_numpy_array_equal(Interval(1, 3, closed='left').covers(idx), np.array([])) + tm.assert_numpy_array_equal(Interval(0, 3, closed='left').covers(idx), np.array([0])) + tm.assert_numpy_array_equal(Interval(0, 2, closed='left').covers(idx), np.array([0])) + tm.assert_numpy_array_equal(Interval(2, 4, closed='left').covers(idx), np.array([1])) + + tm.assert_numpy_array_equal(Interval(1, 3, closed='both').covers(idx), np.array([1, 2])) + tm.assert_numpy_array_equal(Interval(0, 5, closed='both').covers(idx), np.array([0, 1, 2])) + tm.assert_numpy_array_equal(Interval(0, 2, closed='both').covers(idx), np.array([0])) + tm.assert_numpy_array_equal(Interval(2, 4, closed='both').covers(idx), np.array([1])) + + def test_interval_overlaps_interval(self): + + # class Interval: + # def overlaps(self, other: Interval) -> bool + + assert Interval(1, 3).overlaps(Interval(1.5, 2.5)) + assert Interval(1, 3).overlaps(Interval(1, 2)) + assert Interval(1, 3).overlaps(Interval(2, 3)) + assert Interval(1, 3).overlaps(Interval(0.5, 2.5)) + assert Interval(1, 3).overlaps(Interval(1.5, 3.5)) + + assert not Interval(1, 3).overlaps(Interval(-1, 1)) + assert not Interval(1, 3).overlaps(Interval(3, 5)) + + # right + assert Interval(1, 3, closed='right').overlaps(Interval(1, 3, closed='right')) + assert Interval(1, 3, closed='right').overlaps(Interval(1, 3, closed='left')) + assert Interval(1, 3, closed='right').overlaps(Interval(1, 3, closed='both')) + + assert not Interval(1, 3, closed='right').overlaps(Interval(-1, 1, closed='right')) + assert not Interval(1, 3, closed='right').overlaps(Interval(-1, 1, closed='left')) + assert not Interval(1, 3, closed='right').overlaps(Interval(-1, 1, closed='both')) + + assert not Interval(1, 3, closed='right').overlaps(Interval(3, 5, closed='right')) + assert Interval(1, 3, closed='right').overlaps(Interval(3, 5, closed='left')) + assert Interval(1, 3, closed='right').overlaps(Interval(3, 5, closed='both')) + + # left + assert Interval(1, 3, closed='left').overlaps(Interval(1, 3, closed='right')) + assert Interval(1, 3, closed='left').overlaps(Interval(1, 3, closed='left')) + assert Interval(1, 3, closed='left').overlaps(Interval(1, 3, closed='both')) + + assert not Interval(1, 3, closed='left').overlaps(Interval(-1, 1, closed='right')) + assert not Interval(1, 3, closed='left').overlaps(Interval(-1, 1, closed='left')) + assert not Interval(1, 3, closed='left').overlaps(Interval(-1, 1, closed='both')) + + assert not Interval(1, 3, closed='left').overlaps(Interval(3, 5, closed='right')) + assert Interval(1, 3, closed='left').overlaps(Interval(3, 5, closed='left')) + assert Interval(1, 3, closed='left').overlaps(Interval(3, 5, closed='both')) + + # both + assert Interval(1, 3, closed='both').overlaps(Interval(1, 3, closed='right')) + assert Interval(1, 3, closed='both').overlaps(Interval(1, 3, closed='left')) + assert Interval(1, 3, closed='both').overlaps(Interval(1, 3, closed='both')) + + assert Interval(1, 3, closed='both').overlaps(Interval(-1, 1, closed='right')) + assert not Interval(1, 3, closed='both').overlaps(Interval(-1, 1, closed='left')) + assert Interval(1, 3, closed='both').overlaps(Interval(-1, 1, closed='both')) + + assert not Interval(1, 3, closed='both').overlaps(Interval(3, 5, closed='right')) + assert Interval(1, 3, closed='both').overlaps(Interval(3, 5, closed='left')) + assert Interval(1, 3, closed='both').overlaps(Interval(3, 5, closed='both')) + + def test_interval_overlaps_intervalIndex(self): + + # class Interval: + # def overlaps(self, other: IntervalIndex) -> IntegerArray1D + + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') + + tm.assert_numpy_array_equal(Interval(1, 3, closed='right').overlaps(idx), np.array([1, 2])) + tm.assert_numpy_array_equal(Interval(1, 2, closed='right').overlaps(idx), np.array([2])) + tm.assert_numpy_array_equal(Interval(0, 2, closed='right').overlaps(idx), np.array([0, 2])) + tm.assert_numpy_array_equal(Interval(3, 4, closed='right').overlaps(idx), np.array([])) + + tm.assert_numpy_array_equal(Interval(1, 3, closed='left').overlaps(idx), np.array([0, 1, 2])) + tm.assert_numpy_array_equal(Interval(1, 2, closed='left').overlaps(idx), np.array([0, 2])) + tm.assert_numpy_array_equal(Interval(0, 2, closed='left').overlaps(idx), np.array([0, 2])) + tm.assert_numpy_array_equal(Interval(3, 4, closed='left').overlaps(idx), np.array([3])) + + tm.assert_numpy_array_equal(Interval(1, 3, closed='both').overlaps(idx), np.array([0, 1, 2])) + tm.assert_numpy_array_equal(Interval(1, 2, closed='both').overlaps(idx), np.array([0, 2])) + tm.assert_numpy_array_equal(Interval(0, 2, closed='both').overlaps(idx), np.array([0, 2])) + tm.assert_numpy_array_equal(Interval(3, 4, closed='both').overlaps(idx), np.array([3])) + + def test_intervalIndex_covers_interval(self): + + # class IntervalIndex: + # def covers(self, other: Interval) -> IntegerArray1D + + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') + + tm.assert_numpy_array_equal(idx.covers(Interval(1, 3, closed='right')), np.array([1, 2])) + tm.assert_numpy_array_equal(idx.covers(Interval(0, 3, closed='right')), np.array([0, 1, 2])) + tm.assert_numpy_array_equal(idx.covers(Interval(0, 2, closed='right')), np.array([0])) + tm.assert_numpy_array_equal(idx.covers(Interval(2, 4, closed='right')), np.array([1])) + + tm.assert_numpy_array_equal(idx.covers(Interval(1, 3, closed='left')), np.array([])) + tm.assert_numpy_array_equal(idx.covers(Interval(0, 3, closed='left')), np.array([0])) + tm.assert_numpy_array_equal(idx.covers(Interval(0, 2, closed='left')), np.array([0])) + tm.assert_numpy_array_equal(idx.covers(Interval(2, 4, closed='left')), np.array([1])) + + tm.assert_numpy_array_equal(idx.covers(Interval(1, 3, closed='both')), np.array([1, 2])) + tm.assert_numpy_array_equal(idx.covers(Interval(0, 5, closed='both')), np.array([0, 1, 2])) + tm.assert_numpy_array_equal(idx.covers(Interval(0, 2, closed='both')), np.array([0])) + tm.assert_numpy_array_equal(idx.covers(Interval(2, 4, closed='both')), np.array([1])) + + def test_intervalIndex_covers_intervalIndex(self): + + # class IntervalIndex: + # def covers(self, other: IntervalIndex) -> Tuple[IntegerArray1D, IntegerArray1D] + + idx1 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') + idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='left') + idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='both') + + self._compare_tuple_of_numpy_array(idx.covers(idx1), (np.array([0,1,2,2]), np.array([0,1,1,2]))) + self._compare_tuple_of_numpy_array(idx.covers(idx2), (np.array([2]), np.array([1]))) + self._compare_tuple_of_numpy_array(idx.covers(idx3), (np.array([0,1,2,2]), np.array([0,1,1,2]))) + + def test_intervalIndex_overlaps_interval(self): + + # class IntervalIndex: + # def overlaps(self, other: Interval) -> IntegerArray1D + + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') + + tm.assert_numpy_array_equal(idx.overlaps(Interval(1, 3, closed='right')), np.array([1, 2])) + tm.assert_numpy_array_equal(idx.overlaps(Interval(1, 2, closed='right')), np.array([2])) + tm.assert_numpy_array_equal(idx.overlaps(Interval(0, 2, closed='right')), np.array([0, 2])) + tm.assert_numpy_array_equal(idx.overlaps(Interval(3, 4, closed='right')), np.array([])) + + tm.assert_numpy_array_equal(idx.overlaps(Interval(1, 3, closed='left')), np.array([0, 1, 2])) + tm.assert_numpy_array_equal(idx.overlaps(Interval(1, 2, closed='left')), np.array([0, 2])) + tm.assert_numpy_array_equal(idx.overlaps(Interval(0, 2, closed='left')), np.array([0, 2])) + tm.assert_numpy_array_equal(idx.overlaps(Interval(3, 4, closed='left')), np.array([3])) + + tm.assert_numpy_array_equal(idx.overlaps(Interval(1, 3, closed='both')), np.array([0, 1, 2])) + tm.assert_numpy_array_equal(idx.overlaps(Interval(1, 2, closed='both')), np.array([0, 2])) + tm.assert_numpy_array_equal(idx.overlaps(Interval(0, 2, closed='both')), np.array([0, 2])) + tm.assert_numpy_array_equal(idx.overlaps(Interval(3, 4, closed='both')), np.array([3])) + + def test_intervalIndex_overlaps_intervalIndex(self): + + # class IntervalIndex: + # def overlaps(self, other: IntervalIndex) -> Tuple[IntegerArray1D, IntegerArray1D] + + idx1 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') + idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='left') + idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='both') + + self._compare_tuple_of_numpy_array(idx.overlaps(idx1), (np.array([0,1,2,2]), np.array([0,1,1,2]))) + self._compare_tuple_of_numpy_array(idx.overlaps(idx2), (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2]))) + self._compare_tuple_of_numpy_array(idx.overlaps(idx3), (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2]))) + + + From 3ea219194da1951f836cff2e9cf0ecb4150f4da3 Mon Sep 17 00:00:00 2001 From: Alexander Lenail Date: Sat, 30 Dec 2017 18:27:34 -0500 Subject: [PATCH 02/11] update --- .../indexes/interval/test_interval_new.py | 201 ------------ pandas/tests/scalar/test_interval_new.py | 294 ++++++++++++++++++ 2 files changed, 294 insertions(+), 201 deletions(-) create mode 100644 pandas/tests/scalar/test_interval_new.py diff --git a/pandas/tests/indexes/interval/test_interval_new.py b/pandas/tests/indexes/interval/test_interval_new.py index db311f893884f..71c7265b89a1d 100644 --- a/pandas/tests/indexes/interval/test_interval_new.py +++ b/pandas/tests/indexes/interval/test_interval_new.py @@ -13,13 +13,6 @@ class TestIntervalIndex(Base): - def _compare_tuple_of_numpy_array(self, result, expected): - lidx, ridx = result - lidx_expected, ridx_expected = expected - - tm.assert_numpy_array_equal(lidx, lidx_expected) - tm.assert_numpy_array_equal(ridx, ridx_expected) - @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("side", ['right', 'left', 'both', 'neither']) def test_get_loc_interval(self, idx_side, side): @@ -314,197 +307,3 @@ def test_contains_method(self): assert not index.contains(20) assert not index.contains(-20) - - def test_interval_covers_interval(self): - - # class Interval: - # def covers(self, other: Interval) -> bool - - assert Interval(1, 3).covers(Interval(1.5, 2.5)) - assert Interval(1, 3).covers(Interval(1, 2)) - assert Interval(1, 3).covers(Interval(2, 3)) - assert not Interval(1, 3).covers(Interval(0.5, 2.5)) - assert not Interval(1, 3).covers(Interval(1.5, 3.5)) - - assert Interval(1, 3, closed='right').covers(Interval(1, 3, closed='right')) - assert not Interval(1, 3, closed='right').covers(Interval(1, 3, closed='left')) - assert not Interval(1, 3, closed='right').covers(Interval(1, 3, closed='both')) - - assert not Interval(1, 3, closed='left').covers(Interval(1, 3, closed='right')) - assert Interval(1, 3, closed='left').covers(Interval(1, 3, closed='left')) - assert not Interval(1, 3, closed='left').covers(Interval(1, 3, closed='both')) - - assert Interval(1, 3, closed='both').covers(Interval(1, 3, closed='right')) - assert Interval(1, 3, closed='both').covers(Interval(1, 3, closed='left')) - assert Interval(1, 3, closed='both').covers(Interval(1, 3, closed='both')) - - @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) - def test_interval_covers_intervalIndex(self): - - # class Interval: - # def covers(self, other: IntervalIndex) -> IntegerArray1D - - idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') - - tm.assert_numpy_array_equal(Interval(1, 3, closed='right').covers(idx), np.array([1, 2])) - tm.assert_numpy_array_equal(Interval(0, 3, closed='right').covers(idx), np.array([0, 1, 2])) - tm.assert_numpy_array_equal(Interval(0, 2, closed='right').covers(idx), np.array([0])) - tm.assert_numpy_array_equal(Interval(2, 4, closed='right').covers(idx), np.array([1])) - - tm.assert_numpy_array_equal(Interval(1, 3, closed='left').covers(idx), np.array([])) - tm.assert_numpy_array_equal(Interval(0, 3, closed='left').covers(idx), np.array([0])) - tm.assert_numpy_array_equal(Interval(0, 2, closed='left').covers(idx), np.array([0])) - tm.assert_numpy_array_equal(Interval(2, 4, closed='left').covers(idx), np.array([1])) - - tm.assert_numpy_array_equal(Interval(1, 3, closed='both').covers(idx), np.array([1, 2])) - tm.assert_numpy_array_equal(Interval(0, 5, closed='both').covers(idx), np.array([0, 1, 2])) - tm.assert_numpy_array_equal(Interval(0, 2, closed='both').covers(idx), np.array([0])) - tm.assert_numpy_array_equal(Interval(2, 4, closed='both').covers(idx), np.array([1])) - - def test_interval_overlaps_interval(self): - - # class Interval: - # def overlaps(self, other: Interval) -> bool - - assert Interval(1, 3).overlaps(Interval(1.5, 2.5)) - assert Interval(1, 3).overlaps(Interval(1, 2)) - assert Interval(1, 3).overlaps(Interval(2, 3)) - assert Interval(1, 3).overlaps(Interval(0.5, 2.5)) - assert Interval(1, 3).overlaps(Interval(1.5, 3.5)) - - assert not Interval(1, 3).overlaps(Interval(-1, 1)) - assert not Interval(1, 3).overlaps(Interval(3, 5)) - - # right - assert Interval(1, 3, closed='right').overlaps(Interval(1, 3, closed='right')) - assert Interval(1, 3, closed='right').overlaps(Interval(1, 3, closed='left')) - assert Interval(1, 3, closed='right').overlaps(Interval(1, 3, closed='both')) - - assert not Interval(1, 3, closed='right').overlaps(Interval(-1, 1, closed='right')) - assert not Interval(1, 3, closed='right').overlaps(Interval(-1, 1, closed='left')) - assert not Interval(1, 3, closed='right').overlaps(Interval(-1, 1, closed='both')) - - assert not Interval(1, 3, closed='right').overlaps(Interval(3, 5, closed='right')) - assert Interval(1, 3, closed='right').overlaps(Interval(3, 5, closed='left')) - assert Interval(1, 3, closed='right').overlaps(Interval(3, 5, closed='both')) - - # left - assert Interval(1, 3, closed='left').overlaps(Interval(1, 3, closed='right')) - assert Interval(1, 3, closed='left').overlaps(Interval(1, 3, closed='left')) - assert Interval(1, 3, closed='left').overlaps(Interval(1, 3, closed='both')) - - assert not Interval(1, 3, closed='left').overlaps(Interval(-1, 1, closed='right')) - assert not Interval(1, 3, closed='left').overlaps(Interval(-1, 1, closed='left')) - assert not Interval(1, 3, closed='left').overlaps(Interval(-1, 1, closed='both')) - - assert not Interval(1, 3, closed='left').overlaps(Interval(3, 5, closed='right')) - assert Interval(1, 3, closed='left').overlaps(Interval(3, 5, closed='left')) - assert Interval(1, 3, closed='left').overlaps(Interval(3, 5, closed='both')) - - # both - assert Interval(1, 3, closed='both').overlaps(Interval(1, 3, closed='right')) - assert Interval(1, 3, closed='both').overlaps(Interval(1, 3, closed='left')) - assert Interval(1, 3, closed='both').overlaps(Interval(1, 3, closed='both')) - - assert Interval(1, 3, closed='both').overlaps(Interval(-1, 1, closed='right')) - assert not Interval(1, 3, closed='both').overlaps(Interval(-1, 1, closed='left')) - assert Interval(1, 3, closed='both').overlaps(Interval(-1, 1, closed='both')) - - assert not Interval(1, 3, closed='both').overlaps(Interval(3, 5, closed='right')) - assert Interval(1, 3, closed='both').overlaps(Interval(3, 5, closed='left')) - assert Interval(1, 3, closed='both').overlaps(Interval(3, 5, closed='both')) - - def test_interval_overlaps_intervalIndex(self): - - # class Interval: - # def overlaps(self, other: IntervalIndex) -> IntegerArray1D - - idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') - - tm.assert_numpy_array_equal(Interval(1, 3, closed='right').overlaps(idx), np.array([1, 2])) - tm.assert_numpy_array_equal(Interval(1, 2, closed='right').overlaps(idx), np.array([2])) - tm.assert_numpy_array_equal(Interval(0, 2, closed='right').overlaps(idx), np.array([0, 2])) - tm.assert_numpy_array_equal(Interval(3, 4, closed='right').overlaps(idx), np.array([])) - - tm.assert_numpy_array_equal(Interval(1, 3, closed='left').overlaps(idx), np.array([0, 1, 2])) - tm.assert_numpy_array_equal(Interval(1, 2, closed='left').overlaps(idx), np.array([0, 2])) - tm.assert_numpy_array_equal(Interval(0, 2, closed='left').overlaps(idx), np.array([0, 2])) - tm.assert_numpy_array_equal(Interval(3, 4, closed='left').overlaps(idx), np.array([3])) - - tm.assert_numpy_array_equal(Interval(1, 3, closed='both').overlaps(idx), np.array([0, 1, 2])) - tm.assert_numpy_array_equal(Interval(1, 2, closed='both').overlaps(idx), np.array([0, 2])) - tm.assert_numpy_array_equal(Interval(0, 2, closed='both').overlaps(idx), np.array([0, 2])) - tm.assert_numpy_array_equal(Interval(3, 4, closed='both').overlaps(idx), np.array([3])) - - def test_intervalIndex_covers_interval(self): - - # class IntervalIndex: - # def covers(self, other: Interval) -> IntegerArray1D - - idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') - - tm.assert_numpy_array_equal(idx.covers(Interval(1, 3, closed='right')), np.array([1, 2])) - tm.assert_numpy_array_equal(idx.covers(Interval(0, 3, closed='right')), np.array([0, 1, 2])) - tm.assert_numpy_array_equal(idx.covers(Interval(0, 2, closed='right')), np.array([0])) - tm.assert_numpy_array_equal(idx.covers(Interval(2, 4, closed='right')), np.array([1])) - - tm.assert_numpy_array_equal(idx.covers(Interval(1, 3, closed='left')), np.array([])) - tm.assert_numpy_array_equal(idx.covers(Interval(0, 3, closed='left')), np.array([0])) - tm.assert_numpy_array_equal(idx.covers(Interval(0, 2, closed='left')), np.array([0])) - tm.assert_numpy_array_equal(idx.covers(Interval(2, 4, closed='left')), np.array([1])) - - tm.assert_numpy_array_equal(idx.covers(Interval(1, 3, closed='both')), np.array([1, 2])) - tm.assert_numpy_array_equal(idx.covers(Interval(0, 5, closed='both')), np.array([0, 1, 2])) - tm.assert_numpy_array_equal(idx.covers(Interval(0, 2, closed='both')), np.array([0])) - tm.assert_numpy_array_equal(idx.covers(Interval(2, 4, closed='both')), np.array([1])) - - def test_intervalIndex_covers_intervalIndex(self): - - # class IntervalIndex: - # def covers(self, other: IntervalIndex) -> Tuple[IntegerArray1D, IntegerArray1D] - - idx1 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') - idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='left') - idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='both') - - self._compare_tuple_of_numpy_array(idx.covers(idx1), (np.array([0,1,2,2]), np.array([0,1,1,2]))) - self._compare_tuple_of_numpy_array(idx.covers(idx2), (np.array([2]), np.array([1]))) - self._compare_tuple_of_numpy_array(idx.covers(idx3), (np.array([0,1,2,2]), np.array([0,1,1,2]))) - - def test_intervalIndex_overlaps_interval(self): - - # class IntervalIndex: - # def overlaps(self, other: Interval) -> IntegerArray1D - - idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') - - tm.assert_numpy_array_equal(idx.overlaps(Interval(1, 3, closed='right')), np.array([1, 2])) - tm.assert_numpy_array_equal(idx.overlaps(Interval(1, 2, closed='right')), np.array([2])) - tm.assert_numpy_array_equal(idx.overlaps(Interval(0, 2, closed='right')), np.array([0, 2])) - tm.assert_numpy_array_equal(idx.overlaps(Interval(3, 4, closed='right')), np.array([])) - - tm.assert_numpy_array_equal(idx.overlaps(Interval(1, 3, closed='left')), np.array([0, 1, 2])) - tm.assert_numpy_array_equal(idx.overlaps(Interval(1, 2, closed='left')), np.array([0, 2])) - tm.assert_numpy_array_equal(idx.overlaps(Interval(0, 2, closed='left')), np.array([0, 2])) - tm.assert_numpy_array_equal(idx.overlaps(Interval(3, 4, closed='left')), np.array([3])) - - tm.assert_numpy_array_equal(idx.overlaps(Interval(1, 3, closed='both')), np.array([0, 1, 2])) - tm.assert_numpy_array_equal(idx.overlaps(Interval(1, 2, closed='both')), np.array([0, 2])) - tm.assert_numpy_array_equal(idx.overlaps(Interval(0, 2, closed='both')), np.array([0, 2])) - tm.assert_numpy_array_equal(idx.overlaps(Interval(3, 4, closed='both')), np.array([3])) - - def test_intervalIndex_overlaps_intervalIndex(self): - - # class IntervalIndex: - # def overlaps(self, other: IntervalIndex) -> Tuple[IntegerArray1D, IntegerArray1D] - - idx1 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') - idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='left') - idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='both') - - self._compare_tuple_of_numpy_array(idx.overlaps(idx1), (np.array([0,1,2,2]), np.array([0,1,1,2]))) - self._compare_tuple_of_numpy_array(idx.overlaps(idx2), (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2]))) - self._compare_tuple_of_numpy_array(idx.overlaps(idx3), (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2]))) - - - diff --git a/pandas/tests/scalar/test_interval_new.py b/pandas/tests/scalar/test_interval_new.py new file mode 100644 index 0000000000000..cb3f134b53883 --- /dev/null +++ b/pandas/tests/scalar/test_interval_new.py @@ -0,0 +1,294 @@ +from __future__ import division + +import pytest +import numpy as np + +from pandas import Interval, IntervalIndex, Int64Index +from pandas.tests.indexes.common import Base +import pandas.util.testing as tm + + +pytestmark = pytest.mark.skip(reason="new indexing tests for issue 16316") + + +class TestIntervalIndex(Base): + + def _compare_tuple_of_numpy_array(self, result, expected): + lidx, ridx = result + lidx_expected, ridx_expected = expected + + tm.assert_numpy_array_equal(lidx, lidx_expected) + tm.assert_numpy_array_equal(ridx, ridx_expected) + + @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) + @pytest.mark.parametrize("other_side", ['right', 'left', 'both', 'neither']) + def test_interval_covers_interval(self, ivl_side, other_side): + + # class Interval: + # def covers(self, other: Interval) -> bool + + assert Interval(1, 3).covers(Interval(1.5, 2.5)) + assert Interval(1, 3).covers(Interval(1, 2)) + assert Interval(1, 3).covers(Interval(2, 3)) + assert not Interval(1, 3).covers(Interval(0.5, 2.5)) + assert not Interval(1, 3).covers(Interval(1.5, 3.5)) + + should_cover = { + 'right': {'right': True, 'left': False, 'both': False, 'neither': True}, + 'left': {'right': False, 'left': True, 'both': False, 'neither': True}, + 'both': {'right': True, 'left': True, 'both': True, 'neither': True}, + 'neither': {'right': False, 'left': False, 'both': False, 'neither': True} + } + + ivl = Interval(1, 3, closed=ivl_side) + other = Interval(1, 3, closed=other_side) + assert ivl.covers(other) == should_cover[ivl_side][other_side] + + @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) + @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) + @pytest.mark.parametrize("ivl_range", [(1, 3), (0, 3), (0, 2), (2, 4)]) + def test_interval_covers_intervalIndex(self, idx_side, ivl_side, ivl_range): + + # class Interval: + # def covers(self, other: IntervalIndex) -> IntegerArray1D + + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed=idx_side) + ivl = Interval(*ivl_range, closed=ivl_side) + + should_cover = { + # idx_side: + # ivl_side: {ivl_range: expected_result} + 'right': { + 'right': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'left': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, + 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]} + }, + 'left': { + 'right': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, + 'left': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []} + }, + 'both': { + 'right': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, + 'left': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, + 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': {(1, 3): [], (0, 3): [], (0, 2): [], (2, 4): []} + }, + 'neither': { + 'right': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'left': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]} + } + } + + tm.assert_numpy_array_equal(ivl.covers(idx), + should_cover[idx_side][ivl_side][ivl_range]) + + @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) + @pytest.mark.parametrize("other_side", ['right', 'left', 'both', 'neither']) + @pytest.mark.parametrize("ivl_range", [(1, 3), (-1, 1), (3, 5)]) + def test_interval_overlaps_interval(self, ivl_side, other_side, ivl_range): + + # class Interval: + # def overlaps(self, other: Interval) -> bool + + assert Interval(1, 3).overlaps(Interval(1.5, 2.5)) + assert Interval(1, 3).overlaps(Interval(1, 2)) + assert Interval(1, 3).overlaps(Interval(2, 3)) + assert Interval(1, 3).overlaps(Interval(0.5, 2.5)) + assert Interval(1, 3).overlaps(Interval(1.5, 3.5)) + + assert not Interval(1, 3).overlaps(Interval(-1, 1)) + assert not Interval(1, 3).overlaps(Interval(3, 5)) + + ivl = Interval(*ivl_range, closed=ivl_side) + other = Interval(1, 3, closed=other_side) + + should_overlap = { + # idx_side: + # ivl_side: {ivl_range: expected_result} + 'right': { + 'right': {(-1, 1): False, (1, 3): True, (3, 5): False}, + 'left':{(-1, 1): False, (1, 3): True, (3, 5): True}, + 'both': {(-1, 1): False, (1, 3): True, (3, 5): True}, + 'neither': {(-1, 1): False, (1, 3): True, (3, 5): False}, + }, + 'left': { + 'right': {(-1, 1): True, (1, 3): True, (3, 5): False}, + 'left':{(-1, 1): False, (1, 3): True, (3, 5): False}, + 'both': {(-1, 1): True, (1, 3): True, (3, 5): False}, + 'neither': {(-1, 1): False, (1, 3): True, (3, 5): False}, + }, + 'both': { + 'right': {(-1, 1): True, (1, 3): True, (3, 5): False}, + 'left':{(-1, 1): False, (1, 3): True, (3, 5): True}, + 'both': {(-1, 1): True, (1, 3): True, (3, 5): True}, + 'neither': {(-1, 1): False, (1, 3): True, (3, 5): False}, + }, + 'neither': { + 'right': {(-1, 1): False, (1, 3): True, (3, 5): False}, + 'left':{(-1, 1): False, (1, 3): True, (3, 5): False}, + 'both': {(-1, 1): False, (1, 3): True, (3, 5): False}, + 'neither': {(-1, 1): False, (1, 3): True, (3, 5): False}, + } + } + + assert ivl.overlaps(other) == should_overlap[other_side][ivl_side][ivl_range] == other.overlaps(ivl) + + @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) + @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) + @pytest.mark.parametrize("ivl_range", [(1, 3), (1, 2), (0, 2), (3, 4)]) + def test_interval_overlaps_intervalIndex(self, idx_side, ivl_side, ivl_range): + + # class Interval: + # def overlaps(self, other: IntervalIndex) -> IntegerArray1D + + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed=idx_side) + ivl = Interval(*ivl_range, closed=ivl_side) + + should_overlap = { + # idx_side: + # ivl_side: {ivl_range: expected_result} + 'right': { + 'right': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'left': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, + 'both': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, + 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + }, + 'left': { + 'right': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, + 'left': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'both': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, + 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + }, + 'both': { + 'right': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, + 'left': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, + 'both': {(1, 3): [0, 1, 2], (1, 2): [0, 1, 2], (0, 2): [0, 1, 2], (3, 4): [1, 2]}, + 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + }, + 'neither': { + 'right': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'left': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'both': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + } + } + + tm.assert_numpy_array_equal(ivl.overlaps(idx), + should_overlap[idx_side][ivl_side][ivl_range]) + + @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) + @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) + @pytest.mark.parametrize("ivl_range", [(1, 3), (0, 3), (0, 2), (2, 4)]) + def test_intervalIndex_covers_interval(self, idx_side, ivl_side, ivl_range): + + # class IntervalIndex: + # def covers(self, other: Interval) -> IntegerArray1D + + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed=idx_side) + ivl = Interval(*ivl_range, closed=ivl_side) + + should_cover = { + # idx_side: + # ivl_side: {ivl_range: expected_result} + 'right': { + 'right': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'left': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, + 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]} + }, + 'left': { + 'right': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, + 'left': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []} + }, + 'both': { + 'right': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, + 'left': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, + 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': {(1, 3): [], (0, 3): [], (0, 2): [], (2, 4): []} + }, + 'neither': { + 'right': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'left': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]} + } + } + + tm.assert_numpy_array_equal(idx.covers(ivl), + should_cover[idx_side][ivl_side][ivl_range]) + + def test_intervalIndex_covers_intervalIndex(self): + + # class IntervalIndex: + # def covers(self, other: IntervalIndex) -> Tuple[IntegerArray1D, IntegerArray1D] + + idx1 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') + idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='left') + idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='both') + + self._compare_tuple_of_numpy_array(idx.covers(idx1), (np.array([0,1,2,2]), np.array([0,1,1,2]))) + self._compare_tuple_of_numpy_array(idx.covers(idx2), (np.array([2]), np.array([1]))) + self._compare_tuple_of_numpy_array(idx.covers(idx3), (np.array([0,1,2,2]), np.array([0,1,1,2]))) + + @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) + @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) + @pytest.mark.parametrize("ivl_range", [(1, 3), (1, 2), (0, 2), (3, 4)]) + def test_intervalIndex_overlaps_interval(self, idx_side, ivl_side, ivl_range): + + # class IntervalIndex: + # def overlaps(self, other: Interval) -> IntegerArray1D + + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed=idx_side) + ivl = Interval(*ivl_range, closed=ivl_side) + + should_overlap = { + # idx_side: + # ivl_side: {ivl_range: expected_result} + 'right': { + 'right': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'left': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, + 'both': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, + 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + }, + 'left': { + 'right': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, + 'left': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'both': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, + 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + }, + 'both': { + 'right': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, + 'left': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, + 'both': {(1, 3): [0, 1, 2], (1, 2): [0, 1, 2], (0, 2): [0, 1, 2], (3, 4): [1, 2]}, + 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + }, + 'neither': { + 'right': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'left': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'both': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + } + } + + tm.assert_numpy_array_equal(idx.overlaps(ivl), + should_overlap[idx_side][ivl_side][ivl_range]) + + def test_intervalIndex_overlaps_intervalIndex(self): + + # class IntervalIndex: + # def overlaps(self, other: IntervalIndex) -> Tuple[IntegerArray1D, IntegerArray1D] + + idx1 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') + idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='left') + idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='both') + + self._compare_tuple_of_numpy_array(idx.overlaps(idx1), (np.array([0,1,2,2]), np.array([0,1,1,2]))) + self._compare_tuple_of_numpy_array(idx.overlaps(idx2), (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2]))) + self._compare_tuple_of_numpy_array(idx.overlaps(idx3), (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2]))) From d7818205362785bae50dfa0655a2d714b2eafd43 Mon Sep 17 00:00:00 2001 From: Alexander Lenail Date: Sat, 30 Dec 2017 18:39:29 -0500 Subject: [PATCH 03/11] Tiny restructuring --- pandas/tests/scalar/test_interval_new.py | 148 +++++++++++------------ 1 file changed, 74 insertions(+), 74 deletions(-) diff --git a/pandas/tests/scalar/test_interval_new.py b/pandas/tests/scalar/test_interval_new.py index cb3f134b53883..08deb1d1314b6 100644 --- a/pandas/tests/scalar/test_interval_new.py +++ b/pandas/tests/scalar/test_interval_new.py @@ -44,49 +44,6 @@ def test_interval_covers_interval(self, ivl_side, other_side): other = Interval(1, 3, closed=other_side) assert ivl.covers(other) == should_cover[ivl_side][other_side] - @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) - @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) - @pytest.mark.parametrize("ivl_range", [(1, 3), (0, 3), (0, 2), (2, 4)]) - def test_interval_covers_intervalIndex(self, idx_side, ivl_side, ivl_range): - - # class Interval: - # def covers(self, other: IntervalIndex) -> IntegerArray1D - - idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed=idx_side) - ivl = Interval(*ivl_range, closed=ivl_side) - - should_cover = { - # idx_side: - # ivl_side: {ivl_range: expected_result} - 'right': { - 'right': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'left': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, - 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'neither': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]} - }, - 'left': { - 'right': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, - 'left': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'neither': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []} - }, - 'both': { - 'right': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, - 'left': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, - 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'neither': {(1, 3): [], (0, 3): [], (0, 2): [], (2, 4): []} - }, - 'neither': { - 'right': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'left': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'neither': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]} - } - } - - tm.assert_numpy_array_equal(ivl.covers(idx), - should_cover[idx_side][ivl_side][ivl_range]) - @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("other_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("ivl_range", [(1, 3), (-1, 1), (3, 5)]) @@ -140,46 +97,46 @@ def test_interval_overlaps_interval(self, ivl_side, other_side, ivl_range): @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) - @pytest.mark.parametrize("ivl_range", [(1, 3), (1, 2), (0, 2), (3, 4)]) - def test_interval_overlaps_intervalIndex(self, idx_side, ivl_side, ivl_range): + @pytest.mark.parametrize("ivl_range", [(1, 3), (0, 3), (0, 2), (2, 4)]) + def test_interval_covers_intervalIndex(self, idx_side, ivl_side, ivl_range): # class Interval: - # def overlaps(self, other: IntervalIndex) -> IntegerArray1D + # def covers(self, other: IntervalIndex) -> IntegerArray1D idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed=idx_side) ivl = Interval(*ivl_range, closed=ivl_side) - should_overlap = { + should_cover = { # idx_side: # ivl_side: {ivl_range: expected_result} 'right': { - 'right': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - 'left': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, - 'both': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, - 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'right': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'left': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, + 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]} }, 'left': { - 'right': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, - 'left': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - 'both': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, - 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'right': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, + 'left': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []} }, 'both': { - 'right': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, - 'left': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, - 'both': {(1, 3): [0, 1, 2], (1, 2): [0, 1, 2], (0, 2): [0, 1, 2], (3, 4): [1, 2]}, - 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'right': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, + 'left': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, + 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': {(1, 3): [], (0, 3): [], (0, 2): [], (2, 4): []} }, 'neither': { - 'right': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - 'left': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - 'both': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'right': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'left': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]} } } - tm.assert_numpy_array_equal(ivl.overlaps(idx), - should_overlap[idx_side][ivl_side][ivl_range]) + tm.assert_numpy_array_equal(ivl.covers(idx), + should_cover[idx_side][ivl_side][ivl_range]) @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) @@ -224,18 +181,48 @@ def test_intervalIndex_covers_interval(self, idx_side, ivl_side, ivl_range): tm.assert_numpy_array_equal(idx.covers(ivl), should_cover[idx_side][ivl_side][ivl_range]) - def test_intervalIndex_covers_intervalIndex(self): + @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) + @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) + @pytest.mark.parametrize("ivl_range", [(1, 3), (1, 2), (0, 2), (3, 4)]) + def test_interval_overlaps_intervalIndex(self, idx_side, ivl_side, ivl_range): - # class IntervalIndex: - # def covers(self, other: IntervalIndex) -> Tuple[IntegerArray1D, IntegerArray1D] + # class Interval: + # def overlaps(self, other: IntervalIndex) -> IntegerArray1D - idx1 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') - idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='left') - idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='both') + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed=idx_side) + ivl = Interval(*ivl_range, closed=ivl_side) - self._compare_tuple_of_numpy_array(idx.covers(idx1), (np.array([0,1,2,2]), np.array([0,1,1,2]))) - self._compare_tuple_of_numpy_array(idx.covers(idx2), (np.array([2]), np.array([1]))) - self._compare_tuple_of_numpy_array(idx.covers(idx3), (np.array([0,1,2,2]), np.array([0,1,1,2]))) + should_overlap = { + # idx_side: + # ivl_side: {ivl_range: expected_result} + 'right': { + 'right': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'left': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, + 'both': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, + 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + }, + 'left': { + 'right': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, + 'left': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'both': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, + 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + }, + 'both': { + 'right': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, + 'left': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, + 'both': {(1, 3): [0, 1, 2], (1, 2): [0, 1, 2], (0, 2): [0, 1, 2], (3, 4): [1, 2]}, + 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + }, + 'neither': { + 'right': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'left': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'both': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + } + } + + tm.assert_numpy_array_equal(ivl.overlaps(idx), + should_overlap[idx_side][ivl_side][ivl_range]) @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) @@ -280,6 +267,19 @@ def test_intervalIndex_overlaps_interval(self, idx_side, ivl_side, ivl_range): tm.assert_numpy_array_equal(idx.overlaps(ivl), should_overlap[idx_side][ivl_side][ivl_range]) + def test_intervalIndex_covers_intervalIndex(self): + + # class IntervalIndex: + # def covers(self, other: IntervalIndex) -> Tuple[IntegerArray1D, IntegerArray1D] + + idx1 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') + idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='left') + idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='both') + + self._compare_tuple_of_numpy_array(idx.covers(idx1), (np.array([0,1,2,2]), np.array([0,1,1,2]))) + self._compare_tuple_of_numpy_array(idx.covers(idx2), (np.array([2]), np.array([1]))) + self._compare_tuple_of_numpy_array(idx.covers(idx3), (np.array([0,1,2,2]), np.array([0,1,1,2]))) + def test_intervalIndex_overlaps_intervalIndex(self): # class IntervalIndex: From d62ac677e962904fed98892bcbe372122baac089 Mon Sep 17 00:00:00 2001 From: Alexander Lenail Date: Mon, 1 Jan 2018 11:59:46 -0500 Subject: [PATCH 04/11] tiny change --- pandas/tests/scalar/test_interval_new.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pandas/tests/scalar/test_interval_new.py b/pandas/tests/scalar/test_interval_new.py index 08deb1d1314b6..0dd4665ebb798 100644 --- a/pandas/tests/scalar/test_interval_new.py +++ b/pandas/tests/scalar/test_interval_new.py @@ -33,6 +33,9 @@ def test_interval_covers_interval(self, ivl_side, other_side): assert not Interval(1, 3).covers(Interval(0.5, 2.5)) assert not Interval(1, 3).covers(Interval(1.5, 3.5)) + ivl = Interval(1, 3, closed=ivl_side) + other = Interval(1, 3, closed=other_side) + should_cover = { 'right': {'right': True, 'left': False, 'both': False, 'neither': True}, 'left': {'right': False, 'left': True, 'both': False, 'neither': True}, @@ -40,8 +43,6 @@ def test_interval_covers_interval(self, ivl_side, other_side): 'neither': {'right': False, 'left': False, 'both': False, 'neither': True} } - ivl = Interval(1, 3, closed=ivl_side) - other = Interval(1, 3, closed=other_side) assert ivl.covers(other) == should_cover[ivl_side][other_side] @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) From 9f9ce2fb7bab807b8261086de4e83435ae0c5c68 Mon Sep 17 00:00:00 2001 From: Alexander Lenail Date: Wed, 3 Jan 2018 09:30:24 -0500 Subject: [PATCH 05/11] collapse ivl.overlaps(idx) and idx.overlaps(ivl) into a single test -- same for .covers --- pandas/tests/scalar/test_interval_new.py | 198 +++++++++-------------- 1 file changed, 76 insertions(+), 122 deletions(-) diff --git a/pandas/tests/scalar/test_interval_new.py b/pandas/tests/scalar/test_interval_new.py index 0dd4665ebb798..0c231d433fb52 100644 --- a/pandas/tests/scalar/test_interval_new.py +++ b/pandas/tests/scalar/test_interval_new.py @@ -37,10 +37,14 @@ def test_interval_covers_interval(self, ivl_side, other_side): other = Interval(1, 3, closed=other_side) should_cover = { - 'right': {'right': True, 'left': False, 'both': False, 'neither': True}, - 'left': {'right': False, 'left': True, 'both': False, 'neither': True}, - 'both': {'right': True, 'left': True, 'both': True, 'neither': True}, - 'neither': {'right': False, 'left': False, 'both': False, 'neither': True} + 'right': { + 'right': True, 'left': False, 'both': False, 'neither': True}, + 'left': { + 'right': False, 'left': True, 'both': False, 'neither': True}, + 'both': { + 'right': True, 'left': True, 'both': True, 'neither': True}, + 'neither': { + 'right': False, 'left': False, 'both': False, 'neither': True} } assert ivl.covers(other) == should_cover[ivl_side][other_side] @@ -111,76 +115,51 @@ def test_interval_covers_intervalIndex(self, idx_side, ivl_side, ivl_range): # idx_side: # ivl_side: {ivl_range: expected_result} 'right': { - 'right': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'left': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, - 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'neither': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]} + 'right': { + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'left': { + (1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, + 'both': { + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': { + (1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]} }, 'left': { - 'right': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, - 'left': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'neither': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []} + 'right': { + (1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, + 'left': { + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'both': { + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': { + (1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []} }, 'both': { - 'right': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, - 'left': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, - 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'neither': {(1, 3): [], (0, 3): [], (0, 2): [], (2, 4): []} + 'right': { + (1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, + 'left': { + (1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, + 'both': { + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': { + (1, 3): [], (0, 3): [], (0, 2): [], (2, 4): []} }, 'neither': { - 'right': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'left': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'neither': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]} + 'right': { + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'left': { + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'both': { + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + 'neither': { + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]} } } tm.assert_numpy_array_equal(ivl.covers(idx), - should_cover[idx_side][ivl_side][ivl_range]) - - @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) - @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) - @pytest.mark.parametrize("ivl_range", [(1, 3), (0, 3), (0, 2), (2, 4)]) - def test_intervalIndex_covers_interval(self, idx_side, ivl_side, ivl_range): - - # class IntervalIndex: - # def covers(self, other: Interval) -> IntegerArray1D - - idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed=idx_side) - ivl = Interval(*ivl_range, closed=ivl_side) - - should_cover = { - # idx_side: - # ivl_side: {ivl_range: expected_result} - 'right': { - 'right': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'left': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, - 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'neither': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]} - }, - 'left': { - 'right': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, - 'left': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'neither': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []} - }, - 'both': { - 'right': {(1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, - 'left': {(1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, - 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'neither': {(1, 3): [], (0, 3): [], (0, 2): [], (2, 4): []} - }, - 'neither': { - 'right': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'left': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'both': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, - 'neither': {(1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]} - } - } - + np.array(should_cover[idx_side][ivl_side][ivl_range])) tm.assert_numpy_array_equal(idx.covers(ivl), - should_cover[idx_side][ivl_side][ivl_range]) + np.array(should_cover[idx_side][ivl_side][ivl_range])) @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) @@ -197,76 +176,51 @@ def test_interval_overlaps_intervalIndex(self, idx_side, ivl_side, ivl_range): # idx_side: # ivl_side: {ivl_range: expected_result} 'right': { - 'right': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - 'left': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, - 'both': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, - 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'right': { + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'left': { + (1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, + 'both': { + (1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, + 'neither': { + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, }, 'left': { - 'right': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, - 'left': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - 'both': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, - 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'right': { + (1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, + 'left': { + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'both': { + (1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, + 'neither': { + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, }, 'both': { - 'right': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, - 'left': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, - 'both': {(1, 3): [0, 1, 2], (1, 2): [0, 1, 2], (0, 2): [0, 1, 2], (3, 4): [1, 2]}, - 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'right': { + (1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, + 'left': { + (1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, + 'both': { + (1, 3): [0, 1, 2], (1, 2): [0, 1, 2], (0, 2): [0, 1, 2], (3, 4): [1, 2]}, + 'neither': { + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, }, 'neither': { - 'right': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - 'left': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - 'both': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'right': { + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'left': { + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'both': { + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + 'neither': { + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, } } tm.assert_numpy_array_equal(ivl.overlaps(idx), - should_overlap[idx_side][ivl_side][ivl_range]) - - @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) - @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) - @pytest.mark.parametrize("ivl_range", [(1, 3), (1, 2), (0, 2), (3, 4)]) - def test_intervalIndex_overlaps_interval(self, idx_side, ivl_side, ivl_range): - - # class IntervalIndex: - # def overlaps(self, other: Interval) -> IntegerArray1D - - idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed=idx_side) - ivl = Interval(*ivl_range, closed=ivl_side) - - should_overlap = { - # idx_side: - # ivl_side: {ivl_range: expected_result} - 'right': { - 'right': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - 'left': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, - 'both': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, - 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - }, - 'left': { - 'right': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, - 'left': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - 'both': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, - 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - }, - 'both': { - 'right': {(1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, - 'left': {(1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, - 'both': {(1, 3): [0, 1, 2], (1, 2): [0, 1, 2], (0, 2): [0, 1, 2], (3, 4): [1, 2]}, - 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - }, - 'neither': { - 'right': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - 'left': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - 'both': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - 'neither': {(1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, - } - } - + np.array(should_overlap[idx_side][ivl_side][ivl_range])) tm.assert_numpy_array_equal(idx.overlaps(ivl), - should_overlap[idx_side][ivl_side][ivl_range]) + np.array(should_overlap[idx_side][ivl_side][ivl_range])) def test_intervalIndex_covers_intervalIndex(self): From b17f260c13766e996904dd91db12a2d3d3ff18fb Mon Sep 17 00:00:00 2001 From: Alexander Lenail Date: Wed, 3 Jan 2018 09:36:59 -0500 Subject: [PATCH 06/11] few random changes --- pandas/tests/scalar/test_interval_new.py | 25 +++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) diff --git a/pandas/tests/scalar/test_interval_new.py b/pandas/tests/scalar/test_interval_new.py index 0c231d433fb52..537d85805cba7 100644 --- a/pandas/tests/scalar/test_interval_new.py +++ b/pandas/tests/scalar/test_interval_new.py @@ -7,7 +7,6 @@ from pandas.tests.indexes.common import Base import pandas.util.testing as tm - pytestmark = pytest.mark.skip(reason="new indexing tests for issue 16316") @@ -21,8 +20,8 @@ def _compare_tuple_of_numpy_array(self, result, expected): tm.assert_numpy_array_equal(ridx, ridx_expected) @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) - @pytest.mark.parametrize("other_side", ['right', 'left', 'both', 'neither']) - def test_interval_covers_interval(self, ivl_side, other_side): + @pytest.mark.parametrize("oth_side", ['right', 'left', 'both', 'neither']) + def test_interval_covers_interval(self, ivl_side, oth_side): # class Interval: # def covers(self, other: Interval) -> bool @@ -34,7 +33,7 @@ def test_interval_covers_interval(self, ivl_side, other_side): assert not Interval(1, 3).covers(Interval(1.5, 3.5)) ivl = Interval(1, 3, closed=ivl_side) - other = Interval(1, 3, closed=other_side) + other = Interval(1, 3, closed=oth_side) should_cover = { 'right': { @@ -47,12 +46,12 @@ def test_interval_covers_interval(self, ivl_side, other_side): 'right': False, 'left': False, 'both': False, 'neither': True} } - assert ivl.covers(other) == should_cover[ivl_side][other_side] + assert ivl.covers(other) == should_cover[ivl_side][oth_side] @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) - @pytest.mark.parametrize("other_side", ['right', 'left', 'both', 'neither']) + @pytest.mark.parametrize("oth_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("ivl_range", [(1, 3), (-1, 1), (3, 5)]) - def test_interval_overlaps_interval(self, ivl_side, other_side, ivl_range): + def test_interval_overlaps_interval(self, ivl_side, oth_side, ivl_range): # class Interval: # def overlaps(self, other: Interval) -> bool @@ -67,7 +66,7 @@ def test_interval_overlaps_interval(self, ivl_side, other_side, ivl_range): assert not Interval(1, 3).overlaps(Interval(3, 5)) ivl = Interval(*ivl_range, closed=ivl_side) - other = Interval(1, 3, closed=other_side) + other = Interval(1, 3, closed=oth_side) should_overlap = { # idx_side: @@ -98,7 +97,9 @@ def test_interval_overlaps_interval(self, ivl_side, other_side, ivl_range): } } - assert ivl.overlaps(other) == should_overlap[other_side][ivl_side][ivl_range] == other.overlaps(ivl) + assert ivl.overlaps(other) == \ + should_overlap[oth_side][ivl_side][ivl_range] == \ + other.overlaps(ivl) @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) @@ -108,6 +109,9 @@ def test_interval_covers_intervalIndex(self, idx_side, ivl_side, ivl_range): # class Interval: # def covers(self, other: IntervalIndex) -> IntegerArray1D + # class IntervalIndex: + # def covers(self, other: Interval) -> IntegerArray1D + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed=idx_side) ivl = Interval(*ivl_range, closed=ivl_side) @@ -169,6 +173,9 @@ def test_interval_overlaps_intervalIndex(self, idx_side, ivl_side, ivl_range): # class Interval: # def overlaps(self, other: IntervalIndex) -> IntegerArray1D + # class IntervalIndex: + # def overlaps(self, other: Interval) -> IntegerArray1D + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed=idx_side) ivl = Interval(*ivl_range, closed=ivl_side) From 97503355e108e7f944e0406fdb3e002e4fc1f91a Mon Sep 17 00:00:00 2001 From: Alexander Lenail Date: Wed, 10 Jan 2018 22:54:17 -0500 Subject: [PATCH 07/11] try to be compliant with pep --- pandas/tests/scalar/test_interval_new.py | 80 ++++++++++++++++-------- 1 file changed, 54 insertions(+), 26 deletions(-) diff --git a/pandas/tests/scalar/test_interval_new.py b/pandas/tests/scalar/test_interval_new.py index 537d85805cba7..22716c8b59256 100644 --- a/pandas/tests/scalar/test_interval_new.py +++ b/pandas/tests/scalar/test_interval_new.py @@ -104,7 +104,8 @@ def test_interval_overlaps_interval(self, ivl_side, oth_side, ivl_range): @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("ivl_range", [(1, 3), (0, 3), (0, 2), (2, 4)]) - def test_interval_covers_intervalIndex(self, idx_side, ivl_side, ivl_range): + def test_interval_covers_intervalIndex(self, idx_side, ivl_side, + ivl_range): # class Interval: # def covers(self, other: IntervalIndex) -> IntegerArray1D @@ -112,7 +113,8 @@ def test_interval_covers_intervalIndex(self, idx_side, ivl_side, ivl_range): # class IntervalIndex: # def covers(self, other: Interval) -> IntegerArray1D - idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed=idx_side) + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed=idx_side) ivl = Interval(*ivl_range, closed=ivl_side) should_cover = { @@ -168,7 +170,8 @@ def test_interval_covers_intervalIndex(self, idx_side, ivl_side, ivl_range): @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("ivl_range", [(1, 3), (1, 2), (0, 2), (3, 4)]) - def test_interval_overlaps_intervalIndex(self, idx_side, ivl_side, ivl_range): + def test_interval_overlaps_intervalIndex(self, idx_side, ivl_side, + ivl_range): # class Interval: # def overlaps(self, other: IntervalIndex) -> IntegerArray1D @@ -176,7 +179,8 @@ def test_interval_overlaps_intervalIndex(self, idx_side, ivl_side, ivl_range): # class IntervalIndex: # def overlaps(self, other: Interval) -> IntegerArray1D - idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed=idx_side) + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed=idx_side) ivl = Interval(*ivl_range, closed=ivl_side) should_overlap = { @@ -186,9 +190,11 @@ def test_interval_overlaps_intervalIndex(self, idx_side, ivl_side, ivl_range): 'right': { (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, 'left': { - (1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, + (1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], + (3, 4): [1, 2]}, 'both': { - (1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, + (1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], + (3, 4): [1, 2]}, 'neither': { (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, }, @@ -206,9 +212,11 @@ def test_interval_overlaps_intervalIndex(self, idx_side, ivl_side, ivl_range): 'right': { (1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, 'left': { - (1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], (3, 4): [1, 2]}, + (1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], + (3, 4): [1, 2]}, 'both': { - (1, 3): [0, 1, 2], (1, 2): [0, 1, 2], (0, 2): [0, 1, 2], (3, 4): [1, 2]}, + (1, 3): [0, 1, 2], (1, 2): [0, 1, 2], (0, 2): [0, 1, 2], + (3, 4): [1, 2]}, 'neither': { (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, }, @@ -232,25 +240,45 @@ def test_interval_overlaps_intervalIndex(self, idx_side, ivl_side, ivl_range): def test_intervalIndex_covers_intervalIndex(self): # class IntervalIndex: - # def covers(self, other: IntervalIndex) -> Tuple[IntegerArray1D, IntegerArray1D] - - idx1 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') - idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='left') - idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='both') - - self._compare_tuple_of_numpy_array(idx.covers(idx1), (np.array([0,1,2,2]), np.array([0,1,1,2]))) - self._compare_tuple_of_numpy_array(idx.covers(idx2), (np.array([2]), np.array([1]))) - self._compare_tuple_of_numpy_array(idx.covers(idx3), (np.array([0,1,2,2]), np.array([0,1,1,2]))) + # def covers(self, other: IntervalIndex) -> Tuple[IntegerArray1D, + # IntegerArray1D] + + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed="right") + + idx1 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed="right") + idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed="left") + idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed="both") + + self._compare_tuple_of_numpy_array(idx.covers(idx1), + (np.array([0,1,2,2]), np.array([0,1,1,2]))) + self._compare_tuple_of_numpy_array(idx.covers(idx2), + (np.array([2]), np.array([1]))) + self._compare_tuple_of_numpy_array(idx.covers(idx3), + (np.array([0,1,2,2]), np.array([0,1,1,2]))) def test_intervalIndex_overlaps_intervalIndex(self): # class IntervalIndex: - # def overlaps(self, other: IntervalIndex) -> Tuple[IntegerArray1D, IntegerArray1D] - - idx1 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='right') - idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='left') - idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed='both') - - self._compare_tuple_of_numpy_array(idx.overlaps(idx1), (np.array([0,1,2,2]), np.array([0,1,1,2]))) - self._compare_tuple_of_numpy_array(idx.overlaps(idx2), (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2]))) - self._compare_tuple_of_numpy_array(idx.overlaps(idx3), (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2]))) + # def overlaps(self, other: IntervalIndex) -> Tuple[IntegerArray1D, + # IntegerArray1D] + + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed="right") + + idx1 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed="right") + idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed="left") + idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed="both") + + self._compare_tuple_of_numpy_array(idx.overlaps(idx1), + (np.array([0,1,2,2]), np.array([0,1,1,2]))) + self._compare_tuple_of_numpy_array(idx.overlaps(idx2), + (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2]))) + self._compare_tuple_of_numpy_array(idx.overlaps(idx3), + (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2]))) From 64c365847d0e680f420d4c86a3bde565ad2f8bc9 Mon Sep 17 00:00:00 2001 From: Alexander Lenail Date: Thu, 11 Jan 2018 09:41:25 -0500 Subject: [PATCH 08/11] update with jreback's review --- .../interval/test_interval_overlaps_covers.py | 74 +++++++++++++++++ pandas/tests/scalar/test_interval_new.py | 83 +++++-------------- 2 files changed, 93 insertions(+), 64 deletions(-) create mode 100644 pandas/tests/indexes/interval/test_interval_overlaps_covers.py diff --git a/pandas/tests/indexes/interval/test_interval_overlaps_covers.py b/pandas/tests/indexes/interval/test_interval_overlaps_covers.py new file mode 100644 index 0000000000000..409d6aed5578b --- /dev/null +++ b/pandas/tests/indexes/interval/test_interval_overlaps_covers.py @@ -0,0 +1,74 @@ +from __future__ import division + +import pytest +import numpy as np + +from pandas import Interval, IntervalIndex, Int64Index +from pandas.tests.indexes.common import Base +import pandas.util.testing as tm + +pytestmark = pytest.mark.skip(reason="new indexing tests for issue 16316") + + +class TestIntervalIndex(Base): + + def _compare_tuple_of_numpy_array(self, result, expected): + lidx, ridx = result + lidx_expected, ridx_expected = expected + + tm.assert_numpy_array_equal(lidx, lidx_expected) + tm.assert_numpy_array_equal(ridx, ridx_expected) + + def test_intervalIndex_covers_intervalIndex(self): + + # class IntervalIndex: + # def covers(self, other: IntervalIndex) -> Tuple[IntegerArray1D, + # IntegerArray1D] + + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed="right") + + result = idx.covers(idx) + expected = (np.array([0,1,2,2]), np.array([0,1,1,2])) + self._compare_tuple_of_numpy_array(result, expected) + + idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed="left") + + result = idx.covers(idx2), + expected = (np.array([2]), np.array([1])) + self._compare_tuple_of_numpy_array(result, expected) + + idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed="both") + + result = idx.covers(idx3), + expected = (np.array([0,1,2,2]), np.array([0,1,1,2])) + self._compare_tuple_of_numpy_array(result, expected) + + def test_intervalIndex_overlaps_intervalIndex(self): + + # class IntervalIndex: + # def overlaps(self, other: IntervalIndex) -> Tuple[IntegerArray1D, + # IntegerArray1D] + + idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed="right") + + result = idx.overlaps(idx) + expected = (np.array([0,1,2,2]), np.array([0,1,1,2])) + self._compare_tuple_of_numpy_array(result, expected) + + idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed="left") + + result = idx.overlaps(idx2) + expected = (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2])) + self._compare_tuple_of_numpy_array(result, expected) + + idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed="both") + + result = idx.overlaps(idx3) + expected = (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2])) + self._compare_tuple_of_numpy_array(result, expected) diff --git a/pandas/tests/scalar/test_interval_new.py b/pandas/tests/scalar/test_interval_new.py index 22716c8b59256..e545c1a56bfce 100644 --- a/pandas/tests/scalar/test_interval_new.py +++ b/pandas/tests/scalar/test_interval_new.py @@ -12,13 +12,6 @@ class TestIntervalIndex(Base): - def _compare_tuple_of_numpy_array(self, result, expected): - lidx, ridx = result - lidx_expected, ridx_expected = expected - - tm.assert_numpy_array_equal(lidx, lidx_expected) - tm.assert_numpy_array_equal(ridx, ridx_expected) - @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("oth_side", ['right', 'left', 'both', 'neither']) def test_interval_covers_interval(self, ivl_side, oth_side): @@ -46,7 +39,9 @@ def test_interval_covers_interval(self, ivl_side, oth_side): 'right': False, 'left': False, 'both': False, 'neither': True} } - assert ivl.covers(other) == should_cover[ivl_side][oth_side] + result = ivl.covers(other) + expected = should_cover[ivl_side][oth_side] + assert result == expected @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("oth_side", ['right', 'left', 'both', 'neither']) @@ -97,9 +92,11 @@ def test_interval_overlaps_interval(self, ivl_side, oth_side, ivl_range): } } - assert ivl.overlaps(other) == \ - should_overlap[oth_side][ivl_side][ivl_range] == \ - other.overlaps(ivl) + result = ivl.overlaps(other) + expected = should_overlap[oth_side][ivl_side][ivl_range] + other_result = other.overlaps(ivl) + + assert result == expected == other_result @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) @@ -162,10 +159,12 @@ def test_interval_covers_intervalIndex(self, idx_side, ivl_side, } } - tm.assert_numpy_array_equal(ivl.covers(idx), - np.array(should_cover[idx_side][ivl_side][ivl_range])) - tm.assert_numpy_array_equal(idx.covers(ivl), - np.array(should_cover[idx_side][ivl_side][ivl_range])) + result = ivl.covers(idx) + expected = np.array(should_cover[idx_side][ivl_side][ivl_range]) + other_result = idx.covers(ivl) + + tm.assert_numpy_array_equal(result, expected) + tm.assert_numpy_array_equal(other_result, expected) @pytest.mark.parametrize("idx_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) @@ -232,53 +231,9 @@ def test_interval_overlaps_intervalIndex(self, idx_side, ivl_side, } } - tm.assert_numpy_array_equal(ivl.overlaps(idx), - np.array(should_overlap[idx_side][ivl_side][ivl_range])) - tm.assert_numpy_array_equal(idx.overlaps(ivl), - np.array(should_overlap[idx_side][ivl_side][ivl_range])) + result = ivl.overlaps(idx) + expected = np.array(should_overlap[idx_side][ivl_side][ivl_range]) + other_result = idx.overlaps(ivl) - def test_intervalIndex_covers_intervalIndex(self): - - # class IntervalIndex: - # def covers(self, other: IntervalIndex) -> Tuple[IntegerArray1D, - # IntegerArray1D] - - idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="right") - - idx1 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="right") - idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="left") - idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="both") - - self._compare_tuple_of_numpy_array(idx.covers(idx1), - (np.array([0,1,2,2]), np.array([0,1,1,2]))) - self._compare_tuple_of_numpy_array(idx.covers(idx2), - (np.array([2]), np.array([1]))) - self._compare_tuple_of_numpy_array(idx.covers(idx3), - (np.array([0,1,2,2]), np.array([0,1,1,2]))) - - def test_intervalIndex_overlaps_intervalIndex(self): - - # class IntervalIndex: - # def overlaps(self, other: IntervalIndex) -> Tuple[IntegerArray1D, - # IntegerArray1D] - - idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="right") - - idx1 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="right") - idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="left") - idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="both") - - self._compare_tuple_of_numpy_array(idx.overlaps(idx1), - (np.array([0,1,2,2]), np.array([0,1,1,2]))) - self._compare_tuple_of_numpy_array(idx.overlaps(idx2), - (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2]))) - self._compare_tuple_of_numpy_array(idx.overlaps(idx3), - (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2]))) + tm.assert_numpy_array_equal(result, expected) + tm.assert_numpy_array_equal(other_result, expected) From fda5d5cc69d1c7243e26414db56de50e6e32b7a5 Mon Sep 17 00:00:00 2001 From: Alexander Lenail Date: Fri, 19 Jan 2018 18:07:49 -0500 Subject: [PATCH 09/11] free of lint errors? --- .../interval/test_interval_overlaps_covers.py | 24 ++--- pandas/tests/scalar/test_interval_new.py | 100 ++++++++++-------- 2 files changed, 68 insertions(+), 56 deletions(-) diff --git a/pandas/tests/indexes/interval/test_interval_overlaps_covers.py b/pandas/tests/indexes/interval/test_interval_overlaps_covers.py index 409d6aed5578b..c074ccf7ad055 100644 --- a/pandas/tests/indexes/interval/test_interval_overlaps_covers.py +++ b/pandas/tests/indexes/interval/test_interval_overlaps_covers.py @@ -3,7 +3,7 @@ import pytest import numpy as np -from pandas import Interval, IntervalIndex, Int64Index +from pandas import IntervalIndex from pandas.tests.indexes.common import Base import pandas.util.testing as tm @@ -26,24 +26,24 @@ def test_intervalIndex_covers_intervalIndex(self): # IntegerArray1D] idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="right") + closed="right") result = idx.covers(idx) - expected = (np.array([0,1,2,2]), np.array([0,1,1,2])) + expected = (np.array([0, 1, 2, 2]), np.array([0, 1, 1, 2])) self._compare_tuple_of_numpy_array(result, expected) idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="left") + closed="left") result = idx.covers(idx2), expected = (np.array([2]), np.array([1])) self._compare_tuple_of_numpy_array(result, expected) idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="both") + closed="both") result = idx.covers(idx3), - expected = (np.array([0,1,2,2]), np.array([0,1,1,2])) + expected = (np.array([0, 1, 2, 2]), np.array([0, 1, 1, 2])) self._compare_tuple_of_numpy_array(result, expected) def test_intervalIndex_overlaps_intervalIndex(self): @@ -53,22 +53,22 @@ def test_intervalIndex_overlaps_intervalIndex(self): # IntegerArray1D] idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="right") + closed="right") result = idx.overlaps(idx) - expected = (np.array([0,1,2,2]), np.array([0,1,1,2])) + expected = (np.array([0, 1, 2, 2]), np.array([0, 1, 1, 2])) self._compare_tuple_of_numpy_array(result, expected) idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="left") + closed="left") result = idx.overlaps(idx2) - expected = (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2])) + expected = (np.array([0, 0, 1, 1, 2, 2]), np.array([0, 2, 1, 2, 1, 2])) self._compare_tuple_of_numpy_array(result, expected) idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="both") + closed="both") result = idx.overlaps(idx3) - expected = (np.array([0,0,1,1,2,2]), np.array([0,2,1,2,1,2])) + expected = (np.array([0, 0, 1, 1, 2, 2]), np.array([0, 2, 1, 2, 1, 2])) self._compare_tuple_of_numpy_array(result, expected) diff --git a/pandas/tests/scalar/test_interval_new.py b/pandas/tests/scalar/test_interval_new.py index e545c1a56bfce..5e3a1e4553648 100644 --- a/pandas/tests/scalar/test_interval_new.py +++ b/pandas/tests/scalar/test_interval_new.py @@ -68,25 +68,25 @@ def test_interval_overlaps_interval(self, ivl_side, oth_side, ivl_range): # ivl_side: {ivl_range: expected_result} 'right': { 'right': {(-1, 1): False, (1, 3): True, (3, 5): False}, - 'left':{(-1, 1): False, (1, 3): True, (3, 5): True}, + 'left': {(-1, 1): False, (1, 3): True, (3, 5): True}, 'both': {(-1, 1): False, (1, 3): True, (3, 5): True}, 'neither': {(-1, 1): False, (1, 3): True, (3, 5): False}, }, 'left': { 'right': {(-1, 1): True, (1, 3): True, (3, 5): False}, - 'left':{(-1, 1): False, (1, 3): True, (3, 5): False}, + 'left': {(-1, 1): False, (1, 3): True, (3, 5): False}, 'both': {(-1, 1): True, (1, 3): True, (3, 5): False}, 'neither': {(-1, 1): False, (1, 3): True, (3, 5): False}, }, 'both': { 'right': {(-1, 1): True, (1, 3): True, (3, 5): False}, - 'left':{(-1, 1): False, (1, 3): True, (3, 5): True}, + 'left': {(-1, 1): False, (1, 3): True, (3, 5): True}, 'both': {(-1, 1): True, (1, 3): True, (3, 5): True}, 'neither': {(-1, 1): False, (1, 3): True, (3, 5): False}, }, 'neither': { 'right': {(-1, 1): False, (1, 3): True, (3, 5): False}, - 'left':{(-1, 1): False, (1, 3): True, (3, 5): False}, + 'left': {(-1, 1): False, (1, 3): True, (3, 5): False}, 'both': {(-1, 1): False, (1, 3): True, (3, 5): False}, 'neither': {(-1, 1): False, (1, 3): True, (3, 5): False}, } @@ -102,7 +102,7 @@ def test_interval_overlaps_interval(self, ivl_side, oth_side, ivl_range): @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("ivl_range", [(1, 3), (0, 3), (0, 2), (2, 4)]) def test_interval_covers_intervalIndex(self, idx_side, ivl_side, - ivl_range): + ivl_range): # class Interval: # def covers(self, other: IntervalIndex) -> IntegerArray1D @@ -111,7 +111,7 @@ def test_interval_covers_intervalIndex(self, idx_side, ivl_side, # def covers(self, other: Interval) -> IntegerArray1D idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed=idx_side) + closed=idx_side) ivl = Interval(*ivl_range, closed=ivl_side) should_cover = { @@ -119,43 +119,52 @@ def test_interval_covers_intervalIndex(self, idx_side, ivl_side, # ivl_side: {ivl_range: expected_result} 'right': { 'right': { - (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], + (2, 4): [1]}, 'left': { - (1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, + (1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, 'both': { - (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], + (2, 4): [1]}, 'neither': { - (1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]} + (1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]} }, 'left': { 'right': { - (1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, + (1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, 'left': { - (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], + (2, 4): [1]}, 'both': { - (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], + (2, 4): [1]}, 'neither': { - (1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []} + (1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []} }, 'both': { 'right': { - (1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, + (1, 3): [1], (0, 3): [1, 2], (0, 2): [], (2, 4): []}, 'left': { - (1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, + (1, 3): [], (0, 3): [0], (0, 2): [0], (2, 4): [1]}, 'both': { - (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], + (2, 4): [1]}, 'neither': { - (1, 3): [], (0, 3): [], (0, 2): [], (2, 4): []} + (1, 3): [], (0, 3): [], (0, 2): [], (2, 4): []} }, 'neither': { 'right': { - (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], + (2, 4): [1]}, 'left': { - (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], + (2, 4): [1]}, 'both': { - (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]}, + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], + (2, 4): [1]}, 'neither': { - (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], (2, 4): [1]} + (1, 3): [1, 2], (0, 3): [0, 1, 2], (0, 2): [0], + (2, 4): [1]} } } @@ -170,7 +179,7 @@ def test_interval_covers_intervalIndex(self, idx_side, ivl_side, @pytest.mark.parametrize("ivl_side", ['right', 'left', 'both', 'neither']) @pytest.mark.parametrize("ivl_range", [(1, 3), (1, 2), (0, 2), (3, 4)]) def test_interval_overlaps_intervalIndex(self, idx_side, ivl_side, - ivl_range): + ivl_range): # class Interval: # def overlaps(self, other: IntervalIndex) -> IntegerArray1D @@ -179,7 +188,7 @@ def test_interval_overlaps_intervalIndex(self, idx_side, ivl_side, # def overlaps(self, other: Interval) -> IntegerArray1D idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed=idx_side) + closed=idx_side) ivl = Interval(*ivl_range, closed=ivl_side) should_overlap = { @@ -187,47 +196,50 @@ def test_interval_overlaps_intervalIndex(self, idx_side, ivl_side, # ivl_side: {ivl_range: expected_result} 'right': { 'right': { - (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, 'left': { - (1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], - (3, 4): [1, 2]}, + (1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], + (3, 4): [1, 2]}, 'both': { - (1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], - (3, 4): [1, 2]}, + (1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], + (3, 4): [1, 2]}, 'neither': { - (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, }, 'left': { 'right': { - (1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, + (1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], + (3, 4): []}, 'left': { - (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, 'both': { - (1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, + (1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], + (3, 4): []}, 'neither': { - (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, }, 'both': { 'right': { - (1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], (3, 4): []}, + (1, 3): [1, 2], (1, 2): [1, 2], (0, 2): [0, 1, 2], + (3, 4): []}, 'left': { - (1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], - (3, 4): [1, 2]}, + (1, 3): [0, 1, 2], (1, 2): [0, 2], (0, 2): [0, 2], + (3, 4): [1, 2]}, 'both': { - (1, 3): [0, 1, 2], (1, 2): [0, 1, 2], (0, 2): [0, 1, 2], - (3, 4): [1, 2]}, + (1, 3): [0, 1, 2], (1, 2): [0, 1, 2], (0, 2): [0, 1, 2], + (3, 4): [1, 2]}, 'neither': { - (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, }, 'neither': { 'right': { - (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, 'left': { - (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, 'both': { - (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, 'neither': { - (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, + (1, 3): [1, 2], (1, 2): [2], (0, 2): [0, 2], (3, 4): []}, } } From 5686b1dae4b5b74fadcf9e93ff288b9d6f3df970 Mon Sep 17 00:00:00 2001 From: Alexander Lenail Date: Fri, 19 Jan 2018 18:09:51 -0500 Subject: [PATCH 10/11] now looks totally free --- .../indexes/interval/test_interval_overlaps_covers.py | 8 ++++---- pandas/tests/scalar/test_interval_new.py | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/pandas/tests/indexes/interval/test_interval_overlaps_covers.py b/pandas/tests/indexes/interval/test_interval_overlaps_covers.py index c074ccf7ad055..a4b67e12366e4 100644 --- a/pandas/tests/indexes/interval/test_interval_overlaps_covers.py +++ b/pandas/tests/indexes/interval/test_interval_overlaps_covers.py @@ -33,14 +33,14 @@ def test_intervalIndex_covers_intervalIndex(self): self._compare_tuple_of_numpy_array(result, expected) idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="left") + closed="left") result = idx.covers(idx2), expected = (np.array([2]), np.array([1])) self._compare_tuple_of_numpy_array(result, expected) idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="both") + closed="both") result = idx.covers(idx3), expected = (np.array([0, 1, 2, 2]), np.array([0, 1, 1, 2])) @@ -60,14 +60,14 @@ def test_intervalIndex_overlaps_intervalIndex(self): self._compare_tuple_of_numpy_array(result, expected) idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="left") + closed="left") result = idx.overlaps(idx2) expected = (np.array([0, 0, 1, 1, 2, 2]), np.array([0, 2, 1, 2, 1, 2])) self._compare_tuple_of_numpy_array(result, expected) idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="both") + closed="both") result = idx.overlaps(idx3) expected = (np.array([0, 0, 1, 1, 2, 2]), np.array([0, 2, 1, 2, 1, 2])) diff --git a/pandas/tests/scalar/test_interval_new.py b/pandas/tests/scalar/test_interval_new.py index 5e3a1e4553648..55180e246c40e 100644 --- a/pandas/tests/scalar/test_interval_new.py +++ b/pandas/tests/scalar/test_interval_new.py @@ -3,7 +3,7 @@ import pytest import numpy as np -from pandas import Interval, IntervalIndex, Int64Index +from pandas import Interval, IntervalIndex from pandas.tests.indexes.common import Base import pandas.util.testing as tm From d28f9326de26882a9b4dc0bee9dec5c598747190 Mon Sep 17 00:00:00 2001 From: Alexander Lenail Date: Mon, 2 Apr 2018 16:45:45 -0400 Subject: [PATCH 11/11] more parameterization --- .../interval/test_interval_overlaps_covers.py | 53 ++++++++----------- 1 file changed, 21 insertions(+), 32 deletions(-) diff --git a/pandas/tests/indexes/interval/test_interval_overlaps_covers.py b/pandas/tests/indexes/interval/test_interval_overlaps_covers.py index a4b67e12366e4..ef03e9be78abc 100644 --- a/pandas/tests/indexes/interval/test_interval_overlaps_covers.py +++ b/pandas/tests/indexes/interval/test_interval_overlaps_covers.py @@ -19,7 +19,8 @@ def _compare_tuple_of_numpy_array(self, result, expected): tm.assert_numpy_array_equal(lidx, lidx_expected) tm.assert_numpy_array_equal(ridx, ridx_expected) - def test_intervalIndex_covers_intervalIndex(self): + @pytest.mark.parametrize("oth_side", ['right', 'left', 'both']) + def test_intervalIndex_covers_intervalIndex(self, idx): # class IntervalIndex: # def covers(self, other: IntervalIndex) -> Tuple[IntegerArray1D, @@ -27,25 +28,19 @@ def test_intervalIndex_covers_intervalIndex(self): idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed="right") + other = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed=oth_side) result = idx.covers(idx) - expected = (np.array([0, 1, 2, 2]), np.array([0, 1, 1, 2])) - self._compare_tuple_of_numpy_array(result, expected) + expected = { + "right": (np.array([0, 1, 2, 2]), np.array([0, 1, 1, 2])), + "left": (np.array([2]), np.array([1])), + "both": (np.array([0, 1, 2, 2]), np.array([0, 1, 1, 2])) + } - idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="left") - - result = idx.covers(idx2), - expected = (np.array([2]), np.array([1])) - self._compare_tuple_of_numpy_array(result, expected) - - idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="both") - - result = idx.covers(idx3), - expected = (np.array([0, 1, 2, 2]), np.array([0, 1, 1, 2])) - self._compare_tuple_of_numpy_array(result, expected) + self._compare_tuple_of_numpy_array(result, expected[oth_side]) + @pytest.mark.parametrize("oth_side", ['right', 'left', 'both']) def test_intervalIndex_overlaps_intervalIndex(self): # class IntervalIndex: @@ -54,21 +49,15 @@ def test_intervalIndex_overlaps_intervalIndex(self): idx = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], closed="right") + other = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], + closed=oth_side) result = idx.overlaps(idx) - expected = (np.array([0, 1, 2, 2]), np.array([0, 1, 1, 2])) - self._compare_tuple_of_numpy_array(result, expected) - - idx2 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="left") - - result = idx.overlaps(idx2) - expected = (np.array([0, 0, 1, 1, 2, 2]), np.array([0, 2, 1, 2, 1, 2])) - self._compare_tuple_of_numpy_array(result, expected) - - idx3 = IntervalIndex.from_tuples([(0, 1), (2, 3), (1, 3)], - closed="both") - - result = idx.overlaps(idx3) - expected = (np.array([0, 0, 1, 1, 2, 2]), np.array([0, 2, 1, 2, 1, 2])) - self._compare_tuple_of_numpy_array(result, expected) + expected = { + "right": (np.array([0, 1, 2, 2]), np.array([0, 1, 1, 2])), + "left": (np.array([0, 0, 1, 1, 2, 2]), + np.array([0, 2, 1, 2, 1, 2])), + "both": (np.array([0, 0, 1, 1, 2, 2]), + np.array([0, 2, 1, 2, 1, 2])) + } + self._compare_tuple_of_numpy_array(result, expected[oth_side])