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 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))