def test_with_smaller(self):
assert P.closed(0, 4) - P.closed(2, 3) == P.closedopen(
0, 2) | P.openclosed(3, 4)
assert P.closed(1, 4) - P.closed(1, 3) == P.openclosed(3, 4)
assert P.closed(1, 4) - P.closed(2, 4) == P.closedopen(1, 2)
assert P.closed(0, 4) - P.open(1, 2) == P.closed(0, 1) | P.closed(2, 4)
assert P.closed(0, 2) - P.open(0, 2) == P.singleton(0) | P.singleton(2)
def test_combine_nonempty(self):
add = lambda x, y: x + y
d1 = P.IntervalDict([(P.closed(1, 3) | P.closed(5, 7), 1)])
d2 = P.IntervalDict([(P.closed(2, 4) | P.closed(6, 8), 2)])
assert d1.combine(d2, add) == d2.combine(d1, add)
assert d1.combine(d2, add) == P.IntervalDict([
(P.closedopen(1, 2) | P.closedopen(5, 6), 1),
(P.closed(2, 3) | P.closed(6, 7), 3),
(P.openclosed(3, 4) | P.openclosed(7, 8), 2),
])
d1 = P.IntervalDict({
P.closed(0, 1): 2,
P.closed(3, 4): 2
})
d2 = P.IntervalDict({
P.closed(1, 3): 3,
P.closed(4, 5): 1
})
assert d1.combine(d2, add) == d2.combine(d1, add)
assert d1.combine(d2, add) == P.IntervalDict({
P.closedopen(0, 1): 2,
P.singleton(1): 5,
P.open(1, 3): 3,
P.singleton(3): 5,
P.open(3, 4): 2,
P.singleton(4): 3,
P.openclosed(4, 5): 1,
})
def test_with_intervals(self):
d = P.IntervalDict([(P.closed(0, 2), 0)])
assert d[P.open(-P.inf, P.inf)].as_dict() == {P.closed(0, 2): 0}
assert d[P.closed(0, 2)].as_dict() == {P.closed(0, 2): 0}
assert d[P.closed(-1, 0)].as_dict() == {P.singleton(0): 0}
assert d[P.closed(-2, -1)].as_dict() == {}
assert d.get(P.closed(0, 2)).as_dict() == {P.closed(0, 2): 0}
assert d.get(P.closed(-2, -1)).as_dict() == {P.closed(-2, -1): None}
assert d.get(P.closed(-1, 0)).as_dict() == {
P.closedopen(-1, 0): None,
P.singleton(0): 0
}
d[P.closed(1, 3)] = 1
assert d.as_dict() == {P.closedopen(0, 1): 0, P.closed(1, 3): 1}
assert len(d) == 2
assert d[0] == 0
assert d.get(0, -1) == 0
assert d[1] == 1
assert d.get(1, -1) == 1
assert d[3] == 1
assert d.get(3, -1) == 1
with pytest.raises(KeyError):
d[4]
assert d.get(4, -1) == -1
def test_divergent_30_32_34_50(self):
y_intervals = [
p.closed(-p.inf, 30),
p.singleton(32),
p.singleton(34),
p.closed(50, p.inf)
]
self.check_mean_std(y_intervals, 36.0223, 14.4379)
def test_with_union(self):
assert (P.closed(0, 2) | P.closed(4, 6)) & (P.closed(0, 1) | P.closed(
4, 5)) == P.closed(0, 1) | P.closed(4, 5)
assert (P.closed(0, 2) | P.closed(4, 6)) & (P.closed(-1, 1) | P.closed(
3, 6)) == P.closed(0, 1) | P.closed(4, 6)
assert (P.closed(0, 2) | P.closed(4, 6)) & (P.closed(
1, 4) | P.singleton(5)) == P.closed(
1, 2) | P.singleton(4) | P.singleton(5)
def test_right_censored_40_50_30_30(self):
y_intervals = [
p.singleton(50),
p.singleton(40),
p.closed(30, p.inf),
p.closed(30, p.inf)
]
self.check_mean_std(y_intervals, 45.0124, 4.9814)
def test_right_censored_30_30_30_30_50(self):
y_intervals = [
p.singleton(30),
p.singleton(30),
p.singleton(30),
p.singleton(30),
p.closed(50, p.inf)
]
self.check_mean_std(y_intervals, 34.8353, 9.8508)
def test_left_censored_10_30_30_30_30(self):
y_intervals = [
p.closed(-p.inf, 10),
p.singleton(30),
p.singleton(30),
p.singleton(30),
p.singleton(30)
]
self.check_mean_std(y_intervals, 25.1465, 9.8524)
def test_right_censored_30_40_40_40_50(self):
y_intervals = [
p.closed(30, p.inf),
p.singleton(40),
p.singleton(40),
p.singleton(40),
p.closed(50, p.inf)
]
self.check_mean_std(y_intervals, 43.1742, 5.5445)
def test_left_right_censoring_30_35_37_50(self):
if ENABLE_LONG_RUNNING_TESTS:
y_intervals = [
p.closed(30, p.inf),
p.singleton(35),
p.singleton(37),
p.closed(-p.inf, 50)
]
self.check_mean_std(y_intervals, 36.0000, 1.0001)
def test_left_censored_data(self):
y_intervals = [
p.closed(-p.inf, 10),
p.closed(-p.inf, 30),
p.singleton(40),
p.singleton(42),
p.singleton(44)
]
self.check_mean_std(y_intervals, 28.0059, 18.9241)
def test_left_censored_30_30_30_30_10_20(self):
y_intervals = [
p.closed(-p.inf, 30),
p.closed(-p.inf, 30),
p.closed(-p.inf, 30),
p.closed(-p.inf, 30),
p.singleton(10),
p.singleton(20)
]
self.check_mean_std(y_intervals, 14.9774, 4.9659)
def test_left_right_censoring_10_30_40_42_44_60_70(self):
y_intervals = [
p.closed(-p.inf, 10),
p.closed(-p.inf, 30),
p.singleton(40),
p.singleton(42),
p.singleton(44),
p.closed(60, p.inf),
p.closed(70, p.inf)
]
self.check_mean_std(y_intervals, 42.1983, 38.0563)
def test_empty(self):
assert P.empty() == P.Interval.from_atomic(P.OPEN, P.inf, -P.inf, P.open)
assert P.closed(3, -3) == P.empty()
assert P.openclosed(0, 0) == P.empty()
assert P.closedopen(0, 0) == P.empty()
assert P.open(0, 0) == P.empty()
assert P.closed(0, 0) != P.empty()
assert P.singleton(P.inf) == P.empty()
assert P.singleton(-P.inf) == P.empty()
def test_iterators(self):
d = P.IntervalDict([(P.closedopen(0, 1), 0), (P.closedopen(1, 3), 1), (P.singleton(3), 2)])
assert set(d.keys()) == {P.closedopen(0, 1), P.closedopen(1, 3), P.singleton(3)}
assert d.domain() == P.closed(0, 3)
assert set(d.values()) == {0, 1, 2}
assert set(d.items()) == {
(P.closedopen(0, 1), 0),
(P.closedopen(1, 3), 1),
(P.singleton(3), 2),
}
assert set(d) == set(d.keys())
def test_iterators(self):
d = P.IntervalDict([(P.closedopen(0, 1), 0), (P.closedopen(1, 3), 1),
(P.singleton(3), 2)])
assert d.keys() == [
P.closedopen(0, 1),
P.closedopen(1, 3),
P.singleton(3)
]
assert d.domain() == P.closed(0, 3)
assert d.values() == [0, 1, 2]
assert d.items() == list(zip(d.keys(), d.values()))
assert list(d) == d.keys()
def test_left_censored_10_10_30(self):
y_intervals = [
p.closed(-p.inf, 10),
p.closed(-p.inf, 10),
p.singleton(30)
]
self.check_mean_std(y_intervals, 1.8617, 23.7228)
def test_slices(self):
items = [P.closed(5, 6), P.closed(7, 9), P.singleton(10)]
interval = P.Interval(*items)
assert interval[:] == items
assert interval[:2] == items[:2]
assert interval[::-1] == items[::-1]
assert interval[::2] == items[::2]
def test_right_censored_40_30_50(self):
y_intervals = [
p.closed(30, p.inf),
p.singleton(40),
p.closed(50, p.inf)
]
self.check_mean_std(y_intervals, 48.4679, 8.7341)
def test_right_censored_30_40_50(self):
y_intervals = [
p.singleton(30),
p.closed(40, p.inf),
p.closed(50, p.inf)
]
self.check_mean_std(y_intervals, 52.0748, 18.9532)
def test_left_censored_10_20_30(self):
y_intervals = [
p.closed(-p.inf, 10),
p.closed(-p.inf, 20),
p.singleton(30)
]
self.check_mean_std(y_intervals, 7.9252, 18.9532)
def test_parameters(self):
i1, i2, i3, i4 = P.closed(0, 1), P.openclosed(0, 1), P.closedopen(0, 1), P.open(0, 1)
params = {
'disj': ' or ',
'sep': '-',
'left_open': '<!',
'left_closed': '<',
'right_open': '!>',
'right_closed': '>',
'conv': lambda s: '"{}"'.format(s),
'pinf': '+oo',
'ninf': '-oo',
}
assert P.to_string(i1, **params) == '<"0"-"1">'
assert P.to_string(i2, **params) == '<!"0"-"1">'
assert P.to_string(i3, **params) == '<"0"-"1"!>'
assert P.to_string(i4, **params) == '<!"0"-"1"!>'
assert P.to_string(P.empty(), **params) == '<!!>'
assert P.to_string(P.singleton(1), **params) == '<"1">'
assert P.to_string(P.openclosed(-P.inf, 1), **params) == '<!-oo-"1">'
assert P.to_string(P.closedopen(1, P.inf), **params) == '<"1"-+oo!>'
assert P.to_string(P.closed(0, 1) | P.closed(2, 3), **params) == '<"0"-"1"> or <"2"-"3">'
def test_parameters(self):
i1, i2, i3, i4 = '<"0"-"1">', '<!"0"-"1">', '<"0"-"1"!>', '<!"0"-"1"!>'
params = {
'conv': lambda s: int(s[1:-1]),
'disj': ' or ',
'sep': '-',
'left_open': '<!',
'left_closed': '<',
'right_open': '!>',
'right_closed': '>',
'pinf': r'\+oo',
'ninf': '-oo',
}
assert P.from_string(i1, **params) == P.closed(0, 1)
assert P.from_string(i2, **params) == P.openclosed(0, 1)
assert P.from_string(i3, **params) == P.closedopen(0, 1)
assert P.from_string(i4, **params) == P.open(0, 1)
assert P.from_string('<!!>', **params) == P.empty()
assert P.from_string('<"1">', **params) == P.singleton(1)
assert P.from_string('<!-oo-"1">', **params) == P.openclosed(-P.inf, 1)
assert P.from_string('<"1"-+oo!>', **params) == P.closedopen(1, P.inf)
assert P.from_string('<"0"-"1"> or <"2"-"3">', **params) == P.closed(0, 1) | P.closed(2, 3)
def test_right_censored_30_50_50(self):
y_intervals = [
p.singleton(30),
p.closed(50, p.inf),
p.closed(50, p.inf)
]
self.check_mean_std(y_intervals, 58.0191, 23.6987)
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_left_right_censored_30_40_50(self):
if ENABLE_LONG_RUNNING_TESTS:
y_intervals = [
p.closed(30, p.inf),
p.singleton(40),
p.closed(-p.inf, 50)
]
self.check_mean_std(y_intervals, 40, 0.1714)
def test_left_censored_30_30_10(self):
if ENABLE_LONG_RUNNING_TESTS:
y_intervals = [
p.closed(-p.inf, 30),
p.closed(-p.inf, 30),
p.singleton(10)
]
self.check_mean_std(y_intervals, 10.0067, 0.3653)
def test_right_censored_50_30_30(self):
if ENABLE_LONG_RUNNING_TESTS:
y_intervals = [
p.singleton(50),
p.closed(30, p.inf),
p.closed(30, p.inf)
]
self.check_mean_std(y_intervals, 49.9330, 0.3652)
def test_right_censored_30_50_50_50_50(self):
y_intervals = [
p.singleton(30),
p.closed(50, p.inf),
p.closed(50, p.inf),
p.closed(50, p.inf),
p.closed(50, p.inf)
]
self.check_mean_std(y_intervals, 73.3895, 29.4739)
def test_left_censored_10_10_10_10_30(self):
y_intervals = [
p.closed(-p.inf, 10),
p.closed(-p.inf, 10),
p.closed(-p.inf, 10),
p.closed(-p.inf, 10),
p.singleton(30)
]
self.check_mean_std(y_intervals, -13.5183, 29.5021)
