def test_intersection():
# iterable
i = Intersection(FiniteSet(1, 2, 3), Interval(2, 5), evaluate=False)
assert i.is_iterable
assert set(i) == {S(2), S(3)}
# challenging intervals
x = Symbol('x', real=True)
i = Intersection(Interval(0, 3), Interval(x, 6))
assert (5 in i) is False
raises(TypeError, lambda: 2 in i)
# Singleton special cases
assert Intersection(Interval(0, 1), S.EmptySet) == S.EmptySet
assert Intersection(Interval(-oo, oo), Interval(-oo,
x)) == Interval(-oo, x)
# Products
line = Interval(0, 5)
i = Intersection(line**2, line**3, evaluate=False)
assert (2, 2) not in i
assert (2, 2, 2) not in i
raises(ValueError, lambda: list(i))
assert Intersection(Intersection(S.Integers, S.Naturals, evaluate=False),
S.Reals, evaluate=False) == \
Intersection(S.Integers, S.Naturals, S.Reals, evaluate=False)
assert Intersection(S.Complexes,
FiniteSet(S.ComplexInfinity)) == S.EmptySet
# issue 12178
assert Intersection() == S.UniversalSet
def test_issue_9623():
n = Symbol('n')
a = S.Reals
b = Interval(0, oo)
c = FiniteSet(n)
assert Intersection(a, b, c) == Intersection(b, c)
assert Intersection(Interval(1, 2), Interval(3, 4), FiniteSet(n)) == EmptySet()
def test_issue_11174():
r, t = symbols('r t')
eq = z**2 + exp(2 * x) - sin(y)
soln = Intersection(S.Reals, FiniteSet(log(-z**2 + sin(y)) / 2))
assert solveset(eq, x, S.Reals) == soln
eq = sqrt(r) * Abs(tan(t)) / sqrt(tan(t)**2 + 1) + x * tan(t)
s = -sqrt(r) * Abs(tan(t)) / (sqrt(tan(t)**2 + 1) * tan(t))
soln = Intersection(S.Reals, FiniteSet(s))
assert solveset(eq, x, S.Reals) == soln
def test_finite_set_intersection():
# The following should not produce recursion errors
# Note: some of these are not completely correct. See
# https://github.com/sympy/sympy/issues/16342.
assert Intersection(FiniteSet(-oo, x), FiniteSet(x)) == FiniteSet(x)
assert Intersection._handle_finite_sets([FiniteSet(-oo, x), FiniteSet(0, x)]) == FiniteSet(x)
assert Intersection._handle_finite_sets([FiniteSet(-oo, x), FiniteSet(x)]) == FiniteSet(x)
assert Intersection._handle_finite_sets([FiniteSet(2, 3, x, y), FiniteSet(1, 2, x)]) == \
Intersection._handle_finite_sets([FiniteSet(1, 2, x), FiniteSet(2, 3, x, y)]) == \
Intersection(FiniteSet(1, 2, x), FiniteSet(2, 3, x, y)) == \
FiniteSet(1, 2, x)
def test_intersect1():
assert all(S.Integers.intersection(i) is i for i in
(S.Naturals, S.Naturals0))
assert all(i.intersection(S.Integers) is i for i in
(S.Naturals, S.Naturals0))
s = S.Naturals0
assert S.Naturals.intersection(s) is S.Naturals
assert s.intersection(S.Naturals) is S.Naturals
x = Symbol('x')
assert Interval(0, 2).intersect(Interval(1, 2)) == Interval(1, 2)
assert Interval(0, 2).intersect(Interval(1, 2, True)) == \
Interval(1, 2, True)
assert Interval(0, 2, True).intersect(Interval(1, 2)) == \
Interval(1, 2, False, False)
assert Interval(0, 2, True, True).intersect(Interval(1, 2)) == \
Interval(1, 2, False, True)
assert Interval(0, 2).intersect(Union(Interval(0, 1), Interval(2, 3))) == \
Union(Interval(0, 1), Interval(2, 2))
assert FiniteSet(1, 2).intersect(FiniteSet(1, 2, 3)) == FiniteSet(1, 2)
assert FiniteSet(1, 2, x).intersect(FiniteSet(x)) == FiniteSet(x)
assert FiniteSet('ham', 'eggs').intersect(FiniteSet('ham')) == \
FiniteSet('ham')
assert FiniteSet(1, 2, 3, 4, 5).intersect(S.EmptySet) == S.EmptySet
assert Interval(0, 5).intersect(FiniteSet(1, 3)) == FiniteSet(1, 3)
assert Interval(0, 1, True, True).intersect(FiniteSet(1)) == S.EmptySet
assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(1, 2)) == \
Union(Interval(1, 1), Interval(2, 2))
assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(0, 2)) == \
Union(Interval(0, 1), Interval(2, 2))
assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(1, 2, True, True)) == \
S.EmptySet
assert Union(Interval(0, 1), Interval(2, 3)).intersect(S.EmptySet) == \
S.EmptySet
assert Union(Interval(0, 5), FiniteSet('ham')).intersect(FiniteSet(2, 3, 4, 5, 6)) == \
Union(FiniteSet(2, 3, 4, 5), Intersection(FiniteSet(6), Union(Interval(0, 5), FiniteSet('ham'))))
# issue 8217
assert Intersection(FiniteSet(x), FiniteSet(y)) == \
Intersection(FiniteSet(x), FiniteSet(y), evaluate=False)
assert FiniteSet(x).intersect(S.Reals) == \
Intersection(S.Reals, FiniteSet(x), evaluate=False)
# tests for the intersection alias
assert Interval(0, 5).intersection(FiniteSet(1, 3)) == FiniteSet(1, 3)
assert Interval(0, 1, True, True).intersection(FiniteSet(1)) == S.EmptySet
assert Union(Interval(0, 1), Interval(2, 3)).intersection(Interval(1, 2)) == \
Union(Interval(1, 1), Interval(2, 2))
def test_contains():
assert Interval(0, 2).contains(1) is S.true
assert Interval(0, 2).contains(3) is S.false
assert Interval(0, 2, True, False).contains(0) is S.false
assert Interval(0, 2, True, False).contains(2) is S.true
assert Interval(0, 2, False, True).contains(0) is S.true
assert Interval(0, 2, False, True).contains(2) is S.false
assert Interval(0, 2, True, True).contains(0) is S.false
assert Interval(0, 2, True, True).contains(2) is S.false
assert (Interval(0, 2) in Interval(0, 2)) is False
assert FiniteSet(1, 2, 3).contains(2) is S.true
assert FiniteSet(1, 2, Symbol('x')).contains(Symbol('x')) is S.true
assert FiniteSet(y)._contains(x) is None
raises(TypeError, lambda: x in FiniteSet(y))
assert FiniteSet({x, y})._contains({x}) is None
assert FiniteSet({x, y}).subs(y, x)._contains({x}) is True
assert FiniteSet({x, y}).subs(y, x + 1)._contains({x}) is False
# issue 8197
from sympy.abc import a, b
assert isinstance(FiniteSet(b).contains(-a), Contains)
assert isinstance(FiniteSet(b).contains(a), Contains)
assert isinstance(FiniteSet(a).contains(1), Contains)
raises(TypeError, lambda: 1 in FiniteSet(a))
# issue 8209
rad1 = Pow(Pow(2, S(1) / 3) - 1, S(1) / 3)
rad2 = Pow(S(1) / 9,
S(1) / 3) - Pow(S(2) / 9,
S(1) / 3) + Pow(S(4) / 9,
S(1) / 3)
s1 = FiniteSet(rad1)
s2 = FiniteSet(rad2)
assert s1 - s2 == S.EmptySet
items = [1, 2, S.Infinity, S('ham'), -1.1]
fset = FiniteSet(*items)
assert all(item in fset for item in items)
assert all(fset.contains(item) is S.true for item in items)
assert Union(Interval(0, 1), Interval(2, 5)).contains(3) is S.true
assert Union(Interval(0, 1), Interval(2, 5)).contains(6) is S.false
assert Union(Interval(0, 1), FiniteSet(2, 5)).contains(3) is S.false
assert S.EmptySet.contains(1) is S.false
assert FiniteSet(rootof(x**3 + x - 1, 0)).contains(S.Infinity) is S.false
assert rootof(x**5 + x**3 + 1, 0) in S.Reals
assert not rootof(x**5 + x**3 + 1, 1) in S.Reals
# non-bool results
assert Union(Interval(1, 2), Interval(3, 4)).contains(x) == \
Or(And(S(1) <= x, x <= 2), And(S(3) <= x, x <= 4))
assert Intersection(Interval(1, x), Interval(2, 3)).contains(y) == \
And(y <= 3, y <= x, S(1) <= y, S(2) <= y)
assert (S.Complexes).contains(S.ComplexInfinity) == S.false
def test_Complement():
assert Complement(Interval(1, 3), Interval(1, 2)) == Interval(2, 3, True)
assert Complement(FiniteSet(1, 3, 4), FiniteSet(3, 4)) == FiniteSet(1)
assert Complement(Union(Interval(0, 2),
FiniteSet(2, 3, 4)), Interval(1, 3)) == \
Union(Interval(0, 1, False, True), FiniteSet(4))
assert not 3 in Complement(Interval(0, 5), Interval(1, 4), evaluate=False)
assert -1 in Complement(S.Reals, S.Naturals, evaluate=False)
assert not 1 in Complement(S.Reals, S.Naturals, evaluate=False)
assert Complement(S.Integers, S.UniversalSet) == EmptySet()
assert S.UniversalSet.complement(S.Integers) == EmptySet()
assert (not 0 in S.Reals.intersect(S.Integers - FiniteSet(0)))
assert S.EmptySet - S.Integers == S.EmptySet
assert (S.Integers -
FiniteSet(0)) - FiniteSet(1) == S.Integers - FiniteSet(0, 1)
assert S.Reals - Union(S.Naturals, FiniteSet(pi)) == \
Intersection(S.Reals - S.Naturals, S.Reals - FiniteSet(pi))
# issue 12712
assert Complement(FiniteSet(x, y, 2), Interval(-10, 10)) == \
Complement(FiniteSet(x, y), Interval(-10, 10))
def test_issue_9557():
x = Symbol('x')
a = Symbol('a')
assert solveset(x**2 + a, x,
S.Reals) == Intersection(S.Reals,
FiniteSet(-sqrt(-a), sqrt(-a)))
def _print_Piecewise(self, expr):
# Filter out default zeros since they are implicit in a TDB
filtered_args = [i for i in expr.args if not ((i.cond == S.true) and (i.expr == S.Zero))]
exprs = [self._print(arg.expr) for arg in filtered_args]
# Only a small subset of piecewise functions can be represented
# Need to verify that each cond's highlim equals the next cond's lowlim
# to_interval() is used instead of sympy.Relational.as_set() for performance reasons
intervals = [to_interval(i.cond) for i in filtered_args]
if (len(intervals) > 1) and not Intersection(*intervals) is EmptySet:
raise ValueError('Overlapping intervals cannot be represented: {}'.format(intervals))
if not isinstance(Union(*intervals), Interval):
raise ValueError('Piecewise intervals must be continuous')
if not all([arg.cond.free_symbols == {v.T} for arg in filtered_args]):
raise ValueError('Only temperature-dependent piecewise conditions are supported')
# Sort expressions based on intervals
sortindices = [i[0] for i in sorted(enumerate(intervals), key=lambda x:x[1].start)]
exprs = [exprs[idx] for idx in sortindices]
intervals = [intervals[idx] for idx in sortindices]
if len(exprs) > 1:
result = '{1} {0}; {2} Y'.format(exprs[0], self._print(intervals[0].start),
self._print(intervals[0].end))
result += 'Y'.join([' {0}; {1} '.format(expr,
self._print(i.end)) for i, expr in zip(intervals[1:], exprs[1:])])
result += 'N'
else:
result = '{0} {1}; {2} N'.format(self._print(intervals[0].start), exprs[0],
self._print(intervals[0].end))
return result
def test_union_intersection_constructor():
# The actual exception does not matter here, so long as these fail
sets = [FiniteSet(1), FiniteSet(2)]
raises(Exception, lambda: Union(sets))
raises(Exception, lambda: Intersection(sets))
raises(Exception, lambda: Union(tuple(sets)))
raises(Exception, lambda: Intersection(tuple(sets)))
raises(Exception, lambda: Union(i for i in sets))
raises(Exception, lambda: Intersection(i for i in sets))
# Python sets are treated the same as FiniteSet
# The union of a single set (of sets) is the set (of sets) itself
assert Union(set(sets)) == FiniteSet(*sets)
assert Intersection(set(sets)) == FiniteSet(*sets)
assert Union({1}, {2}) == FiniteSet(1, 2)
assert Intersection({1, 2}, {2, 3}) == FiniteSet(2)
def intersection_sets(self, other): # noqa:F811
if other.is_ComplexRegion:
# self in rectangular form
if (not self.polar) and (not other.polar):
return ComplexRegion(Intersection(self.sets, other.sets))
# self in polar form
elif self.polar and other.polar:
r1, theta1 = self.a_interval, self.b_interval
r2, theta2 = other.a_interval, other.b_interval
new_r_interval = Intersection(r1, r2)
new_theta_interval = Intersection(theta1, theta2)
# 0 and 2*Pi means the same
if ((2*S.Pi in theta1 and S.Zero in theta2) or
(2*S.Pi in theta2 and S.Zero in theta1)):
new_theta_interval = Union(new_theta_interval,
FiniteSet(0))
return ComplexRegion(new_r_interval*new_theta_interval,
polar=True)
if other.is_subset(S.Reals):
new_interval = []
x = symbols("x", cls=Dummy, real=True)
# self in rectangular form
if not self.polar:
for element in self.psets:
if S.Zero in element.args[1]:
new_interval.append(element.args[0])
new_interval = Union(*new_interval)
return Intersection(new_interval, other)
# self in polar form
elif self.polar:
for element in self.psets:
if S.Zero in element.args[1]:
new_interval.append(element.args[0])
if S.Pi in element.args[1]:
new_interval.append(ImageSet(Lambda(x, -x), element.args[0]))
if S.Zero in element.args[0]:
new_interval.append(FiniteSet(0))
new_interval = Union(*new_interval)
return Intersection(new_interval, other)
def test_intersection():
# iterable
i = Intersection(FiniteSet(1, 2, 3), Interval(2, 5), evaluate=False)
assert i.is_iterable
assert set(i) == set([S(2), S(3)])
# challenging intervals
x = Symbol('x', real=True)
i = Intersection(Interval(0, 3), Interval(x, 6))
assert (5 in i) is False
raises(TypeError, lambda: 2 in i)
# Singleton special cases
assert Intersection(Interval(0, 1), S.EmptySet) == S.EmptySet
# Products
line = Interval(0, 5)
i = Intersection(line**2, line**3, evaluate=False)
assert (2, 2) not in i
assert (2, 2, 2) not in i
raises(ValueError, lambda: list(i))
assert Intersection(Intersection(S.Integers, S.Naturals, evaluate=False),
S.Reals, evaluate=False) == \
Intersection(S.Integers, S.Naturals, S.Reals, evaluate=False)
def set(self):
if not isinstance(self.n, Integer):
i = Symbol('i', integer=True, positive=True)
return Product(Intersection(S.Naturals0, Interval(0, self.n//i)),
(i, 1, self.n))
prod_set = Range(0, self.n + 1)
for i in range(2, self.n + 1):
prod_set *= Range(0, self.n//i + 1)
return prod_set
def get_solution_domain(sols, iVar):
from sympy import Union, Interval, oo, Intersection, Abs
sIVar = iVar._sympy_()
domain = S.Reals
for sol in sols:
domain = Intersection(domain,
find_real_domain(sol.rhs()._sympy_(), sIVar))
return domain
def test_intersect():
x = Symbol('x')
assert Interval(0, 2).intersect(Interval(1, 2)) == Interval(1, 2)
assert Interval(0, 2).intersect(Interval(1, 2, True)) == \
Interval(1, 2, True)
assert Interval(0, 2, True).intersect(Interval(1, 2)) == \
Interval(1, 2, False, False)
assert Interval(0, 2, True, True).intersect(Interval(1, 2)) == \
Interval(1, 2, False, True)
assert Interval(0, 2).intersect(Union(Interval(0, 1), Interval(2, 3))) == \
Union(Interval(0, 1), Interval(2, 2))
assert FiniteSet(1, 2)._intersect((1, 2, 3)) == FiniteSet(1, 2)
assert FiniteSet(1, 2, x).intersect(FiniteSet(x)) == FiniteSet(x)
assert FiniteSet('ham', 'eggs').intersect(FiniteSet('ham')) == \
FiniteSet('ham')
assert FiniteSet(1, 2, 3, 4, 5).intersect(S.EmptySet) == S.EmptySet
assert Interval(0, 5).intersect(FiniteSet(1, 3)) == FiniteSet(1, 3)
assert Interval(0, 1, True, True).intersect(FiniteSet(1)) == S.EmptySet
assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(1, 2)) == \
Union(Interval(1, 1), Interval(2, 2))
assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(0, 2)) == \
Union(Interval(0, 1), Interval(2, 2))
assert Union(Interval(0, 1), Interval(2, 3)).intersect(Interval(1, 2, True, True)) == \
S.EmptySet
assert Union(Interval(0, 1), Interval(2, 3)).intersect(S.EmptySet) == \
S.EmptySet
assert Union(Interval(0, 5), FiniteSet('ham')).intersect(FiniteSet(2, 3, 4, 5, 6)) == \
Union(FiniteSet(2, 3, 4, 5), Intersection(FiniteSet(6), Union(Interval(0, 5), FiniteSet('ham'))))
# issue 8217
assert Intersection(FiniteSet(x), FiniteSet(y)) == \
Intersection(FiniteSet(x), FiniteSet(y), evaluate=False)
assert FiniteSet(x).intersect(S.Reals) == \
Intersection(S.Reals, FiniteSet(x), evaluate=False)
# tests for the intersection alias
assert Interval(0, 5).intersection(FiniteSet(1, 3)) == FiniteSet(1, 3)
assert Interval(0, 1, True, True).intersection(FiniteSet(1)) == S.EmptySet
assert Union(Interval(0, 1), Interval(2, 3)).intersection(Interval(1, 2)) == \
Union(Interval(1, 1), Interval(2, 2))
def test_solve_invert():
assert solveset_real(exp(x) - 3, x) == FiniteSet(log(3))
assert solveset_real(log(x) - 3, x) == FiniteSet(exp(3))
assert solveset_real(3**(x + 2), x) == FiniteSet()
assert solveset_real(3**(2 - x), x) == FiniteSet()
assert solveset_real(y - b*exp(a/x), x) == Intersection(S.Reals, FiniteSet(a/log(y/b)))
# issue 4504
assert solveset_real(2**x - 10, x) == FiniteSet(log(10)/log(2))
def test_invert_real():
x = Dummy(real=True)
n = Symbol('n')
assert solveset(abs(x) - n, x) == Intersection(S.Reals, FiniteSet(-n, n))
n = Symbol('n', real=True)
assert invert_real(x + 3, y, x) == (x, FiniteSet(y - 3))
assert invert_real(x*3, y, x) == (x, FiniteSet(y / 3))
assert invert_real(exp(x), y, x) == (x, FiniteSet(log(y)))
assert invert_real(exp(3*x), y, x) == (x, FiniteSet(log(y) / 3))
assert invert_real(exp(x + 3), y, x) == (x, FiniteSet(log(y) - 3))
assert invert_real(exp(x) + 3, y, x) == (x, FiniteSet(log(y - 3)))
assert invert_real(exp(x)*3, y, x) == (x, FiniteSet(log(y / 3)))
assert invert_real(log(x), y, x) == (x, FiniteSet(exp(y)))
assert invert_real(log(3*x), y, x) == (x, FiniteSet(exp(y) / 3))
assert invert_real(log(x + 3), y, x) == (x, FiniteSet(exp(y) - 3))
assert invert_real(Abs(x), y, x) == (x, FiniteSet(-y, y))
assert invert_real(2**x, y, x) == (x, FiniteSet(log(y)/log(2)))
assert invert_real(2**exp(x), y, x) == (x, FiniteSet(log(log(y)/log(2))))
assert invert_real(x**2, y, x) == (x, FiniteSet(sqrt(y), -sqrt(y)))
assert invert_real(x**Rational(1, 2), y, x) == (x, FiniteSet(y**2))
raises(ValueError, lambda: invert_real(x, x, x))
raises(ValueError, lambda: invert_real(x**pi, y, x))
raises(ValueError, lambda: invert_real(S.One, y, x))
assert invert_real(x**31 + x, y, x) == (x**31 + x, FiniteSet(y))
assert invert_real(Abs(x**31 + x + 1), y, x) == (x**31 + x,
FiniteSet(-y - 1, y - 1))
assert invert_real(tan(x), y, x) == \
(x, imageset(Lambda(n, n*pi + atan(y)), S.Integers))
assert invert_real(tan(exp(x)), y, x) == \
(x, imageset(Lambda(n, log(n*pi + atan(y))), S.Integers))
assert invert_real(cot(x), y, x) == \
(x, imageset(Lambda(n, n*pi + acot(y)), S.Integers))
assert invert_real(cot(exp(x)), y, x) == \
(x, imageset(Lambda(n, log(n*pi + acot(y))), S.Integers))
assert invert_real(tan(tan(x)), y, x) == \
(tan(x), imageset(Lambda(n, n*pi + atan(y)), S.Integers))
x = Symbol('x', positive=True)
assert invert_real(x**pi, y, x) == (x, FiniteSet(y**(1/pi)))
def chain_reaction(A, var_no, var_interval, constraints, symbol):
if not (A.shape[1] > 1 and A.shape[0] > 2):
return [A, var_interval]
new_var_interval = copy.deepcopy(var_interval)
var_index = np.where(A[-1, :-1] == var_no)[0][0]
if var_interval[var_no].is_Union:
lbound = var_interval[var_no].args[0].args[0]
rbound = var_interval[var_no].args[-1].args[1]
else:
lbound = var_interval[var_no].args[0]
rbound = var_interval[var_no].args[1]
row_sum = np.sum(A[:-2, :-1], 1)
con_index = np.where((row_sum == 2) *
A[:-2, var_index] == 1)[0] # 是包含var_no和另一个变量的约束
con_no = A[con_index, -1]
A[:-2, var_index] = np.zeros(A[:-2, var_index].shape)
for i in range(con_no.shape[0]):
func = parse_expr(constraints[con_no[i]])
func = sympy.solve(func, symbol[var_no]) # 可以把当前变量整理到式子左侧
if ((not lbound.is_infinite) and
(func.rel_op is '<' or func.rel_op is '<=')): # 说明可以给式子右侧的一坨确定一个下界
new_var_index = np.where(A[con_index[i], :-1] == 1)[0][0]
result = solveset(func.subs({symbol[var_no]: lbound}),
domain=sympy.S.Reals)
new_var_interval[new_var_index] = Intersection(
new_var_interval[new_var_index], result)
elif ((not rbound.is_infinite)
and (func.rel_op is '>' or func.rel_op is '>=')):
new_var_index = np.where(A[con_index[i], :-1] == 1)[0][0]
result = solveset(func.subs({symbol[var_no]: rbound}),
domain=sympy.S.Reals)
new_var_interval[new_var_index] = Intersection(
new_var_interval[new_var_index], result)
old_new_var_interval = new_var_interval
for i in range(len(var_interval)):
if old_new_var_interval[i] != var_interval[i]:
[A, new_var_interval] = chain_reaction(A, i, new_var_interval,
constraints, symbol)
return [A, new_var_interval]
def test_intersection():
# iterable
i = Intersection(FiniteSet(1,2,3), Interval(2, 5), evaluate=False)
assert i.is_iterable
assert list(i) == [2, 3]
# challenging intervals
x = Symbol('x', real=True)
i = Intersection(Interval(0, 3), Interval(x, 6))
assert (5 in i) == False
raises(TypeError, lambda: 2 in i)
# Singleton special cases
assert Intersection(Interval(0, 1), S.EmptySet) == S.EmptySet
assert Intersection(Interval(0, 1), S.UniversalSet) == Interval(0, 1)
# Products
line = Interval(0, 5)
i = Intersection(line**2, line**3, evaluate=False)
assert (2,2) not in i
assert (2,2,2) not in i
raises(ValueError, lambda: list(i))
def parse_explicit_set(cls, eq):
"""Parses potentially multiple explicit sets with unions and intersections,
eq is formatted such as {1,2,3}u{4,5,6}"""
final_set_1 = S.UniversalSet
tab_1 = eq.split('\\cap') # Intersections
for set_1 in tab_1:
tab_2 = set_1.split('\\cup') # Unions
final_set_2 = EmptySet
for set_2 in tab_2:
sympy_set_2 = cls.parse_single_explicit_set(set_2)
final_set_2 = Union(final_set_2, sympy_set_2)
final_set_1 = Intersection(final_set_1, final_set_2)
return simplify(final_set_1)
def test_issue_20291():
from sympy import FiniteSet, Complement, Intersection, Reals, EmptySet
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 test_finite_set_intersection():
# The following should not produce recursion errors
# Note: some of these are not completely correct. See
# https://github.com/sympy/sympy/issues/16342.
assert Intersection(FiniteSet(-oo, x), FiniteSet(x)) == FiniteSet(x)
assert Intersection._handle_finite_sets(
[FiniteSet(-oo, x), FiniteSet(0, x)]) == FiniteSet(x)
assert Intersection._handle_finite_sets([FiniteSet(-oo, x),
FiniteSet(x)]) == FiniteSet(x)
assert Intersection._handle_finite_sets([FiniteSet(2, 3, x, y), FiniteSet(1, 2, x)]) == \
Intersection._handle_finite_sets([FiniteSet(1, 2, x), FiniteSet(2, 3, x, y)]) == \
Intersection(FiniteSet(1, 2, x), FiniteSet(2, 3, x, y)) == \
Intersection(FiniteSet(1, 2, x), FiniteSet(2, x, y))
assert FiniteSet(1+x-y) & FiniteSet(1) == \
FiniteSet(1) & FiniteSet(1+x-y) == \
Intersection(FiniteSet(1+x-y), FiniteSet(1), evaluate=False)
assert FiniteSet(1) & FiniteSet(x) == FiniteSet(x) & FiniteSet(1) == \
Intersection(FiniteSet(1), FiniteSet(x), evaluate=False)
assert FiniteSet({x}) & FiniteSet({x, y}) == \
Intersection(FiniteSet({x}), FiniteSet({x, y}), evaluate=False)
def to_interval(relational):
if isinstance(relational, And):
return Intersection([to_interval(i) for i in relational.args])
elif isinstance(relational, Or):
return Union([to_interval(i) for i in relational.args])
elif isinstance(relational, Not):
return Complement([to_interval(i) for i in relational.args])
if relational == S.true:
return Interval(S.NegativeInfinity,
S.Infinity,
left_open=True,
right_open=True)
if len(relational.free_symbols) != 1:
raise ValueError('Relational must only have one free symbol')
if len(relational.args) != 2:
raise ValueError('Relational must only have two arguments')
free_symbol = list(relational.free_symbols)[0]
lhs = relational.args[0]
rhs = relational.args[1]
if isinstance(relational, GreaterThan):
if lhs == free_symbol:
return Interval(rhs, S.Infinity, left_open=False)
else:
return Interval(S.NegativeInfinity, rhs, right_open=False)
elif isinstance(relational, StrictGreaterThan):
if lhs == free_symbol:
return Interval(rhs, S.Infinity, left_open=True)
else:
return Interval(S.NegativeInfinity, rhs, right_open=True)
elif isinstance(relational, LessThan):
if lhs != free_symbol:
return Interval(rhs, S.Infinity, left_open=False)
else:
return Interval(S.NegativeInfinity, rhs, right_open=False)
elif isinstance(relational, StrictLessThan):
if lhs != free_symbol:
return Interval(rhs, S.Infinity, left_open=True)
else:
return Interval(S.NegativeInfinity, rhs, right_open=True)
else:
raise ValueError('Unsupported Relational: {}'.format(
relational.__class__.__name__))
def _print_Piecewise(self, expr):
exprs = [self._print(arg.expr) for arg in expr.args]
# Only a small subset of piecewise functions can be represented
# Need to verify that each cond's highlim equals the next cond's lowlim
intervals = [to_interval(i.cond) for i in expr.args]
if (len(intervals) > 1) and Intersection(intervals) != EmptySet():
raise ValueError(
'Overlapping intervals cannot be represented: {}'.format(
intervals))
if not isinstance(Union(intervals), Interval):
raise ValueError('Piecewise intervals must be continuous')
if not all([arg.cond.free_symbols == {v.T} for arg in expr.args]):
raise ValueError(
'Only temperature-dependent piecewise conditions are supported'
)
# Sort expressions based on intervals
sortindices = [
i[0]
for i in sorted(enumerate(intervals), key=lambda x: x[1].start)
]
exprs = [exprs[idx] for idx in sortindices]
intervals = [intervals[idx] for idx in sortindices]
if len(exprs) > 1:
result = '{1} {0}; {2} Y'.format(exprs[0],
self._print(intervals[0].start),
self._print(intervals[0].end))
result += 'Y'.join([
' {0}; {1} '.format(expr, self._print(i.end))
for i, expr in zip(intervals[1:], exprs[1:])
])
result += 'N'
else:
result = '{0} {1}; {2} N'.format(self._print(intervals[0].start),
exprs[0],
self._print(intervals[0].end))
return result
def intersection_sets(a, b): # noqa:F811
return ConditionSet(a.sym, a.condition, Intersection(a.base_set, b))
def test_issue_10248():
assert list(Intersection(S.Reals, FiniteSet(x))) == [
And(x < oo, x > -oo)]
def test_issue_Symbol_inter():
i = Interval(0, oo)
r = S.Reals
mat = Matrix([0, 0, 0])
assert Intersection(r, i, FiniteSet(m), FiniteSet(m, n)) == \
Intersection(i, FiniteSet(m))
assert Intersection(FiniteSet(1, m, n), FiniteSet(m, n, 2), i) == \
Intersection(i, FiniteSet(m, n))
assert Intersection(FiniteSet(m, n, x), FiniteSet(m, z), r) == \
Intersection(r, FiniteSet(m, z), FiniteSet(n, x))
assert Intersection(FiniteSet(m, n, 3), FiniteSet(m, n, x), r) == \
Intersection(r, FiniteSet(3, m, n), evaluate=False)
assert Intersection(FiniteSet(m, n, 3), FiniteSet(m, n, 2, 3), r) == \
Union(FiniteSet(3), Intersection(r, FiniteSet(m, n)))
assert Intersection(r, FiniteSet(mat, 2, n), FiniteSet(0, mat, n)) == \
Intersection(r, FiniteSet(n))
assert Intersection(FiniteSet(sin(x), cos(x)), FiniteSet(sin(x), cos(x), 1), r) == \
Intersection(r, FiniteSet(sin(x), cos(x)))
assert Intersection(FiniteSet(x**2, 1, sin(x)), FiniteSet(x**2, 2, sin(x)), r) == \
Intersection(r, FiniteSet(x**2, sin(x)))
def test_issue_9536():
from sympy.functions.elementary.exponential import log
a = Symbol('a', real=True)
assert FiniteSet(log(a)).intersect(S.Reals) == Intersection(S.Reals, FiniteSet(log(a)))
def test_Intersection_as_relational():
x = Symbol('x')
assert (Intersection(Interval(0, 1), FiniteSet(2),
evaluate=False).as_relational(x)
== And(And(Le(0, x), Le(x, 1)), Eq(x, 2)))
def test_issue_11174():
soln = Intersection(Interval(-oo, oo), FiniteSet(-x), evaluate=False)
assert Intersection(FiniteSet(-x), S.Reals) == soln
soln = Intersection(S.Reals, FiniteSet(x), evaluate=False)
assert Intersection(FiniteSet(x), S.Reals) == soln
def set(self):
N, m, n = self.N, self.m, self.n
if self.is_symbolic:
return Intersection(S.Naturals0, Interval(self.low, self.high))
return set([i for i in range(max(0, n + m - N), min(n, m) + 1)])
