def test_clear(self):
d = P.IntervalDict([(P.closed(0, 3), 0)])
d.clear()
assert d == P.IntervalDict()
d.clear()
assert d == P.IntervalDict()
def test_replace_values(self):
i = P.open(0, 1)
assert i.replace(left=P.CLOSED, right=P.CLOSED) == P.closed(0, 1)
assert i.replace(lower=1, upper=2) == P.open(1, 2)
assert i.replace(lower=lambda v: 1, upper=lambda v: 2) == P.open(1, 2)
def test_apply_on_empty(self):
assert P.empty().apply(lambda s:
(P.CLOSED, 1, 2, P.CLOSED)) == P.closed(1, 2)
def test_diverge_20_30(self):
if ENABLE_LONG_RUNNING_TESTS:
y_intervals = [p.closed(-p.inf, 20), p.closed(30, p.inf)]
# is the negative std correct ?
self.check_mean_std(y_intervals, 25)
def test_hash_with_hashable(self):
assert hash(P.closed(0, 1)) is not None
assert hash(P.closed(0, 1)) != hash(P.closed(1, 2))
assert hash(P.openclosed(-P.inf, 0)) is not None
assert hash(P.closedopen(0, P.inf)) is not None
assert hash(P.empty()) is not None
assert hash(P.closed(0, 1) | P.closed(3, 4)) is not None
assert hash(P.closed(0, 1) | P.closed(3, 4)) != hash(P.closed(0, 1))
assert hash(P.closed(0, 1) | P.closed(3, 4)) != hash(P.closed(3, 4))
def test_bounds(self):
assert P.to_string(P.closed(0, 1)) == '[0,1]'
assert P.to_string(P.openclosed(0, 1)) == '(0,1]'
assert P.to_string(P.closedopen(0, 1)) == '[0,1)'
assert P.to_string(P.open(0, 1)) == '(0,1)'
def test_left_censored_10_30_30(self):
y_intervals = [p.closed(-p.inf, 10), p.singleton(30), p.singleton(30)]
self.check_mean_std(y_intervals, 21.83)
def test_delete_interval(self):
d = P.IntervalDict([(P.closed(0, 2), 0)])
del d[P.closed(-1, 1)]
assert d.as_dict() == {P.openclosed(1, 2): 0}
def test_delete_interval_out_of_bound(self):
d = P.IntervalDict([(P.closed(0, 2), 0)])
del d[P.closed(-10, -9)]
assert d.as_dict() == {P.closed(0, 2): 0}
def test_set(self):
# Set values
d = P.IntervalDict([(P.closed(0, 2), 0)])
d[3] = 2
assert d.as_dict() == {P.closed(0, 2): 0, P.singleton(3): 2}
d[3] = 3
assert d.as_dict() == {P.closed(0, 2): 0, P.singleton(3): 3}
d[P.closed(0, 2)] = 1
assert d.as_dict() == {P.closed(0, 2): 1, P.singleton(3): 3}
d[P.closed(-1, 1)] = 2
assert d.as_dict() == {
P.closed(-1, 1): 2,
P.openclosed(1, 2): 1,
P.singleton(3): 3
}
d = P.IntervalDict([(P.closed(0, 2), 0)])
d[P.closed(-1, 4)] = 1
assert d.as_dict() == {P.closed(-1, 4): 1}
d[P.closed(5, 6)] = 1
assert d.as_dict() == {P.closed(-1, 4) | P.closed(5, 6): 1}
def test_delete_value(self):
d = P.IntervalDict([(P.closed(0, 2), 0)])
del d[1]
assert d.get(1, None) is None
def test_copy(self):
d = P.IntervalDict([(P.closed(0, 3), 0)])
assert d.copy() == d
assert d.copy() is not d
def test_find_on_unions(self):
d = P.IntervalDict([(P.closed(0, 2), 0), (P.closed(3, 5), 0),
(P.closed(7, 9), 1)])
assert d.find(1) == P.closed(7, 9)
assert d.find(0) == P.closed(0, 2) | P.closed(3, 5)
def test_find(self):
d = P.IntervalDict([(P.closed(0, 3), 0)])
assert d.find(-1) == P.empty()
assert d.find(0) == P.closed(0, 3)
def test_bound_types(self):
assert P.to_string(P.closed('a', 'b')) == "['a','b']"
assert P.to_string(P.closed(tuple([0]), tuple([1]))) == '[(0,),(1,)]'
def test_delete_empty_interval(self):
d = P.IntervalDict([(P.closed(0, 2), 0)])
del d[P.empty()]
assert d.as_dict() == {P.closed(0, 2): 0}
def test_bounds(self):
assert P.from_string('[0,1]', int) == P.closed(0, 1)
assert P.from_string('(0,1]', int) == P.openclosed(0, 1)
assert P.from_string('[0,1)', int) == P.closedopen(0, 1)
assert P.from_string('(0,1)', int) == P.open(0, 1)
def test_setdefault_with_values(self):
d = P.IntervalDict([(P.closed(0, 2), 0)])
assert d.setdefault(-1, default=0) == 0
assert d[-1] == 0
assert d.setdefault(0, default=1) == 0
assert d[0] == 0
def test_unions(self):
assert P.from_string('[0,1] | [2,3]', int) == P.closed(0, 1) | P.closed(2, 3)
def test_bounds(self):
assert P.to_data(P.closed(0, 1)) == [(True, 0, 1, True)]
assert P.to_data(P.openclosed(0, 1)) == [(False, 0, 1, True)]
assert P.to_data(P.closedopen(0, 1)) == [(True, 0, 1, False)]
assert P.to_data(P.open(0, 1)) == [(False, 0, 1, False)]
def test_left_censored_30_20_10(self):
y_intervals = [p.closed(-p.inf, 30), p.singleton(10), p.singleton(20)]
self.check_mean_std(y_intervals, 14.9935)
def test_values(self):
assert P.to_data(P.closed('a', 'b')) == [(True, 'a', 'b', True)]
assert P.to_data(P.closed(tuple([0]), tuple([1]))) == [(True, (0,), (1,), True)]
def test_right_censored_30_30_50(self):
y_intervals = [p.singleton(30), p.singleton(30), p.closed(50, p.inf)]
self.check_mean_std(y_intervals, 38.16)
def test_bounds(self):
assert P.from_data([(P.CLOSED, 0, 1, P.CLOSED)]) == P.closed(0, 1)
assert P.from_data([(P.OPEN, 0, 1, P.CLOSED)]) == P.openclosed(0, 1)
assert P.from_data([(P.CLOSED, 0, 1, P.OPEN)]) == P.closedopen(0, 1)
assert P.from_data([(P.OPEN, 0, 1, P.OPEN)]) == P.open(0, 1)
def test_enclosure(self):
assert P.closed(0, 1) == P.closed(0, 1).enclosure
assert P.open(0, 1) == P.open(0, 1).enclosure
assert P.closed(0, 4) == (P.closed(0, 1) | P.closed(3, 4)).enclosure
assert P.openclosed(0, 4) == (P.open(0, 1) | P.closed(3, 4)).enclosure
def test_values(self):
assert P.from_data([(P.CLOSED, 'a', 'b', P.CLOSED)]) == P.closed('a', 'b')
assert P.from_data([(P.CLOSED, (0,), (1,), P.CLOSED)]) == P.closed(tuple([0]), tuple([1]))
def test_with_infinities(self):
assert P.closed(-P.inf, P.inf) == P.open(-P.inf, P.inf)
assert P.closed(-P.inf, 0) == P.openclosed(-P.inf, 0)
assert P.closed(0, P.inf) == P.closedopen(0, P.inf)
def test_unions(self):
assert P.to_string(P.closed(0, 1) | P.closed(2, 3)) == '[0,1] | [2,3]'
def test_adjacent(self):
assert P.closedopen(0, 1).adjacent(P.closedopen(1, 2))
assert P.closed(0, 1).adjacent(P.open(1, 2))
assert not P.closed(0, 1).adjacent(P.closed(1, 2))
assert not P.open(0, 1).adjacent(P.open(1, 2))
def test_popitem(self):
d = P.IntervalDict([(P.closed(0, 3), 0)])
t = d.popitem()
assert t == (P.closed(0, 3), 0)
assert len(d) == 0
