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
