def sin(x):
"""evaluates the sine of an interval"""
if isinstance(x, (int, float)):
return interval(np.sin(x))
elif isinstance(x, interval):
if not x.is_valid:
return interval(-1, 1, is_valid=x.is_valid)
na, __ = divmod(x.start, np.pi / 2.0)
nb, __ = divmod(x.end, np.pi / 2.0)
start = min(np.sin(x.start), np.sin(x.end))
end = max(np.sin(x.start), np.sin(x.end))
if nb - na > 4:
return interval(-1, 1, is_valid=x.is_valid)
elif na == nb:
return interval(start, end, is_valid=x.is_valid)
else:
if (na - 1) // 4 != (nb - 1) // 4:
#sin has max
end = 1
if (na - 3) // 4 != (nb - 3) // 4:
#sin has min
start = -1
return interval(start, end)
else:
raise NotImplementedError
def cos(x):
"""Evaluates the cos of an interval"""
if isinstance(x, (int, float)):
return interval(np.sin(x))
elif isinstance(x, interval):
if not (np.isfinite(x.start) and np.isfinite(x.end)):
return interval(-1, 1, is_valid=x.is_valid)
na, __ = divmod(x.start, np.pi / 2.0)
nb, __ = divmod(x.end, np.pi / 2.0)
start = min(np.cos(x.start), np.cos(x.end))
end = max(np.cos(x.start), np.cos(x.end))
if nb - na > 4:
#differ more than 2*pi
return interval(-1, 1, is_valid=x.is_valid)
elif na == nb:
#in the same quadarant
return interval(start, end, is_valid=x.is_valid)
else:
if (na) // 4 != (nb) // 4:
#cos has max
end = 1
if (na - 2) // 4 != (nb - 2) // 4:
#cos has min
start = -1
return interval(start, end, is_valid=x.is_valid)
else:
raise NotImplementedError
def exp(x):
"""evaluates the exponential of an interval"""
if isinstance(x, (int, float)):
return interval(np.exp(x), np.exp(x))
elif isinstance(x, interval):
return interval(np.exp(x.start), np.exp(x.end), is_valid=x.is_valid)
else:
raise NotImplementedError
def test_tan():
a = tan(interval(0, np.pi / 4))
assert a.start == 0
assert a.end == np.tan(np.pi / 4)
a = tan(interval(np.pi / 4, 3 * np.pi / 4))
#discontinuity
assert a.is_valid is None
def tanh(x):
"""Evaluates the hyperbolic tan of an interval"""
if isinstance(x, (int, float)):
return interval(np.tanh(x), np.tanh(x))
elif isinstance(x, interval):
return interval(np.tanh(x.start), np.tanh(x.end), is_valid=x.is_valid)
else:
raise NotImplementedError
def test_tan():
a = tan(interval(0, np.pi / 4))
assert a.start == 0
# must match lib_interval definition of tan:
assert a.end == np.sin(np.pi / 4)/np.cos(np.pi / 4)
a = tan(interval(np.pi / 4, 3 * np.pi / 4))
#discontinuity
assert a.is_valid is None
def sinh(x):
"""Evaluates the hyperbolic sine of an interval"""
np = import_module('numpy')
if isinstance(x, (int, float)):
return interval(np.sinh(x), np.sinh(x))
elif isinstance(x, interval):
return interval(np.sinh(x.start), np.sinh(x.end), is_valid=x.is_valid)
else:
raise NotImplementedError
def test_exp():
a = exp(interval(-np.inf, 0))
assert a.start == np.exp(-np.inf)
assert a.end == np.exp(0)
a = exp(interval(1, 2))
assert a.start == np.exp(1)
assert a.end == np.exp(2)
a = exp(1)
assert a.start == np.exp(1)
assert a.end == np.exp(1)
def asinh(x):
"""Evaluates the inverse hyperbolic sine of an interval"""
if isinstance(x, (int, float)):
return interval(np.arcsinh(x))
elif isinstance(x, interval):
start = np.arcsinh(x.start)
end = np.arcsinh(x.end)
return interval(start, end, is_valid=x.is_valid)
else:
return NotImplementedError
def Abs(x):
if isinstance(x, (int, float)):
return interval(abs(x))
elif isinstance(x, interval):
if x.start < 0 and x.end > 0:
return interval(0, max(abs(x.start), abs(x.end)), is_valid=x.is_valid)
else:
return interval(abs(x.start), abs(x.end))
else:
raise NotImplementedError
def atan(x):
"""evaluates the tan inverse of an interval"""
if isinstance(x, (int, float)):
return interval(np.arctan(x))
elif isinstance(x, interval):
start = np.arctan(x.start)
end = np.arctan(x.end)
return interval(start, end, is_valid=x.is_valid)
else:
raise NotImplementedError
def test_log10():
a = log10(interval(1, 2))
assert a.start == 0
assert a.end == np.log10(2)
a = log10(interval(-1, 1))
assert a.is_valid is None
a = log10(interval(-3, -1))
assert a.is_valid is False
a = log10(-3)
assert a.is_valid is False
a = log10(2)
assert a.start == np.log10(2)
assert a.end == np.log10(2)
def test_hashable():
'''
test that interval objects are hashable.
this is required in order to be able to put them into the cache, which
appears to be necessary for plotting in py3k. For details, see:
https://github.com/sympy/sympy/pull/2101
https://github.com/sympy/sympy/issues/6533
'''
hash(interval(1, 1))
hash(interval(1, 1, is_valid=True))
hash(interval(-4, -0.5))
hash(interval(-2, -0.5))
hash(interval(0.25, 8.0))
def test_cosh():
a = cosh(interval(1, 2))
assert a.start == np.cosh(1)
assert a.end == np.cosh(2)
a = cosh(interval(-2, -1))
assert a.start == np.cosh(-1)
assert a.end == np.cosh(-2)
a = cosh(interval(-2, 1))
assert a.start == 1
assert a.end == np.cosh(-2)
a = cosh(1)
assert a.start == np.cosh(1)
assert a.end == np.cosh(1)
def test_ceil():
a = ceil(interval(0.2, 0.5))
assert a.start == 1
assert a.end == 1
a = ceil(interval(0.5, 1.5))
assert a.start == 1
assert a.end == 2
assert a.is_valid is None
a = ceil(interval(-5, 5))
assert a.is_valid is None
a = ceil(5.4)
assert a.start == 6
assert a.end == 6
def cosh(x):
"""Evaluates the hyperbolic cos of an interval"""
if isinstance(x, (int, float)):
return interval(np.cosh(x), np.cosh(x))
elif isinstance(x, interval):
#both signs
if x.start < 0 and x.end > 0:
end = max(np.cosh(x.start), np.cosh(x.end))
return interval(1, end, is_valid=x.is_valid)
else:
#Monotonic
start = np.cosh(x.start)
end = np.cosh(x.end)
return interval(start, end, is_valid=x.is_valid)
else:
raise NotImplementedError
def test_floor():
a = floor(interval(0.2, 0.5))
assert a.start == 0
assert a.end == 0
a = floor(interval(0.5, 1.5))
assert a.start == 0
assert a.end == 1
assert a.is_valid is None
a = floor(interval(-5, 5))
assert a.is_valid is None
a = floor(5.4)
assert a.start == 5
assert a.end == 5
def test_acosh():
a = acosh(interval(3, 5))
assert a.start == np.arccosh(3)
assert a.end == np.arccosh(5)
a = acosh(interval(0, 3))
assert a.is_valid is None
a = acosh(interval(-3, 0.5))
assert a.is_valid is False
a = acosh(0.5)
assert a.is_valid is False
a = acosh(2)
assert a.start == np.arccosh(2)
assert a.end == np.arccosh(2)
def test_atan():
a = atan(interval(0, 1))
assert a.start == np.arctan(0)
assert a.end == np.arctan(1)
a = atan(1)
assert a.start == np.arctan(1)
assert a.end == np.arctan(1)
def test_atanh():
a = atanh(interval(-0.5, 0.5))
assert a.start == np.arctanh(-0.5)
assert a.end == np.arctanh(0.5)
a = atanh(interval(0, 3))
assert a.is_valid is None
a = atanh(interval(-3, -2))
assert a.is_valid is False
a = atanh(0.5)
assert a.start == np.arctanh(0.5)
assert a.end == np.arctanh(0.5)
a = atanh(1.5)
assert a.is_valid is False
def test_sinh():
a = sinh(interval(-1, 1))
assert a.start == np.sinh(-1)
assert a.end == np.sinh(1)
a = sinh(1)
assert a.start == np.sinh(1)
assert a.end == np.sinh(1)
def test_tanh():
a = tanh(interval(-3, 3))
assert a.start == np.tanh(-3)
assert a.end == np.tanh(3)
a = tanh(3)
assert a.start == np.tanh(3)
assert a.end == np.tanh(3)
def test_asinh():
a = asinh(interval(1, 2))
assert a.start == np.arcsinh(1)
assert a.end == np.arcsinh(2)
a = asinh(0.5)
assert a.start == np.arcsinh(0.5)
assert a.end == np.arcsinh(0.5)
def test_sin():
a = sin(interval(0, np.pi / 4))
assert a.start == np.sin(0)
assert a.end == np.sin(np.pi / 4)
a = sin(interval(-np.pi / 4, np.pi / 4))
assert a.start == np.sin(-np.pi / 4)
assert a.end == np.sin(np.pi / 4)
a = sin(interval(np.pi / 4, 3 * np.pi / 4))
assert a.start == np.sin(np.pi / 4)
assert a.end == 1
a = sin(interval(7 * np.pi / 6, 7 * np.pi / 4))
assert a.start == -1
assert a.end == np.sin(7 * np.pi / 6)
a = sin(interval(0, 3 * np.pi))
assert a.start == -1
assert a.end == 1
a = sin(interval(np.pi / 3, 7 * np.pi / 4))
assert a.start == -1
assert a.end == 1
a = sin(np.pi / 4)
assert a.start == np.sin(np.pi / 4)
assert a.end == np.sin(np.pi / 4)
a = sin(interval(1, 2, is_valid=False))
assert a.is_valid is False
def test_cos():
a = cos(interval(0, np.pi / 4))
assert a.start == np.cos(np.pi / 4)
assert a.end == 1
a = cos(interval(-np.pi / 4, np.pi / 4))
assert a.start == np.cos(-np.pi / 4)
assert a.end == 1
a = cos(interval(np.pi / 4, 3 * np.pi / 4))
assert a.start == np.cos(3 * np.pi / 4)
assert a.end == np.cos(np.pi / 4)
a = cos(interval(3 * np.pi / 4, 5 * np.pi / 4))
assert a.start == -1
assert a.end == np.cos(3 * np.pi / 4)
a = cos(interval(0, 3 * np.pi))
assert a.start == -1
assert a.end == 1
a = cos(interval(- np.pi / 3, 5 * np.pi / 4))
assert a.start == -1
assert a.end == 1
a = cos(interval(1, 2, is_valid=False))
assert a.is_valid is False
def imin(*args):
"""Evaluates the minimum of a list of intervals"""
if not all(isinstance(arg, (int, float, interval)) for arg in args):
return NotImplementedError
else:
new_args = [a for a in args if isinstance(a, (int, float))
or a.is_valid]
if len(new_args) == 0:
if all(a.is_valid is False for a in args):
return interval(-np.inf, np.inf, is_valid=False)
else:
return interval(-np.inf, np.inf, is_valid=None)
start_array = [a if isinstance(a, (int, float)) else a.start
for a in new_args]
end_array = [a if isinstance(a, (int, float)) else a.end
for a in new_args]
return interval(min(start_array), min(end_array))
def floor(x):
"""Evaluates the floor of an interval"""
if isinstance(x, (int, float)):
return interval(np.floor(x))
elif isinstance(x, interval):
if x.is_valid is False:
return interval(-np.inf, np.inf, is_valid=False)
else:
start = np.floor(x.start)
end = np.floor(x.end)
#continuous over the argument
if start == end:
return interval(start, end, is_valid=x.is_valid)
else:
#not continuous over the interval
return interval(start, end, is_valid=None)
else:
return NotImplementedError
def acos(x):
"""Evaluates the inverse cos of an interval"""
if isinstance(x, (int, float)):
if abs(x) > 1:
#Outside the domain
return interval(-np.inf, np.inf, is_valid=False)
else:
return interval(np.arccos(x), np.arccos(x))
elif isinstance(x, interval):
#Outside the domain
if x.is_valid is False or x.start > 1 or x.end < -1:
return interval(-np.inf, np.inf, is_valid=False)
#Partially outside the domain
elif x.start < -1 or x.end > 1:
return interval(-np.inf, np.inf, is_valid=None)
else:
start = np.arccos(x.start)
end = np.arccos(x.end)
return interval(start, end, is_valid=x.is_valid)
def acos(x):
"""Evaluates the inverse cos of an interval"""
if isinstance(x, (int, float)):
if abs(x) > 1:
#Outside the domain
return interval(-np.inf, np.inf, is_valid=False)
else:
return interval(np.arccos(x), np.arccos(x))
elif isinstance(x, interval):
#Outside the domain
if x.is_valid is False or x.start > 1 or x.end < -1:
return interval(-np.inf, np.inf, is_valid=False)
#Partially outside the domain
elif x.start < -1 or x.end > 1:
return interval(-np.inf, np.inf, is_valid=None)
else:
start = np.arccos(x.start)
end = np.arccos(x.end)
return interval(start, end, is_valid=x.is_valid)
def imin(*args):
"""Evaluates the minimum of a list of intervals"""
np = import_module('numpy')
if not all(isinstance(arg, (int, float, interval)) for arg in args):
return NotImplementedError
else:
new_args = [a for a in args if isinstance(a, (int, float))
or a.is_valid]
if len(new_args) == 0:
if all(a.is_valid is False for a in args):
return interval(-np.inf, np.inf, is_valid=False)
else:
return interval(-np.inf, np.inf, is_valid=None)
start_array = [a if isinstance(a, (int, float)) else a.start
for a in new_args]
end_array = [a if isinstance(a, (int, float)) else a.end
for a in new_args]
return interval(min(start_array), min(end_array))
def ceil(x):
"""Evaluates the ceiling of an interval"""
np = import_module('numpy')
if isinstance(x, (int, float)):
return interval(np.ceil(x))
elif isinstance(x, interval):
if x.is_valid is False:
return interval(-np.inf, np.inf, is_valid=False)
else:
start = np.ceil(x.start)
end = np.ceil(x.end)
#Continuous over the interval
if start == end:
return interval(start, end, is_valid=x.is_valid)
else:
#Not continuous over the interval
return interval(start, end, is_valid=None)
else:
return NotImplementedError
def sqrt(x):
"""Evaluates the square root of an interval"""
if isinstance(x, (int, float)):
if x > 0:
return interval(np.sqrt(x))
else:
return interval(-np.inf, np.inf, is_valid=False)
elif isinstance(x, interval):
#Outside the domain
if x.end < 0:
return interval(-np.inf, np.inf, is_valid=False)
#Partially outside the domain
elif x.start < 0:
return interval(-np.inf, np.inf, is_valid=None)
else:
return interval(np.sqrt(x.start), np.sqrt(x.end),
is_valid=x.is_valid)
else:
raise NotImplementedError
def floor(x):
"""Evaluates the floor of an interval"""
np = import_module('numpy')
if isinstance(x, (int, float)):
return interval(np.floor(x))
elif isinstance(x, interval):
if x.is_valid is False:
return interval(-np.inf, np.inf, is_valid=False)
else:
start = np.floor(x.start)
end = np.floor(x.end)
#continuous over the argument
if start == end:
return interval(start, end, is_valid=x.is_valid)
else:
#not continuous over the interval
return interval(start, end, is_valid=None)
else:
return NotImplementedError
def ceil(x):
"""Evaluates the ceiling of an interval"""
np = import_module("numpy")
if isinstance(x, (int, float)):
return interval(np.ceil(x))
elif isinstance(x, interval):
if x.is_valid is False:
return interval(-np.inf, np.inf, is_valid=False)
else:
start = np.ceil(x.start)
end = np.ceil(x.end)
# Continuous over the interval
if start == end:
return interval(start, end, is_valid=x.is_valid)
else:
# Not continuous over the interval
return interval(start, end, is_valid=None)
else:
return NotImplementedError
def asin(x):
"""Evaluates the inverse sine of an interval"""
np = import_module('numpy')
if isinstance(x, (int, float)):
#Outside the domain
if abs(x) > 1:
return interval(-np.inf, np.inf, is_valid=False)
else:
return interval(np.arcsin(x), np.arcsin(x))
elif isinstance(x, interval):
#Outside the domain
if x.is_valid is False or x.start > 1 or x.end < -1:
return interval(-np.inf, np.inf, is_valid=False)
#Partially outside the domain
elif x.start < -1 or x.end > 1:
return interval(-np.inf, np.inf, is_valid=None)
else:
start = np.arcsin(x.start)
end = np.arcsin(x.end)
return interval(start, end, is_valid=x.is_valid)
def sqrt(x):
"""Evaluates the square root of an interval"""
if isinstance(x, (int, float)):
if x > 0:
return interval(np.sqrt(x))
else:
return interval(-np.inf, np.inf, is_valid=False)
elif isinstance(x, interval):
#Outside the domain
if x.end < 0:
return interval(-np.inf, np.inf, is_valid=False)
#Partially outside the domain
elif x.start < 0:
return interval(-np.inf, np.inf, is_valid=None)
else:
return interval(np.sqrt(x.start),
np.sqrt(x.end),
is_valid=x.is_valid)
else:
raise NotImplementedError
def test_sqrt():
a = sqrt(interval(1, 4))
assert a.start == 1
assert a.end == 2
a = sqrt(interval(0.01, 1))
assert a.start == np.sqrt(0.01)
assert a.end == 1
a = sqrt(interval(-1, 1))
assert a.is_valid is None
a = sqrt(interval(-3, -1))
assert a.is_valid is False
a = sqrt(4)
assert (a == interval(2, 2)) == (True, True)
a = sqrt(-3)
assert a.is_valid is False
def atanh(x):
"""Evaluates the inverse hyperbolic tangent of an interval"""
if isinstance(x, (int, float)):
#Outside the domain
if abs(x) >= 1:
return interval(-np.inf, np.inf, is_valid=False)
else:
return interval(np.arctanh(x))
elif isinstance(x, interval):
#outside the domain
if x.is_valid is False or x.start >= 1 or x.end <= -1:
return interval(-np.inf, np.inf, is_valid=False)
#partly outside the domain
elif x.start <= -1 or x.end >= 1:
return interval(-np.inf, np.inf, is_valid=None)
else:
start = np.arctanh(x.start)
end = np.arctanh(x.end)
return interval(start, end, is_valid=x.is_valid)
else:
return NotImplementedError
def acosh(x):
"""Evaluates the inverse hyperbolic cosine of an interval"""
if isinstance(x, (int, float)):
#Outside the domain
if x < 1:
return interval(-np.inf, np.inf, is_valid=False)
else:
return interval(np.arccosh(x))
elif isinstance(x, interval):
#Outside the domain
if x.end < 1:
return interval(-np.inf, np.inf, is_valid=False)
#Partly outside the domain
elif x.start < 1:
return interval(-np.inf, np.inf, is_valid=None)
else:
start = np.arccosh(x.start)
end = np.arccosh(x.end)
return interval(start, end, is_valid=x.is_valid)
else:
return NotImplementedError
def test_acos():
a = acos(interval(-0.5, 0.5))
assert a.start == np.arccos(0.5)
assert a.end == np.arccos(-0.5)
a = acos(interval(-1.5, 1.5))
assert a.is_valid is None
a = acos(interval(-2, -1.5))
assert a.is_valid is False
a = acos(interval(0, 2))
assert a.is_valid is None
a = acos(interval(2, 5))
assert a.is_valid is False
a = acos(0.5)
assert a.start == np.arccos(0.5)
assert a.end == np.arccos(0.5)
a = acos(1.5)
assert a.is_valid is False
def test_asin():
a = asin(interval(-0.5, 0.5))
assert a.start == np.arcsin(-0.5)
assert a.end == np.arcsin(0.5)
a = asin(interval(-1.5, 1.5))
assert a.is_valid is None
a = asin(interval(-2, -1.5))
assert a.is_valid is False
a = asin(interval(0, 2))
assert a.is_valid is None
a = asin(interval(2, 5))
assert a.is_valid is False
a = asin(0.5)
assert a.start == np.arcsin(0.5)
assert a.end == np.arcsin(0.5)
a = asin(1.5)
assert a.is_valid == False
def test_imax():
a = imax(interval(-2, 2), interval(2, 7), interval(-3, 9))
assert a.start == 2
assert a.end == 9
a = imax(8, interval(1, 4))
assert a.start == 8
assert a.end == 8
a = imax(interval(1, 2), interval(3, 4), interval(-2, 2, is_valid=False))
assert a.start == 3
assert a.end == 4
def test_imin():
a = imin(interval(1, 3), interval(2, 5), interval(-1, 3))
assert a.start == -1
assert a.end == 3
a = imin(-2, interval(1, 4))
assert a.start == -2
assert a.end == -2
a = imin(5, interval(3, 4), interval(-2, 2, is_valid=False))
assert a.start == 3
assert a.end == 4
def log10(x):
"""evaluates the logarithm to the base 10 of an interval"""
if isinstance(x, (int, float)):
if x <= 0:
return interval(-np.inf, np.inf, is_valid=False)
else:
return interval(np.log10(x))
elif isinstance(x, interval):
if not x.is_valid:
return interval(-np.inf, np.inf, is_valid=x.is_valid)
elif x.end <= 0:
return interval(-np.inf, np.inf, is_valid=False)
elif x.start <= 0:
return interval(-np.inf, np.inf, is_valid=None)
return interval(np.log10(x.start), np.log10(x.end))
else:
raise NotImplementedError
def log(x):
"""evaluates the natural logarithm of an interval"""
np = import_module('numpy')
if isinstance(x, (int, float)):
if x <= 0:
return interval(-np.inf, np.inf, is_valid=False)
else:
return interval(np.log(x))
elif isinstance(x, interval):
if not x.is_valid:
return interval(-np.inf, np.inf, is_valid=x.is_valid)
elif x.end <= 0:
return interval(-np.inf, np.inf, is_valid=False)
elif x.start <= 0:
return interval(-np.inf, np.inf, is_valid=None)
return interval(np.log(x.start), np.log(x.end))
else:
raise NotImplementedError
def test_interval_pow():
a = 2**interval(1, 2) == interval(2, 4)
assert a == (True, True)
a = interval(1, 2)**interval(1, 2) == interval(1, 4)
assert a == (True, True)
a = interval(-1, 1)**interval(0.5, 2)
assert a.is_valid is None
a = interval(-2, -1)**interval(1, 2)
assert a.is_valid is False
a = interval(-2, -1)**(1 / 2)
assert a.is_valid is False
a = interval(-1, 1)**(1 / 2)
assert a.is_valid is None
a = interval(-1, 1)**(1 / 3) == interval(-1, 1)
assert a == (True, True)
a = interval(-1, 1)**2 == interval(0, 1)
assert a == (True, True)
a = interval(-1, 1)**(1 / 29) == interval(-1, 1)
assert a == (True, True)
a = -2**interval(1, 1) == interval(-2, -2)
assert a == (True, True)
a = interval(1, 2, is_valid=False)**2
assert a.is_valid is False
a = (-3)**interval(1, 2)
assert a.is_valid is False
a = (-4)**interval(0.5, 0.5)
assert a.is_valid is False
assert ((-3)**interval(1, 1) == interval(-3, -3)) == (True, True)
a = interval(8, 64)**(2 / 3)
assert abs(a.start - 4) < 1e-10 # eps
assert abs(a.end - 16) < 1e-10
a = interval(-8, 64)**(2 / 3)
assert abs(a.start - 4) < 1e-10 # eps
assert abs(a.end - 16) < 1e-10
def test_interval_inequality():
assert (interval(1, 2) < interval(3, 4)) == (True, True)
assert (interval(1, 2) < interval(2, 4)) == (None, True)
assert (interval(1, 2) < interval(-2, 0)) == (False, True)
assert (interval(1, 2) <= interval(2, 4)) == (True, True)
assert (interval(1, 2) <= interval(1.5, 6)) == (None, True)
assert (interval(2, 3) <= interval(1, 2)) == (None, True)
assert (interval(2, 3) <= interval(1, 1.5)) == (False, True)
assert (interval(1, 2, is_valid=False) <= interval(-2, 0)) == (False,
False)
assert (interval(1, 2, is_valid=None) <= interval(-2, 0)) == (False, None)
assert (interval(1, 2) <= 1.5) == (None, True)
assert (interval(1, 2) <= 3) == (True, True)
assert (interval(1, 2) <= 0) == (False, True)
assert (interval(5, 8) > interval(2, 3)) == (True, True)
assert (interval(2, 5) > interval(1, 3)) == (None, True)
assert (interval(2, 3) > interval(3.1, 5)) == (False, True)
assert (interval(3, 5) > 2) == (True, True)
assert (interval(3, 5) < 2) == (False, True)
assert (interval(1, 5) < 2) == (None, True)
assert (interval(1, 5) > 2) == (None, True)
assert (interval(0, 1) > 2) == (False, True)
assert (interval(1, 2) >= interval(0, 1)) == (True, True)
assert (interval(1, 2) >= interval(0, 1.5)) == (None, True)
assert (interval(1, 2) >= interval(3, 4)) == (False, True)
assert (interval(1, 2) >= 0) == (True, True)
assert (interval(1, 2) >= 1.2) == (None, True)
assert (interval(1, 2) >= 3) == (False, True)
assert (2 > interval(0, 1)) == (True, True)
a = interval(-1, 1, is_valid=False) < interval(2, 5, is_valid=None)
assert a == (True, False)
a = interval(-1, 1, is_valid=None) < interval(2, 5, is_valid=False)
assert a == (True, False)
a = interval(-1, 1, is_valid=None) < interval(2, 5, is_valid=None)
assert a == (True, None)
a = interval(-1, 1, is_valid=False) > interval(-5, -2, is_valid=None)
assert a == (True, False)
a = interval(-1, 1, is_valid=None) > interval(-5, -2, is_valid=False)
assert a == (True, False)
a = interval(-1, 1, is_valid=None) > interval(-5, -2, is_valid=None)
assert a == (True, None)
def test_interval_div():
div = interval(1, 2, is_valid=False) / 3
assert div == interval(-float('inf'), float('inf'), is_valid=False)
div = interval(1, 2, is_valid=None) / 3
assert div == interval(-float('inf'), float('inf'), is_valid=None)
div = 3 / interval(1, 2, is_valid=None)
assert div == interval(-float('inf'), float('inf'), is_valid=None)
a = interval(1, 2) / 0
assert a.is_valid is False
a = interval(0.5, 1) / interval(-1, 0)
assert a.is_valid is None
a = interval(0, 1) / interval(0, 1)
assert a.is_valid is None
a = interval(-1, 1) / interval(-1, 1)
assert a.is_valid is None
a = interval(-1, 2) / interval(0.5, 1) == interval(-2.0, 4.0)
assert a == (True, True)
a = interval(0, 1) / interval(0.5, 1) == interval(0.0, 2.0)
assert a == (True, True)
a = interval(-1, 0) / interval(0.5, 1) == interval(-2.0, 0.0)
assert a == (True, True)
a = interval(-0.5, -0.25) / interval(0.5, 1) == interval(-1.0, -0.25)
assert a == (True, True)
a = interval(0.5, 1) / interval(0.5, 1) == interval(0.5, 2.0)
assert a == (True, True)
a = interval(0.5, 4) / interval(0.5, 1) == interval(0.5, 8.0)
assert a == (True, True)
a = interval(-1, -0.5) / interval(0.5, 1) == interval(-2.0, -0.5)
assert a == (True, True)
a = interval(-4, -0.5) / interval(0.5, 1) == interval(-8.0, -0.5)
assert a == (True, True)
a = interval(-1, 2) / interval(-2, -0.5) == interval(-4.0, 2.0)
assert a == (True, True)
a = interval(0, 1) / interval(-2, -0.5) == interval(-2.0, 0.0)
assert a == (True, True)
a = interval(-1, 0) / interval(-2, -0.5) == interval(0.0, 2.0)
assert a == (True, True)
a = interval(-0.5, -0.25) / interval(-2, -0.5) == interval(0.125, 1.0)
assert a == (True, True)
a = interval(0.5, 1) / interval(-2, -0.5) == interval(-2.0, -0.25)
assert a == (True, True)
a = interval(0.5, 4) / interval(-2, -0.5) == interval(-8.0, -0.25)
assert a == (True, True)
a = interval(-1, -0.5) / interval(-2, -0.5) == interval(0.25, 2.0)
assert a == (True, True)
a = interval(-4, -0.5) / interval(-2, -0.5) == interval(0.25, 8.0)
assert a == (True, True)
a = interval(-5, 5, is_valid=False) / 2
assert a.is_valid is False
def test_interval():
assert (interval(1, 1) == interval(1, 1, is_valid=True)) == (True, True)
assert (interval(1, 1) == interval(1, 1, is_valid=False)) == (True, False)
assert (interval(1, 1) == interval(1, 1, is_valid=None)) == (True, None)
assert (interval(1, 1.5) == interval(1, 2)) == (None, True)
assert (interval(0, 1) == interval(2, 3)) == (False, True)
assert (interval(0, 1) == interval(1, 2)) == (None, True)
assert (interval(1, 2) != interval(1, 2)) == (False, True)
assert (interval(1, 3) != interval(2, 3)) == (None, True)
assert (interval(1, 3) != interval(-5, -3)) == (True, True)
assert (interval(1, 3, is_valid=False) != interval(-5, -3)) == (True,
False)
assert (interval(1, 3, is_valid=None) != interval(-5, 3)) == (None, None)
assert (interval(4, 4) != 4) == (False, True)
assert (interval(1, 1) == 1) == (True, True)
assert (interval(1, 3, is_valid=False) == interval(1, 3)) == (True, False)
assert (interval(1, 3, is_valid=None) == interval(1, 3)) == (True, None)
inter = interval(-5, 5)
assert (interval(inter) == interval(-5, 5)) == (True, True)
assert inter.width == 10
assert 0 in inter
assert -5 in inter
assert 5 in inter
assert interval(0, 3) in inter
assert interval(-6, 2) not in inter
assert -5.05 not in inter
assert 5.3 not in inter
interb = interval(-float('inf'), float('inf'))
assert 0 in inter
assert inter in interb
assert interval(0, float('inf')) in interb
assert interval(-float('inf'), 5) in interb
assert interval(-1e50, 1e50) in interb
assert (-interval(-1, -2, is_valid=False) == interval(1,
2)) == (True, False)
raises(ValueError, lambda: interval(1, 2, 3))
def test_interval_add():
assert (interval(1, 2) + interval(2, 3) == interval(3, 5)) == (True, True)
assert (1 + interval(1, 2) == interval(2, 3)) == (True, True)
assert (interval(1, 2) + 1 == interval(2, 3)) == (True, True)
compare = (1 + interval(0, float('inf')) == interval(1, float('inf')))
assert compare == (True, True)
a = 1 + interval(2, 5, is_valid=False)
assert a.is_valid is False
a = 1 + interval(2, 5, is_valid=None)
assert a.is_valid is None
a = interval(2, 5, is_valid=False) + interval(3, 5, is_valid=None)
assert a.is_valid is False
a = interval(3, 5) + interval(-1, 1, is_valid=None)
assert a.is_valid is None
a = interval(2, 5, is_valid=False) + 1
assert a.is_valid is False
def _get_raster_interval(self, func):
""" Uses interval math to adaptively mesh and obtain the plot"""
k = self.depth
interval_list = []
#Create initial 32 divisions
np = import_module('numpy')
xsample = np.linspace(self.start_x, self.end_x, 33)
ysample = np.linspace(self.start_y, self.end_y, 33)
#Add a small jitter so that there are no false positives for equality.
# Ex: y==x becomes True for x interval(1, 2) and y interval(1, 2)
#which will draw a rectangle.
jitterx = (np.random.rand(
len(xsample)) * 2 - 1) * (self.end_x - self.start_x) / 2**20
jittery = (np.random.rand(
len(ysample)) * 2 - 1) * (self.end_y - self.start_y) / 2**20
xsample += jitterx
ysample += jittery
xinter = [interval(x1, x2) for x1, x2 in zip(xsample[:-1],
xsample[1:])]
yinter = [interval(y1, y2) for y1, y2 in zip(ysample[:-1],
ysample[1:])]
interval_list = [[x, y] for x in xinter for y in yinter]
plot_list = []
#recursive call refinepixels which subdivides the intervals which are
#neither True nor False according to the expression.
def refine_pixels(interval_list):
""" Evaluates the intervals and subdivides the interval if the
expression is partially satisfied."""
temp_interval_list = []
plot_list = []
for intervals in interval_list:
#Convert the array indices to x and y values
intervalx = intervals[0]
intervaly = intervals[1]
func_eval = func(intervalx, intervaly)
#The expression is valid in the interval. Change the contour
#array values to 1.
if func_eval[1] is False or func_eval[0] is False:
pass
elif func_eval == (True, True):
plot_list.append([intervalx, intervaly])
elif func_eval[1] is None or func_eval[0] is None:
#Subdivide
avgx = intervalx.mid
avgy = intervaly.mid
a = interval(intervalx.start, avgx)
b = interval(avgx, intervalx.end)
c = interval(intervaly.start, avgy)
d = interval(avgy, intervaly.end)
temp_interval_list.append([a, c])
temp_interval_list.append([a, d])
temp_interval_list.append([b, c])
temp_interval_list.append([b, d])
return temp_interval_list, plot_list
while k >= 0 and len(interval_list):
interval_list, plot_list_temp = refine_pixels(interval_list)
plot_list.extend(plot_list_temp)
k = k - 1
#Check whether the expression represents an equality
#If it represents an equality, then none of the intervals
#would have satisfied the expression due to floating point
#differences. Add all the undecided values to the plot.
if self.has_equality:
for intervals in interval_list:
intervalx = intervals[0]
intervaly = intervals[1]
func_eval = func(intervalx, intervaly)
if func_eval[1] and func_eval[0] is not False:
plot_list.append([intervalx, intervaly])
return plot_list, 'fill'
def test_interval_mul():
assert (interval(1, 5) * interval(2, 10) == interval(2,
50)) == (True, True)
a = interval(-1, 1) * interval(2, 10) == interval(-10, 10)
assert a == (True, True)
a = interval(-1, 1) * interval(-5, 3) == interval(-5, 5)
assert a == (True, True)
assert (interval(1, 3) * 2 == interval(2, 6)) == (True, True)
assert (3 * interval(-1, 2) == interval(-3, 6)) == (True, True)
a = 3 * interval(1, 2, is_valid=False)
assert a.is_valid is False
a = 3 * interval(1, 2, is_valid=None)
assert a.is_valid is None
a = interval(1, 5, is_valid=False) * interval(1, 2, is_valid=None)
assert a.is_valid is False
def test_Abs():
assert (Abs(interval(-0.5, 0.5)) == interval(0, 0.5)) == (True, True)
assert (Abs(interval(-3, -2)) == interval(2, 3)) == (True, True)
assert (Abs(-3) == interval(3, 3)) == (True, True)
def test_interval_sub():
assert (interval(1, 2) - interval(1, 5) == interval(-4, 1)) == (True, True)
assert (interval(1, 2) - 1 == interval(0, 1)) == (True, True)
assert (1 - interval(1, 2) == interval(-1, 0)) == (True, True)
a = 1 - interval(1, 2, is_valid=False)
assert a.is_valid is False
a = interval(1, 4, is_valid=None) - 1
assert a.is_valid is None
a = interval(1, 3, is_valid=False) - interval(1, 3)
assert a.is_valid is False
a = interval(1, 3, is_valid=None) - interval(1, 3)
assert a.is_valid is None
