def test_singularities():
assert singularities(x**2, x) == S.EmptySet
assert singularities(x/(x**2 + 3*x + 2), x) == FiniteSet(-2, -1)
assert singularities(1/(x**2 + 1), x) == FiniteSet(I, -I)
assert singularities(x/(x**3 + 1), x) == \
FiniteSet(-1, (1 - sqrt(3) * I) / 2, (1 + sqrt(3) * I) / 2)
assert singularities(1/(y**2 + 2*I*y + 1), y) == \
FiniteSet(-I + sqrt(2)*I, -I - sqrt(2)*I)
def test_singularities():
assert singularities(x**2, x) == S.EmptySet
assert singularities(x / (x**2 + 3 * x + 2), x) == FiniteSet(-2, -1)
assert singularities(1 / (x**2 + 1), x) == FiniteSet(I, -I)
assert singularities(x/(x**3 + 1), x) == \
FiniteSet(-1, (1 - sqrt(3) * I) / 2, (1 + sqrt(3) * I) / 2)
assert singularities(1/(y**2 + 2*I*y + 1), y) == \
FiniteSet(-I + sqrt(2)*I, -I - sqrt(2)*I)
def test_singularities():
x = Symbol('x')
assert singularities(x**2, x) == S.EmptySet
assert singularities(x / (x**2 + 3 * x + 2), x) == FiniteSet(-2, -1)
assert singularities(1 / (x**2 + 1), x) == FiniteSet(I, -I)
assert singularities(x/(x**3 + 1), x) == \
FiniteSet(-1, (1 - sqrt(3) * I) / 2, (1 + sqrt(3) * I) / 2)
assert singularities(1/(y**2 + 2*I*y + 1), y) == \
FiniteSet(-I + sqrt(2)*I, -I - sqrt(2)*I)
x = Symbol('x', real=True)
assert singularities(1 / (x**2 + 1), x) == S.EmptySet
assert singularities(exp(1 / x), x, S.Reals) == FiniteSet(0)
assert singularities(exp(1 / x), x, Interval(1, 2)) == S.EmptySet
assert singularities(log((x - 2)**2), x, Interval(1, 3)) == FiniteSet(2)
raises(NotImplementedError, lambda: singularities(x**-oo, x))
def check_singularity(self):
function = self.f
# continous=continuous_domain(function, x, S.Reals)
holeset = singularities(function, x)
intervalset = Interval(Float(self.interval.split()[0]),
Float(self.interval.split()[1]))
intersection = holeset.intersect(intervalset)
return intersection
def _eval_imageset(self, f):
from sympy.functions.elementary.miscellaneous import Min, Max
from sympy.solvers import solve
from sympy.core.function import diff
from sympy.series import limit
from sympy.calculus.singularities import singularities
# TODO: handle piecewise defined functions
# TODO: handle functions with infinitely many solutions (eg, sin, tan)
# TODO: handle multivariate functions
expr = f.expr
if len(expr.free_symbols) > 1 or len(f.variables) != 1:
return
var = f.variables[0]
if not self.start.is_comparable or not self.end.is_comparable:
return
try:
sing = [x for x in singularities(expr, var) if x.is_real and x in self]
except NotImplementedError:
return
if self.left_open:
_start = limit(expr, var, self.start, dir="+")
elif self.start not in sing:
_start = f(self.start)
if self.right_open:
_end = limit(expr, var, self.end, dir="-")
elif self.end not in sing:
_end = f(self.end)
if len(sing) == 0:
solns = solve(diff(expr, var), var)
extr = [_start, _end] + [f(x) for x in solns
if x.is_real and x in self]
start, end = Min(*extr), Max(*extr)
left_open, right_open = False, False
if _start <= _end:
# the minimum or maximum value can occur simultaneously
# on both the edge of the interval and in some interior
# point
if start == _start and start not in solns:
left_open = self.left_open
if end == _end and end not in solns:
right_open = self.right_open
else:
if start == _end and start not in solns:
left_open = self.right_open
if end == _start and end not in solns:
right_open = self.left_open
return Interval(start, end, left_open, right_open)
else:
return imageset(f, Interval(self.start, sing[0],
self.left_open, True)) + \
Union(*[imageset(f, Interval(sing[i], sing[i + 1]), True, True)
for i in range(1, len(sing) - 1)]) + \
imageset(f, Interval(sing[-1], self.end, True, self.right_open))
def _set_function(f, x):
from sympy.functions.elementary.miscellaneous import Min, Max
from sympy.solvers.solveset import solveset
from sympy.core.function import diff, Lambda
from sympy.series import limit
from sympy.calculus.singularities import singularities
from sympy.sets import Complement
# TODO: handle functions with infinitely many solutions (eg, sin, tan)
# TODO: handle multivariate functions
expr = f.expr
if len(expr.free_symbols) > 1 or len(f.variables) != 1:
return
var = f.variables[0]
if expr.is_Piecewise:
result = S.EmptySet
domain_set = x
for (p_expr, p_cond) in expr.args:
if p_cond is true:
intrvl = domain_set
else:
intrvl = p_cond.as_set()
intrvl = Intersection(domain_set, intrvl)
if p_expr.is_Number:
image = FiniteSet(p_expr)
else:
image = imageset(Lambda(var, p_expr), intrvl)
result = Union(result, image)
# remove the part which has been `imaged`
domain_set = Complement(domain_set, intrvl)
if domain_set.is_EmptySet:
break
return result
if not x.start.is_comparable or not x.end.is_comparable:
return
try:
sing = [i for i in singularities(expr, var)
if i.is_real and i in x]
except NotImplementedError:
return
if x.left_open:
_start = limit(expr, var, x.start, dir="+")
elif x.start not in sing:
_start = f(x.start)
if x.right_open:
_end = limit(expr, var, x.end, dir="-")
elif x.end not in sing:
_end = f(x.end)
if len(sing) == 0:
solns = list(solveset(diff(expr, var), var))
extr = [_start, _end] + [f(i) for i in solns
if i.is_real and i in x]
start, end = Min(*extr), Max(*extr)
left_open, right_open = False, False
if _start <= _end:
# the minimum or maximum value can occur simultaneously
# on both the edge of the interval and in some interior
# point
if start == _start and start not in solns:
left_open = x.left_open
if end == _end and end not in solns:
right_open = x.right_open
else:
if start == _end and start not in solns:
left_open = x.right_open
if end == _start and end not in solns:
right_open = x.left_open
return Interval(start, end, left_open, right_open)
else:
return imageset(f, Interval(x.start, sing[0],
x.left_open, True)) + \
Union(*[imageset(f, Interval(sing[i], sing[i + 1], True, True))
for i in range(0, len(sing) - 1)]) + \
imageset(f, Interval(sing[-1], x.end, True, x.right_open))
def _eval_imageset(self, f):
from sympy.functions.elementary.miscellaneous import Min, Max
from sympy.solvers import solve
from sympy.core.function import diff
from sympy.series import limit
from sympy.calculus.singularities import singularities
# TODO: handle piecewise defined functions
# TODO: handle functions with infinitely many solutions (eg, sin, tan)
# TODO: handle multivariate functions
expr = f.expr
if len(expr.free_symbols) > 1 or len(f.variables) != 1:
return
var = f.variables[0]
if not self.start.is_comparable or not self.end.is_comparable:
return
try:
sing = [
x for x in singularities(expr, var) if x.is_real and x in self
]
except NotImplementedError:
return
if self.left_open:
_start = limit(expr, var, self.start, dir="+")
elif self.start not in sing:
_start = f(self.start)
if self.right_open:
_end = limit(expr, var, self.end, dir="-")
elif self.end not in sing:
_end = f(self.end)
if len(sing) == 0:
solns = solve(diff(expr, var), var)
extr = [_start, _end
] + [f(x) for x in solns if x.is_real and x in self]
start, end = Min(*extr), Max(*extr)
left_open, right_open = False, False
if _start <= _end:
# the minimum or maximum value can occur simultaneously
# on both the edge of the interval and in some interior
# point
if start == _start and start not in solns:
left_open = self.left_open
if end == _end and end not in solns:
right_open = self.right_open
else:
if start == _end and start not in solns:
left_open = self.right_open
if end == _start and end not in solns:
right_open = self.left_open
return Interval(start, end, left_open, right_open)
else:
return imageset(f, Interval(self.start, sing[0],
self.left_open, True)) + \
Union(*[imageset(f, Interval(sing[i], sing[i + 1]), True, True)
for i in range(1, len(sing) - 1)]) + \
imageset(f, Interval(sing[-1], self.end, True, self.right_open))
def test_singularities_non_rational():
x = Symbol('x', real=True)
assert singularities(exp(1 / x), x) == FiniteSet(0)
assert singularities(log((x - 2)**2), x) == FiniteSet(2)
def _set_function(f, x):
from sympy.functions.elementary.miscellaneous import Min, Max
from sympy.solvers.solveset import solveset
from sympy.core.function import diff, Lambda
from sympy.series import limit
from sympy.calculus.singularities import singularities
from sympy.sets import Complement
# TODO: handle functions with infinitely many solutions (eg, sin, tan)
# TODO: handle multivariate functions
expr = f.expr
if len(expr.free_symbols) > 1 or len(f.variables) != 1:
return
var = f.variables[0]
if expr.is_Piecewise:
result = S.EmptySet
domain_set = x
for (p_expr, p_cond) in expr.args:
if p_cond is true:
intrvl = domain_set
else:
intrvl = p_cond.as_set()
intrvl = Intersection(domain_set, intrvl)
if p_expr.is_Number:
image = FiniteSet(p_expr)
else:
image = imageset(Lambda(var, p_expr), intrvl)
result = Union(result, image)
# remove the part which has been `imaged`
domain_set = Complement(domain_set, intrvl)
if domain_set.is_EmptySet:
break
return result
if not x.start.is_comparable or not x.end.is_comparable:
return
try:
sing = [i for i in singularities(expr, var)
if i.is_real and i in x]
except NotImplementedError:
return
if x.left_open:
_start = limit(expr, var, x.start, dir="+")
elif x.start not in sing:
_start = f(x.start)
if x.right_open:
_end = limit(expr, var, x.end, dir="-")
elif x.end not in sing:
_end = f(x.end)
if len(sing) == 0:
solns = list(solveset(diff(expr, var), var))
extr = [_start, _end] + [f(i) for i in solns
if i.is_real and i in x]
start, end = Min(*extr), Max(*extr)
left_open, right_open = False, False
if _start <= _end:
# the minimum or maximum value can occur simultaneously
# on both the edge of the interval and in some interior
# point
if start == _start and start not in solns:
left_open = x.left_open
if end == _end and end not in solns:
right_open = x.right_open
else:
if start == _end and start not in solns:
left_open = x.right_open
if end == _start and end not in solns:
right_open = x.left_open
return Interval(start, end, left_open, right_open)
else:
return imageset(f, Interval(x.start, sing[0],
x.left_open, True)) + \
Union(*[imageset(f, Interval(sing[i], sing[i + 1], True, True))
for i in range(0, len(sing) - 1)]) + \
imageset(f, Interval(sing[-1], x.end, True, x.right_open))
def test_singularities():
x = Symbol('x', real=True)
assert singularities(x**2, x) == ()
assert singularities(x/(x**2 + 3*x + 2), x) == (-2, -1)
def test_singularities_non_rational():
x = Symbol('x', real=True)
assert singularities(exp(1/x), x) == (0)
assert singularities(log((x - 2)**2), x) == (2)
def check_constraints(model,
constraints,
intervals,
characteristic_vals=None,
verbose=0):
"""WIP function for Tc project.
UseS Sympy to check for singularities and other limits."""
intervals = dict(intervals)
feature_set = list(constraints.keys())
if characteristic_vals is None:
characteristic_vals = {
feature: i / 10
for i, feature in enumerate(feature_set)
}
for feature in feature_set:
if feature not in intervals.keys():
intervals[feature] = sympy.Reals
continue
interval_min, interval_max = intervals[feature]
if interval_min == "-oo" or interval_min == -np.inf:
interval_min = -oo
elif interval_max == "oo" or interval_max == np.inf:
interval_max = oo
interval = Interval(interval_min, interval_max)
intervals[feature] = interval
symbol_dict = {
k: v
for k, v in zip(
feature_set,
sympy.symbols(
feature_set, positive=True, finite=True, infinite=False))
}
expr = parse_expr(model.replace('^', '**'), local_dict=symbol_dict)
passed = True
checks = {k: {} for k in constraints.keys()}
for feature, symbol in symbol_dict.items():
symbol_set = list(symbol_dict.values())
variable = symbol_set.pop(symbol_set.index(symbol))
interval = intervals[feature]
univariate_expr = expr.subs([(symbol, characteristic_vals[str(symbol)])
for symbol in symbol_set])
if verbose > 1:
print(univariate_expr)
if constraints[feature].get('increasing', None) is not None:
try:
increasing = is_increasing(univariate_expr, interval=interval)
except TypeError:
increasing = False
if increasing is None: # bug?
increasing = False
checks[feature]['increasing'] = increasing
if increasing != constraints[feature]['increasing']:
passed = False
if constraints[feature].get('decreasing', None) is not None:
try:
decreasing = is_decreasing(univariate_expr, interval=interval)
except TypeError:
decreasing = False
if decreasing is None: # bug?
decreasing = False
checks[feature]['decreasing'] = decreasing
if decreasing != constraints[feature]['decreasing']:
passed = False
if constraints[feature].get('monotonic', None) is not None:
try:
monotonic = is_monotonic(univariate_expr, interval=interval)
except TypeError:
monotonic = False
checks[feature]['monotonic'] = monotonic
if monotonic != constraints[feature]['monotonic']:
passed = False
if constraints[feature].get('singularities', None) is not None:
try:
singularity_set = singularities(expr,
variable,
domain=interval)
except TypeError:
singularity_set = sympy.EmptySet
checks[feature]['singularities'] = singularity_set
# has_singularities = singularity_set is not sympy.EmptySet
if singularity_set != constraints[feature]['singularities']:
passed = False
if constraints[feature].get('zero limit', None) is not None:
try:
zero_limit = sympy.limit(expr, variable, 0)
except TypeError:
zero_limit = None
checks[feature]['zero limit'] = zero_limit
if zero_limit != constraints[feature]['zero limit']:
passed = False
if verbose == 0:
return passed
else:
return checks, passed
def _eval_imageset(self, f):
from sympy import Dummy
from sympy.functions.elementary.miscellaneous import Min, Max
from sympy.solvers import solve
from sympy.core.function import diff
from sympy.series import limit
from sympy.calculus.singularities import singularities
# TODO: handle piecewise defined functions
# TODO: handle functions with infinitely many solutions (eg, sin, tan)
# TODO: handle multivariate functions
# var and expr are being defined this way to
# support Python lambda and not just sympy Lambda
try:
var = Dummy()
expr = f(var)
if len(expr.free_symbols) > 1:
raise TypeError
except TypeError:
raise NotImplementedError("Sorry, Multivariate imagesets are"
" not yet implemented, you are welcome"
" to add this feature in Sympy")
if not self.start.is_comparable or not self.end.is_comparable:
raise NotImplementedError("Sets with non comparable/variable"
" arguments are not supported")
sing = [x for x in singularities(expr, var) if x.is_real and x in self]
if self.left_open:
_start = limit(expr, var, self.start, dir="+")
elif self.start not in sing:
_start = f(self.start)
if self.right_open:
_end = limit(expr, var, self.end, dir="-")
elif self.end not in sing:
_end = f(self.end)
if len(sing) == 0:
solns = solve(diff(expr, var), var)
extr = [_start, _end] + [f(x) for x in solns
if x.is_real and x in self]
start, end = Min(*extr), Max(*extr)
left_open, right_open = False, False
if _start <= _end:
# the minimum or maximum value can occur simultaneously
# on both the edge of the interval and in some interior
# point
if start == _start and start not in solns:
left_open = self.left_open
if end == _end and end not in solns:
right_open = self.right_open
else:
if start == _end and start not in solns:
left_open = self.right_open
if end == _start and end not in solns:
right_open = self.left_open
return Interval(start, end, left_open, right_open)
else:
return imageset(f, Interval(self.start, sing[0],
self.left_open, True)) + \
Union(*[imageset(f, Interval(sing[i], sing[i + 1]), True, True)
for i in range(1, len(sing) - 1)]) + \
imageset(f, Interval(sing[-1], self.end, True, self.right_open))
def test_singularities():
x = Symbol('x', real=True)
assert singularities(x**2, x) == ()
assert singularities(x / (x**2 + 3 * x + 2), x) == (-2, -1)
def _eval_imageset(self, f):
from sympy import Dummy
from sympy.functions.elementary.miscellaneous import Min, Max
from sympy.solvers import solve
from sympy.core.function import diff
from sympy.series import limit
from sympy.calculus.singularities import singularities
# TODO: handle piecewise defined functions
# TODO: handle functions with infinitely many solutions (eg, sin, tan)
# TODO: handle multivariate functions
# var and expr are being defined this way to
# support Python lambda and not just sympy Lambda
try:
var = Dummy()
expr = f(var)
if len(expr.free_symbols) > 1:
raise TypeError
except TypeError:
raise NotImplementedError("Sorry, Multivariate imagesets are"
" not yet implemented, you are welcome"
" to add this feature in Sympy")
if not self.start.is_comparable or not self.end.is_comparable:
raise NotImplementedError("Sets with non comparable/variable"
" arguments are not supported")
sing = [x for x in singularities(expr, var) if x.is_real and x in self]
if self.left_open:
_start = limit(expr, var, self.start, dir="+")
elif self.start not in sing:
_start = f(self.start)
if self.right_open:
_end = limit(expr, var, self.end, dir="-")
elif self.end not in sing:
_end = f(self.end)
if len(sing) == 0:
solns = solve(diff(expr, var), var)
extr = [_start, _end
] + [f(x) for x in solns if x.is_real and x in self]
start, end = Min(*extr), Max(*extr)
left_open, right_open = False, False
if _start <= _end:
# the minimum or maximum value can occur simultaneously
# on both the edge of the interval and in some interior
# point
if start == _start and start not in solns:
left_open = self.left_open
if end == _end and end not in solns:
right_open = self.right_open
else:
if start == _end and start not in solns:
left_open = self.right_open
if end == _start and end not in solns:
right_open = self.left_open
return Interval(start, end, left_open, right_open)
else:
return imageset(f, Interval(self.start, sing[0],
self.left_open, True)) + \
Union(*[imageset(f, Interval(sing[i], sing[i + 1]), True, True)
for i in range(1, len(sing) - 1)]) + \
imageset(f, Interval(sing[-1], self.end, True, self.right_open))
def find_vertical_asymptote(self):
for non_definition in singularities(self.function, x).args:
if limit(self.function, x, non_definition) in [oo, -oo]:
self.vertical_asymptote.append(non_definition)
else:
self.domain.append(u'X\u2260'+str(non_definition))
