def test_interval_contains_inf():
inf = Interval.infinite()
assert inf.contains(math.inf) is True
assert inf.contains(-math.inf) is True
assert Interval.gte(0).contains(math.inf) is True
assert Interval.gte(0).contains(-math.inf) is False
assert Interval.lte(0).contains(math.inf) is False
assert Interval.lte(0).contains(-math.inf) is True
def test_first():
funcs = [[(0, None), (1, 12), (2, None)], [(0, 1), (1, 1), (2, 1)]]
first = Curve.first(funcs)
assert first(-1) is None
assert first(0) == 1
assert first(1) == 12
assert first(2) == 1
assert first(3) is None
funcs = [[(0, None), (1, 12), (2, None)], 1]
first = Curve.first(funcs)
assert first(-1) == 1
assert first(0) == 1
assert first(1) == 12
assert first(2) == 1
assert first(3) == 1
first = Curve.first([
Generic(lambda x: 1, domain=Interval(0, 2)),
Generic(lambda x: 2, domain=Interval.gte(1))
])
assert first(-1) is None
assert first(0) == 1
assert first(1) == 1
assert first(2) == 1
assert first(2.1) == 2
assert first(3) == 2
assert first.sample_points(Interval(0, 3), min_step=1) == [(0, 1), (1, 1),
(2, 1), (3, 2)]
def test_extensions():
d = Interval(1, 3)
assert d.get_lte().equals(Interval.lte(3))
assert d.get_gte().equals(Interval.gte(1))
assert d.get_lt().equals(Interval.lt(1))
assert d.get_gt().equals(Interval.gt(3))
d = Interval.open(1, 3)
assert d.get_lte().equals(Interval.lt(3))
assert d.get_gte().equals(Interval.gt(1))
assert d.get_lt().equals(Interval.lte(1))
assert d.get_gt().equals(Interval.gte(3))
d = Interval.empty()
assert d.get_lte().is_empty
assert d.get_gte().is_empty
assert d.get_lt().is_empty
assert d.get_gt().is_empty
def test_sample_infinite():
f = Constant(1)
with pytest.raises(Exception):
f.sample_points()
with pytest.raises(Exception):
f.sample_points(domain=Interval.infinite())
with pytest.raises(Exception):
f.sample_points(domain=Interval.gte(0))
with pytest.raises(Exception):
f.sample_points(domain=Interval.lte(0))
def update_points_of_interest(self, underlying_points):
if not self.is_ready:
return False
i_end = len(underlying_points)
if i_end == 0:
return False
def process_points_on_trend(points_on_trend, insert_index):
if len(points_on_trend) == 0:
return
closest_point = None
closest_dist = 0
for p in points_on_trend:
dist = abs(self.y(p[0]) - p[1])
if closest_point is None or dist < closest_dist:
closest_dist = dist
closest_point = p
self.tangent_points.insert(insert_index, closest_point)
# find intersections, tangent points and extremas
phase = 0
phase_point = None
previous_phase = phase
intersection_found = False
intersection_insert_index = len(self.intersections)
tangent_insert_index = len(self.tangent_points)
points_on_trend = []
new_extremas = []
extrema = None
extrema_dist = 0
# search up to the last intersection or tangent point
update_interval = self.search_interval
if len(self.intersections) != 0:
update_interval = Interval.intersection(
[update_interval,
Interval.gte(self.intersections[-1][0])])
if len(self.tangent_points) != 0:
update_interval = Interval.intersection(
[update_interval,
Interval.gt(self.tangent_points[-1][0])])
for i in reversed(range(len(underlying_points))):
p = underlying_points[i]
if not update_interval.contains(p[0]):
break
if self.is_point_on_trend(p):
points_on_trend.insert(0, p)
if extrema is not None:
new_extremas.insert(0, extrema)
extrema = None
continue
elif len(points_on_trend) != 0:
process_points_on_trend(points_on_trend, tangent_insert_index)
points_on_trend = []
phase = p[1] - self.y(p[0])
at_intersection = previous_phase != 0 and phase * previous_phase < 0
if at_intersection:
# found intersection
intersection = _line_intersection(self._line, (phase_point, p))
if intersection is None or intersection[0] < self._line[0][0]:
intersection = _average_point_of_2(phase_point, p)
self.intersections.insert(intersection_insert_index,
intersection)
intersection_found = True
if extrema is not None:
new_extremas.insert(0, extrema)
extrema = None
if phase > 0:
dist = p[1]
else:
dist = -p[1]
if extrema is None or dist > extrema_dist:
extrema = p
extrema_dist = dist
previous_phase = phase
phase_point = p
if len(points_on_trend) != 0:
process_points_on_trend(points_on_trend, tangent_insert_index)
if extrema is not None:
new_extremas.insert(0, extrema)
if len(new_extremas) != 0:
# merge extremas with existing ones
if len(self.extremas) == 0:
self.extremas += new_extremas
else:
if self.extremas[-1][0] >= update_interval.start:
# old extrema may be outdated
del self.extremas[-1]
self.extremas += new_extremas
if intersection_found:
self.update_interval()
return intersection_found
def test_intersection_inf():
assert Interval.intersection([Interval.gte(100), (98, 101)]) == (100, 101)
assert Interval.intersection([Interval.point(100), Interval.open_closed(100, 101)]) == Interval.empty()
def test_infinite():
assert Interval.gte(math.inf).is_empty is True
assert Interval.gte(-math.inf).is_empty is False
assert Interval.lte(math.inf).is_empty is False
assert Interval.lte(-math.inf).is_empty is True