def test_not_empty_in(): assert not_empty_in(FiniteSet(x, 2*x).intersect(Interval(1, 2, True, False)), x) == \ Interval(S.Half, 2, True, False) assert not_empty_in(FiniteSet(x, x**2).intersect(Interval(1, 2)), x) == \ Union(Interval(-sqrt(2), -1), Interval(1, 2)) assert not_empty_in(FiniteSet(x**2 + x, x).intersect(Interval(2, 4)), x) == \ Union(Interval(-sqrt(17)/2 - S.Half, -2), Interval(1, Rational(-1, 2) + sqrt(17)/2), Interval(2, 4)) assert not_empty_in(FiniteSet(x/(x - 1)).intersect(S.Reals), x) == \ Complement(S.Reals, FiniteSet(1)) assert not_empty_in(FiniteSet(a/(a - 1)).intersect(S.Reals), a) == \ Complement(S.Reals, FiniteSet(1)) assert not_empty_in(FiniteSet((x**2 - 3*x + 2)/(x - 1)).intersect(S.Reals), x) == \ Complement(S.Reals, FiniteSet(1)) assert not_empty_in(FiniteSet(3, 4, x/(x - 1)).intersect(Interval(2, 3)), x) == \ Interval(-oo, oo) assert not_empty_in(FiniteSet(4, x/(x - 1)).intersect(Interval(2, 3)), x) == \ Interval(S(3)/2, 2) assert not_empty_in(FiniteSet(x/(x**2 - 1)).intersect(S.Reals), x) == \ Complement(S.Reals, FiniteSet(-1, 1)) assert not_empty_in(FiniteSet(x, x**2).intersect(Union(Interval(1, 3, True, True), Interval(4, 5))), x) == \ Union(Interval(-sqrt(5), -2), Interval(-sqrt(3), -1, True, True), Interval(1, 3, True, True), Interval(4, 5)) assert not_empty_in(FiniteSet(1).intersect(Interval(3, 4)), x) == S.EmptySet assert not_empty_in(FiniteSet(x**2/(x + 2)).intersect(Interval(1, oo)), x) == \ Union(Interval(-2, -1, True, False), Interval(2, oo)) raises(ValueError, lambda: not_empty_in(x)) raises(ValueError, lambda: not_empty_in(Interval(0, 1), x)) raises(NotImplementedError, lambda: not_empty_in(FiniteSet(x).intersect(S.Reals), x, a))
def test_not_empty_in(): assert not_empty_in(FiniteSet(x, 2*x).intersect(Interval(1, 2, True, False)), x) == \ Interval(S(1)/2, 2, True, False) assert not_empty_in(FiniteSet(x, x**2).intersect(Interval(1, 2)), x) == \ Union(Interval(-sqrt(2), -1), Interval(1, 2)) assert not_empty_in(FiniteSet(x**2 + x, x).intersect(Interval(2, 4)), x) == \ Union(Interval(-sqrt(17)/2 - S(1)/2, -2), Interval(1, -S(1)/2 + sqrt(17)/2), Interval(2, 4)) assert not_empty_in(FiniteSet(x/(x - 1)).intersect(S.Reals), x) == \ Complement(S.Reals, FiniteSet(1)) assert not_empty_in(FiniteSet(a/(a - 1)).intersect(S.Reals), a) == \ Complement(S.Reals, FiniteSet(1)) assert not_empty_in(FiniteSet((x**2 - 3*x + 2)/(x - 1)).intersect(S.Reals), x) == \ Complement(S.Reals, FiniteSet(1)) assert not_empty_in(FiniteSet(3, 4, x/(x - 1)).intersect(Interval(2, 3)), x) == \ Union(Interval(S(3)/2, 2), FiniteSet(3)) assert not_empty_in(FiniteSet(x/(x**2 - 1)).intersect(S.Reals), x) == \ Complement(S.Reals, FiniteSet(-1, 1)) assert not_empty_in(FiniteSet(x, x**2).intersect(Union(Interval(1, 3, True, True), Interval(4, 5))), x) == \ Union(Interval(-sqrt(5), -2), Interval(-sqrt(3), -1, True, True), Interval(1, 3, True, True), Interval(4, 5)) assert not_empty_in(FiniteSet(1).intersect(Interval(3, 4)), x) == S.EmptySet assert not_empty_in(FiniteSet(x**2/(x + 2)).intersect(Interval(1, oo)), x) == \ Union(Interval(-2, -1, True, False), Interval(2, oo))
def test_issue_20291(): from sympy.sets import EmptySet, Reals from sympy.sets.sets import (Complement, FiniteSet, Intersection) a = Symbol('a') b = Symbol('b') A = FiniteSet(a, b) assert A.evalf(subs={a: 1, b: 2}) == FiniteSet(1.0, 2.0) B = FiniteSet(a - b, 1) assert B.evalf(subs={a: 1, b: 2}) == FiniteSet(-1.0, 1.0) sol = Complement( Intersection(FiniteSet(-b / 2 - sqrt(b**2 - 4 * pi) / 2), Reals), FiniteSet(0)) assert sol.evalf(subs={b: 1}) == EmptySet
def elm_domain(expr, intrvl): """ Finds the domain of an expression in any given interval """ from sympy.solvers.solveset import solveset _start = intrvl.start _end = intrvl.end _singularities = solveset(expr.as_numer_denom()[1], symb, domain=S.Reals) if intrvl.right_open: if _end is S.Infinity: _domain1 = S.Reals else: _domain1 = solveset(expr < _end, symb, domain=S.Reals) else: _domain1 = solveset(expr <= _end, symb, domain=S.Reals) if intrvl.left_open: if _start is S.NegativeInfinity: _domain2 = S.Reals else: _domain2 = solveset(expr > _start, symb, domain=S.Reals) else: _domain2 = solveset(expr >= _start, symb, domain=S.Reals) # domain in the interval expr_with_sing = Intersection(_domain1, _domain2) expr_domain = Complement(expr_with_sing, _singularities) return expr_domain
def complement(self, other): if isinstance(other, AtEmptySet): return AtEmptySet() elif isinstance(other, AtUnivSet): return AtSymSet( FiniteSet(*list(self.at_set)).complement(UniversalSet())) elif isinstance(other, AtSymSet): # return convert(AtSymSet(FiniteSet(*list(self.at_set)) # .complement(other.at_set))) # return convert(AtSymSet(Complement(FiniteSet(*list(self.at_set)), # other.at_set, # evaluate=True)) ) return convert( AtSymSet( Complement(other.at_set, FiniteSet(*list(self.at_set)), evaluate=True))) elif isinstance(other, AtFinSet): return convert(AtFinSet(other.at_set - self.at_set)) # elif isinstance(other, AtPosStringSet): # return copy.deepcopy(other) # elif isinstance(other, AtNegStringSet): # return copy.deepcopy(other) else: raise AtSetError( "Finite Numerical set cannot complement with type {}".format( type(other)))
def test_print_SetOp(): f1 = FiniteSet(x, 1, 3) f2 = FiniteSet(y, 2, 4) assert mpp.doprint(Union(f1, f2, evaluate=False)) == '<mrow><mfenced close="}" open="{"><mn>1</mn><mn>3</mn><mi>x</mi></mfenced><mo>∪</mo><mfenced close="}" open="{"><mn>2</mn><mn>4</mn><mi>y</mi></mfenced></mrow>' assert mpp.doprint(Intersection(f1, f2, evaluate=False)) == '<mrow><mfenced close="}" open="{"><mn>1</mn><mn>3</mn><mi>x</mi></mfenced><mo>∩</mo><mfenced close="}" open="{"><mn>2</mn><mn>4</mn><mi>y</mi></mfenced></mrow>' assert mpp.doprint(Complement(f1, f2, evaluate=False)) == '<mrow><mfenced close="}" open="{"><mn>1</mn><mn>3</mn><mi>x</mi></mfenced><mo>∖</mo><mfenced close="}" open="{"><mn>2</mn><mn>4</mn><mi>y</mi></mfenced></mrow>' assert mpp.doprint(SymmetricDifference(f1, f2, evaluate=False)) == '<mrow><mfenced close="}" open="{"><mn>1</mn><mn>3</mn><mi>x</mi></mfenced><mo>∆</mo><mfenced close="}" open="{"><mn>2</mn><mn>4</mn><mi>y</mi></mfenced></mrow>'
def reduce_union(sets): """sympy.set does not reduce complements in a union""" if isinstance(sets, Union): new_args = [] for sset in sets._args: if not sset.is_Complement: new_args.append(sset) if sset.is_Complement: if len(sset.args) != 2: raise ReGraphError("complement without 2 args") other_sets = [s for s in sets._args if s != sset] new_sset = Complement(sset.args[0], Complement(sset.args[1], *other_sets, evaluate=True), evaluate=True) new_args.append(new_sset) return Union(*new_args, evaluate=True) else: return sets
def test_imageset_intersect_real(): from sympy import I from sympy.abc import n assert imageset(Lambda(n, n + (n - 1) * (n + 1) * I), S.Integers).intersect(S.Reals) == Complement( S.Integers, FiniteSet((-1, 1))) s = ImageSet( Lambda(n, -I * (I * (2 * pi * n - pi / 4) + log(Abs(sqrt(-I))))), S.Integers) # s is unevaluated, but after intersection the result # should be canonical assert s.intersect(S.Reals) == imageset(Lambda( n, 2 * n * pi - pi / 4), S.Integers) == ImageSet( Lambda(n, 2 * pi * n + pi * Rational(7, 4)), S.Integers)
def test_codomain(): x = Symbol('x', real=True) assert codomain(x, Interval(-1, 1), x) == Interval(-1, 1) assert codomain(x, Interval(0, 1, True, True), x) == \ Interval(0, 1, True, True) assert codomain(x, Interval(1, 2, True, False), x) == Interval(1, 2, True, False) assert codomain(x, Interval(1, 2, False, True), x) == Interval(1, 2, False, True) assert codomain(x**2, Interval(-1, 1), x) == Interval(0, 1) assert codomain(x**3, Interval(0, 1), x) == Interval(0, 1) assert codomain(x/(x**2 - 4), Interval(3, 4), x) == Interval(S(1)/3, S(3)/5) assert codomain(1, Interval(-1, 4), x) == FiniteSet(1) assert codomain(x, Interval(-oo, oo), x) == S.Reals assert codomain(1/x**2, FiniteSet(1, 2, -1, 0), x) == FiniteSet(1, S(1)/4) assert codomain(x, FiniteSet(1, -1, 3, 5), x) == FiniteSet(-1, 1, 3, 5) assert codomain(x**2 - x, FiniteSet(1, -1, 3, 5, -oo), x) == \ FiniteSet(0, 2, 6, 20, oo) assert codomain(x**2/(x - 4), FiniteSet(4), x) == S.EmptySet assert codomain(x**2 - x, FiniteSet(S(1)/2, -oo, oo, 2), x) == \ FiniteSet(S(-1)/4, 2, oo) assert codomain(x**2, Interval(-1, 1, True, True), x) == Interval(0, 1, False, True) assert codomain(x**2, Interval(-1, 1, False, True), x) == Interval(0, 1) assert codomain(x**2, Interval(-1, 1, True, False), x) == Interval(0, 1) assert codomain(1/x, Interval(0, 1), x) == Interval(1, oo) assert codomain(1/x, Interval(-1, 1), x) == Union(Interval(-oo, -1), Interval(1, oo)) assert codomain(1/x**2, Interval(-1, 1), x) == Interval(1, oo) assert codomain(1/x**2, Interval(-1, 1, True, False), x) == Interval(1, oo) assert codomain(1/x**2, Interval(-1, 1, True, True), x) == \ Interval(1, oo, True, True) assert codomain(1/x**2, Interval(-1, 1, False, True), x) == Interval(1, oo) assert codomain(1/x, Interval(1, 2), x) == Interval(S(1)/2, 1) assert codomain(1/x**2, Interval(-2, -1, True, True), x) == \ Interval(S(1)/4, 1, True, True) assert codomain(x**2/(x - 4), Interval(-oo, oo), x) == \ Complement(S.Reals, Interval(0, 16, True, True)) assert codomain(x**2/(x - 4), Interval(3, 4), x) == Interval(-oo, -9) assert codomain(-x**2/(x - 4), Interval(3, 4), x) == Interval(9, oo) assert codomain((x**2 - x)/(x**3 - 1), S.Reals, x) == Interval(-1, S(1)/3, False, True) assert codomain(-x**2 + 1/x, S.Reals, x) == S.Reals assert codomain(x**2 - 1/x, S.Reals, x) == S.Reals assert codomain(x**2, Union(Interval(1, 2), FiniteSet(3)), x) == \ Union(Interval(1, 4), FiniteSet(9)) assert codomain(x/(x**2 - 4), Union(Interval(-oo, 1), Interval(0, oo)), x) == S.Reals assert codomain(x, Union(Interval(-1, 1), FiniteSet(-oo)), x) == \ Union(Interval(-1, 1), FiniteSet(-oo)) assert codomain(x**2 - x, Interval(1, oo), x) == Interval(0, oo) raises(ValueError, lambda: codomain(sqrt(x), Interval(-1, 2), x))
def __new__(cls, *args, **kwargs): c = Complement(*args, **kwargs) return Group(*c.args)
def test_Complement(): assert str(Complement(S.Reals, S.Naturals)) == 'Complement(Reals, Naturals)'
def codomain(func, domain, *syms): """ Finds the range of a real-valued function, for a real-domain Parameters ========== func: Expr The expression whose range is to be found domain: Union of Sets The real-domain for the variable involved in function syms: Tuple of symbols Symbol whose domain is given Raises ====== NotImplementedError The algorithms to find the range of the given function are not yet implemented. ValueError The input is not valid. RuntimeError It is a bug, please report it to the github issue tracker (https://github.com/sympy/sympy/issues). Examples ======== >>> from sympy import Symbol, S, Interval, Union, FiniteSet, codomain >>> x = Symbol('x', real=True) >>> codomain(x**2, Interval(-1, 1), x) [0, 1] >>> codomain(x/(x**2 - 4), Union(Interval(-1, 3), FiniteSet(5)), x) (-oo, 1/3] U [3/5, oo) >>> codomain(x**2/(x**2 - 4), S.Reals, x) (-oo, 0] U (1, oo) """ func = sympify(func) if not isinstance(domain, Set): raise ValueError('A Set must be given, not %s: %s' % (type(domain), domain)) # TODO: handle piecewise defined functions # TODO: handle transcendental functions # TODO: handle multivariate functions if len(syms) == 0: raise ValueError("A Symbol or a tuple of symbols must be given") if len(syms) == 1: sym = syms[0] else: raise NotImplementedError("more than one variables %s not handled" % (syms, )) if not func.has(sym): return FiniteSet(func) # this block of code can be replaced by # sing = Intersection(FiniteSet(*sing), domain.closure) # after the issue #9706 has been fixed def closure_handle(set_im, singul): if set_im.has(Interval): if not oo in set_im.boundary: if not S.NegativeInfinity in set_im.boundary: return Intersection(FiniteSet(*singul), set_im.closure) return Intersection( FiniteSet(*singul), Union(set_im, FiniteSet(max(set_im.boundary)))) else: if not S.NegativeInfinity in set_im.boundary: return Intersection( FiniteSet(*singul), Union(set_im, FiniteSet(min(set_im.boundary)))) return Intersection(FiniteSet(*singul), set_im) return Intersection(FiniteSet(*singul), set_im) # all the singularities of the function sing = solveset(func.as_numer_denom()[1], sym, domain=S.Reals) sing_in_domain = closure_handle(domain, sing) domain = Complement(domain, sing_in_domain) if domain.is_EmptySet: return EmptySet() def codomain_interval(f, set_val, *sym): symb = sym[0] df1 = diff(f, symb) df2 = diff(df1, symb) der_zero = solveset(df1, symb, domain=S.Reals) der_zero_in_dom = closure_handle(set_val, der_zero) local_maxima = set() local_minima = set() start_val = limit(f, symb, set_val.start) end_val = limit(f, symb, set_val.end, '-') if start_val is S.Infinity or end_val is S.Infinity: local_maxima = set([(oo, True)]) elif start_val is S.NegativeInfinity or end_val is S.NegativeInfinity: local_minima = set([(-oo, True)]) if (not start_val.is_real) or (not end_val.is_real): raise ValueError('Function does not contain all points of %s ' 'as its domain' % (domain)) if local_maxima == set(): if start_val > end_val: local_maxima = set([(start_val, set_val.left_open)]) elif start_val < end_val: local_maxima = set([(end_val, set_val.right_open)]) else: local_maxima = set([(start_val, set_val.left_open and set_val.right_open)]) if local_minima == set(): if start_val < end_val: local_minima = set([(start_val, set_val.left_open)]) elif start_val > end_val: local_minima = set([(end_val, set_val.right_open)]) else: local_minima = set([(start_val, set_val.left_open and set_val.right_open)]) for i in der_zero_in_dom: exist = not i in set_val if df2.subs({symb: i}) < 0: local_maxima.add((f.subs({symb: i}), exist)) elif df2.subs({symb: i}) > 0: local_minima.add((f.subs({symb: i}), exist)) maximum = (-oo, True) minimum = (oo, True) for i in local_maxima: if i[0] > maximum[0]: maximum = i elif i[0] == maximum[0]: maximum = (maximum[0], i[1] and maximum[1]) for i in local_minima: if i[0] < minimum[0]: minimum = i elif i[0] == minimum[0]: minimum = (minimum[0], i[1] and minimum[1]) return Union(Interval(minimum[0], maximum[0], minimum[1], maximum[1])) if isinstance(domain, Union): return Union(*[ codomain(func, intrvl_or_finset, sym) for intrvl_or_finset in domain.args ]) if isinstance(domain, Interval): return codomain_interval(func, domain, sym) if isinstance(domain, FiniteSet): return FiniteSet(*[ limit(func, sym, i) if i in FiniteSet(-oo, oo) else func.subs({sym: i}) for i in domain ])
def _regular_point_ellipse(self, a, b, c, d, e, f): D = 4*a*c - b**2 ok = D if not ok: raise ValueError("Rational Point on the conic does not exist") if a == 0 and c == 0: K = -1 L = 4*(d*e - b*f) elif c != 0: K = D L = 4*c**2*d**2 - 4*b*c*d*e + 4*a*c*e**2 + 4*b**2*c*f - 16*a*c**2*f else: K = D L = 4*a**2*e**2 - 4*b*a*d*e + 4*b**2*a*f ok = L != 0 and not(K > 0 and L < 0) if not ok: raise ValueError("Rational Point on the conic does not exist") K = Rational(K).limit_denominator(10**12) L = Rational(L).limit_denominator(10**12) k1, k2 = K.p, K.q l1, l2 = L.p, L.q g = gcd(k2, l2) a1 = (l2*k2)/g b1 = (k1*l2)/g c1 = -(l1*k2)/g a2 = sign(a1)*core(abs(a1), 2) r1 = sqrt(a1/a2) b2 = sign(b1)*core(abs(b1), 2) r2 = sqrt(b1/b2) c2 = sign(c1)*core(abs(c1), 2) r3 = sqrt(c1/c2) g = gcd(gcd(a2, b2), c2) a2 = a2/g b2 = b2/g c2 = c2/g g1 = gcd(a2, b2) a2 = a2/g1 b2 = b2/g1 c2 = c2*g1 g2 = gcd(a2,c2) a2 = a2/g2 b2 = b2*g2 c2 = c2/g2 g3 = gcd(b2, c2) a2 = a2*g3 b2 = b2/g3 c2 = c2/g3 x, y, z = symbols("x y z") eq = a2*x**2 + b2*y**2 + c2*z**2 solutions = diophantine(eq) if len(solutions) == 0: raise ValueError("Rational Point on the conic does not exist") flag = False for sol in solutions: syms = Tuple(*sol).free_symbols rep = {s: 3 for s in syms} sol_z = sol[2] if sol_z == 0: flag = True continue if not isinstance(sol_z, (int, Integer)): syms_z = sol_z.free_symbols if len(syms_z) == 1: p = next(iter(syms_z)) p_values = Complement(S.Integers, solveset(Eq(sol_z, 0), p, S.Integers)) rep[p] = next(iter(p_values)) if len(syms_z) == 2: p, q = list(ordered(syms_z)) for i in S.Integers: subs_sol_z = sol_z.subs(p, i) q_values = Complement(S.Integers, solveset(Eq(subs_sol_z, 0), q, S.Integers)) if not q_values.is_empty: rep[p] = i rep[q] = next(iter(q_values)) break if len(syms) != 0: x, y, z = tuple(s.subs(rep) for s in sol) else: x, y, z = sol flag = False break if flag: raise ValueError("Rational Point on the conic does not exist") x = (x*g3)/r1 y = (y*g2)/r2 z = (z*g1)/r3 x = x/z y = y/z if a == 0 and c == 0: x_reg = (x + y - 2*e)/(2*b) y_reg = (x - y - 2*d)/(2*b) elif c != 0: x_reg = (x - 2*d*c + b*e)/K y_reg = (y - b*x_reg - e)/(2*c) else: y_reg = (x - 2*e*a + b*d)/K x_reg = (y - b*y_reg - d)/(2*a) return x_reg, y_reg