def test_is_subset():
assert Interval(0, 1).is_subset(Interval(0, 2)) is True
assert Interval(0, 3).is_subset(Interval(0, 2)) is False
assert FiniteSet(1, 2).is_subset(FiniteSet(1, 2, 3, 4))
assert FiniteSet(4, 5).is_subset(FiniteSet(1, 2, 3, 4)) is False
assert FiniteSet(1).is_subset(Interval(0, 2))
assert FiniteSet(1, 2).is_subset(Interval(0, 2, True, True)) is False
assert (Interval(1, 2) + FiniteSet(3)).is_subset(
(Interval(0, 2, False, True) + FiniteSet(2, 3)))
assert Interval(3, 4).is_subset(Union(Interval(0, 1), Interval(2, 5))) is True
assert Interval(3, 6).is_subset(Union(Interval(0, 1), Interval(2, 5))) is False
assert FiniteSet(1, 2, 3, 4).is_subset(Interval(0, 5)) is True
assert S.EmptySet.is_subset(FiniteSet(1, 2, 3)) is True
assert Interval(0, 1).is_subset(S.EmptySet) is False
assert S.EmptySet.is_subset(S.EmptySet) is True
pytest.raises(ValueError, lambda: S.EmptySet.is_subset(1))
# tests for the issubset alias
assert FiniteSet(1, 2, 3, 4).issubset(Interval(0, 5)) is True
assert S.EmptySet.issubset(FiniteSet(1, 2, 3)) is True
def test_sympyissue_10113():
f = x**2 / (x**2 - 4)
assert imageset(x, f, S.Reals) == Union(Interval(-oo, 0, True),
Interval(1, oo, True, True))
assert imageset(x, f, Interval(-2, 2)) == Interval(-oo, 0, True)
assert imageset(x, f, Interval(-2, 3)) == Union(
Interval(-oo, 0, True), Interval(Rational(9, 5), oo, False, True))
def test_solve_univariate_inequality():
assert isolve(x**2 >= 4, x, relational=False) == Union(Interval(-oo, -2, True),
Interval(2, oo, False, True))
assert isolve(x**2 >= 4, x) == Or(And(Le(2, x), Lt(x, oo)), And(Le(x, -2),
Lt(-oo, x)))
assert isolve((x - 1)*(x - 2)*(x - 3) >= 0, x, relational=False) == \
Union(Interval(1, 2), Interval(3, oo, False, True))
assert isolve((x - 1)*(x - 2)*(x - 3) >= 0, x) == \
Or(And(Le(1, x), Le(x, 2)), And(Le(3, x), Lt(x, oo)))
# issue sympy/sympy#2785:
assert isolve(x**3 - 2*x - 1 > 0, x, relational=False) == \
Union(Interval(-1, -sqrt(5)/2 + Rational(1, 2), True, True),
Interval(Rational(1, 2) + sqrt(5)/2, oo, True, True))
# issue sympy/sympy#2794:
assert isolve(x**3 - x**2 + x - 1 > 0, x, relational=False) == \
Interval(1, oo, True, True)
# XXX should be limited in domain, e.g. between 0 and 2*pi
assert isolve(sin(x) < S.Half, x) == \
Or(And(-oo < x, x < pi/6), And(5*pi/6 < x, x < oo))
assert isolve(sin(x) > S.Half, x) == And(pi/6 < x, x < 5*pi/6)
# numerical testing in valid() is needed
assert isolve(x**7 - x - 2 > 0, x) == \
And(RootOf(x**7 - x - 2, 0) < x, x < oo)
# handle numerator and denominator; although these would be handled as
# rational inequalities, these test confirm that the right thing is done
# when the domain is EX (e.g. when 2 is replaced with sqrt(2))
assert isolve(1/(x - 2) > 0, x) == And(Integer(2) < x, x < oo)
den = ((x - 1)*(x - 2)).expand()
assert isolve((x - 1)/den <= 0, x) == \
Or(And(-oo < x, x < 1), And(Integer(1) < x, x < 2))
assert isolve(x > oo, x) is S.false
def test_interval_symbolic_end_points():
a = Symbol('a', extended_real=True)
assert Union(Interval(0, a), Interval(0, 3)).sup == Max(a, 3)
assert Union(Interval(a, 0), Interval(-3, 0)).inf == Min(-3, a)
assert Interval(0, a).contains(1) == LessThan(1, a)
def test_SymmetricDifference():
assert (SymmetricDifference(FiniteSet(0, 1, 2, 3, 4, 5),
FiniteSet(2, 4, 6, 8, 10)) == FiniteSet(
0, 1, 3, 5, 6, 8, 10))
assert (SymmetricDifference(FiniteSet(2, 3, 4),
FiniteSet(2, 3, 4, 5)) == FiniteSet(5))
assert FiniteSet(2).symmetric_difference(FiniteSet(2, 5)) == FiniteSet(5)
assert (FiniteSet(1, 2, 3, 4, 5) ^ FiniteSet(1, 2, 5, 6) == FiniteSet(
3, 4, 6))
assert (Set(Integer(1), Integer(2), Integer(3))
^ Set(Integer(2), Integer(3), Integer(4)) == Union(
Set(Integer(1), Integer(2), Integer(3)) -
Set(Integer(2), Integer(3), Integer(4)),
Set(Integer(2), Integer(3), Integer(4)) -
Set(Integer(1), Integer(2), Integer(3))))
assert (Interval(0, 4) ^ Interval(2, 5) == Union(
Interval(0, 4) - Interval(2, 5),
Interval(2, 5) - Interval(0, 4)))
class TestSet(Set):
def _symmetric_difference(self, other):
return
t1, t2 = TestSet(1), TestSet(2)
assert t1.symmetric_difference(t2) == SymmetricDifference(t1,
t2,
evaluate=False)
def test_measure():
a = Symbol('a', extended_real=True)
assert Interval(1, 3).measure == 2
assert Interval(0, a).measure == a
assert Interval(1, a).measure == a - 1
assert Union(Interval(1, 2), Interval(3, 4)).measure == 2
assert Union(Interval(1, 2), Interval(3, 4), FiniteSet(5, 6, 7)).measure \
== 2
assert FiniteSet(1, 2, oo, a, -oo, -5).measure == 0
assert S.EmptySet.measure == 0
square = Interval(0, 10) * Interval(0, 10)
offsetsquare = Interval(5, 15) * Interval(5, 15)
band = Interval(-oo, oo) * Interval(2, 4)
assert square.measure == offsetsquare.measure == 100
assert (square + offsetsquare).measure == 175 # there is some overlap
assert (square - offsetsquare).measure == 75
assert (square * FiniteSet(1, 2, 3)).measure == 0
assert (square.intersection(band)).measure == 20
assert (square + band).measure == oo
assert (band * FiniteSet(1, 2, 3)).measure == nan
def test_sympyissue_9447():
a = Interval(0, 1) + Interval(2, 3)
assert (Complement(S.UniversalSet, a) ==
Complement(S.UniversalSet,
Union(Interval(0, 1), Interval(2, 3)), evaluate=False))
# issue sympy/sympy#10305:
assert (Complement(S.Naturals, a) ==
Complement(S.Naturals,
Union(Interval(0, 1), Interval(2, 3)), evaluate=False))
def test_contains():
assert Interval(0, 2).contains(1) is true
assert Interval(0, 2).contains(3) is false
assert Interval(0, 2, True, False).contains(0) is false
assert Interval(0, 2, True, False).contains(2) is true
assert Interval(0, 2, False, True).contains(0) is true
assert Interval(0, 2, False, True).contains(2) is false
assert Interval(0, 2, True, True).contains(0) is false
assert Interval(0, 2, True, True).contains(2) is false
assert Interval(0, 2) not in Interval(0, 2)
# issue sympy/sympy#10326
assert S.Reals.contains(oo) is false
assert S.Reals.contains(-oo) is false
assert Interval(-oo, oo, True).contains(oo) is true
assert Interval(-oo, oo).contains(-oo) is true
bad = [EmptySet(), FiniteSet(1), Interval(1, 2), zoo,
I, oo, nan, -oo]
assert all(i not in Interval(0, 5) for i in bad)
assert FiniteSet(1, 2, 3).contains(2) is true
assert FiniteSet(1, 2, x).contains(x) is true
# issue sympy/sympy#8197
assert isinstance(FiniteSet(b).contains(-a), Contains)
assert isinstance(FiniteSet(b).contains(a), Contains)
assert isinstance(FiniteSet(a).contains(1), Contains)
pytest.raises(TypeError, lambda: 1 in FiniteSet(a))
# issue sympy/sympy#8209
rad1 = Integer(4)
rad2 = Pow(2, 2, evaluate=False)
s1 = FiniteSet(rad1)
s2 = FiniteSet(rad2)
assert s1 - s2 == S.EmptySet
items = [1, 2, oo, Symbol('ham'), -1.1]
fset = FiniteSet(*items)
assert all(item in fset for item in items)
assert all(fset.contains(item) is true for item in items)
assert Union(Interval(0, 1), Interval(2, 5)).contains(3) is true
assert Union(Interval(0, 1), Interval(2, 5)).contains(6) is false
assert Union(Interval(0, 1), FiniteSet(2, 5)).contains(3) is false
assert S.EmptySet.contains(1) is false
assert FiniteSet(RootOf(x**3 + x - 1, 0)).contains(oo) is false
assert RootOf(x**5 + x**3 + 1, 0) in S.Reals
assert not RootOf(x**5 + x**3 + 1, 1) in S.Reals
def test_SymmetricDifference():
assert (SymmetricDifference(FiniteSet(0, 1, 2, 3, 4, 5),
FiniteSet(2, 4, 6, 8, 10)) == FiniteSet(
0, 1, 3, 5, 6, 8, 10))
assert (SymmetricDifference(FiniteSet(2, 3, 4),
FiniteSet(2, 3, 4, 5)) == FiniteSet(5))
assert (FiniteSet(1, 2, 3, 4, 5) ^ FiniteSet(1, 2, 5, 6) == FiniteSet(
3, 4, 6))
assert (Set(1, 2, 3) ^ Set(2, 3, 4) == Union(
Set(1, 2, 3) - Set(2, 3, 4),
Set(2, 3, 4) - Set(1, 2, 3)))
assert (Interval(0, 4) ^ Interval(2, 5) == Union(
Interval(0, 4) - Interval(2, 5),
Interval(2, 5) - Interval(0, 4)))
def test_boundary_Union():
assert (Interval(0, 1) + Interval(2, 3)).boundary == FiniteSet(0, 1, 2, 3)
assert ((Interval(0, 1, False, True) +
Interval(1, 2, True, False)).boundary == FiniteSet(0, 1, 2))
assert (Interval(0, 1) + FiniteSet(2)).boundary == FiniteSet(0, 1, 2)
assert (Union(Interval(0, 10), Interval(5, 15), evaluate=False).boundary ==
FiniteSet(0, 15))
assert (Union(Interval(0, 10), Interval(0, 1), evaluate=False).boundary ==
FiniteSet(0, 10))
assert (Union(Interval(0, 10, True, True),
Interval(10, 15, True, True), evaluate=False).boundary ==
FiniteSet(0, 10, 15))
def test_finite_basic():
A = FiniteSet(1, 2, 3)
B = FiniteSet(3, 4, 5)
AorB = Union(A, B)
AandB = A.intersect(B)
assert A.is_subset(AorB) and B.is_subset(AorB)
assert AandB.is_subset(A)
assert AandB == FiniteSet(3)
assert A.inf == 1 and A.sup == 3
assert AorB.inf == 1 and AorB.sup == 5
assert FiniteSet(x, 1, 5).sup == Max(x, 5)
assert FiniteSet(x, 1, 5).inf == Min(x, 1)
# issue 7335
assert FiniteSet(S.EmptySet) != S.EmptySet
assert FiniteSet(FiniteSet(1, 2, 3)) != FiniteSet(1, 2, 3)
assert FiniteSet((1, 2, 3)) != FiniteSet(1, 2, 3)
# Ensure a variety of types can exist in a FiniteSet
assert FiniteSet((1, 2), Float, A, -5, x, 'eggs', x**2, Interval)
assert (A > B) is False
assert (A >= B) is False
assert (A < B) is False
assert (A <= B) is False
assert AorB > A and AorB > B
assert AorB >= A and AorB >= B
assert A >= A and A <= A
assert A >= AandB and B >= AandB
assert A > AandB and B > AandB
def test_product_basic():
H, T = 'H', 'T'
unit_line = Interval(0, 1)
d6 = FiniteSet(1, 2, 3, 4, 5, 6)
d4 = FiniteSet(1, 2, 3, 4)
coin = FiniteSet(H, T)
square = unit_line * unit_line
assert (0, 0) in square
assert 0 not in square
assert (H, T) in coin ** 2
assert (.5, .5, .5) in square * unit_line
assert (H, 3, 3) in coin*d6*d6
HH, TT = sympify(H), sympify(T)
assert set(coin**2) == {(HH, HH), (HH, TT), (TT, HH), (TT, TT)}
assert (d4*d4).is_subset(d6*d6)
assert (square.complement(Interval(-oo, oo)*Interval(-oo, oo)) ==
Union((Interval(-oo, 0, True, True) +
Interval(1, oo, True, True))*Interval(-oo, oo),
Interval(-oo, oo)*(Interval(-oo, 0, True, True) +
Interval(1, oo, True, True))))
assert (Interval(-5, 5)**3).is_subset(Interval(-10, 10)**3)
assert not (Interval(-10, 10)**3).is_subset(Interval(-5, 5)**3)
assert not (Interval(-5, 5)**2).is_subset(Interval(-10, 10)**3)
assert (Interval(.2, .5)*FiniteSet(.5)).is_subset(square) # segment in square
assert len(coin*coin*coin) == 8
assert len(S.EmptySet*S.EmptySet) == 0
assert len(S.EmptySet*coin) == 0
pytest.raises(TypeError, lambda: len(coin*Interval(0, 2)))
def test_image_piecewise():
f = Piecewise((x, x <= -1), (1 / x**2, x <= 5), (x**3, True))
f1 = Piecewise((0, x <= 1), (1, x <= 2), (2, True))
f2 = Piecewise((x, x <= -1), (x**3, True))
assert imageset(x, f, Interval(-5, 5)) == Union(
Interval(-5, -1), Interval(Rational(1, 25), oo, false, true))
assert imageset(x, f1, Interval(1, 2)) == FiniteSet(0, 1)
assert imageset(x, f2, Interval(-2, 2)) == Interval(-2, 8)
def test_booleans():
"""Test basic unions and intersections."""
assert Union(l1, l2).equal(l1)
assert Intersection(l1, l2).equal(l1)
assert Intersection(l1, l4) == FiniteSet(Point(1, 1))
assert Intersection(Union(l1, l4),
l3) == FiniteSet(Point(-1 / 3, -1 / 3), Point(5, 1))
assert Intersection(l1, FiniteSet(Point(7, -7))) == EmptySet()
assert Intersection(Circle(Point(0, 0), 3),
Line(p1, p2)) == FiniteSet(Point(-3, 0), Point(3, 0))
fs = FiniteSet(Point(1 / 3, 1), Point(2 / 3, 0), Point(9 / 5, 1 / 5),
Point(7 / 3, 1))
# test the intersection of polygons
assert Intersection(poly1, poly2) == fs
# make sure if we union polygons with subsets, the subsets go away
assert Union(poly1, poly2, fs) == Union(poly1, poly2)
# make sure that if we union with a FiniteSet that isn't a subset,
# that the points in the intersection stop being listed
assert Union(poly1, FiniteSet(Point(0, 0),
Point(3,
5))) == Union(poly1,
FiniteSet(Point(3, 5)))
# intersect two polygons that share an edge
assert Intersection(poly1, poly3) == Union(
FiniteSet(Point(3 / 2, 1), Point(2, 1)),
Segment(Point(0, 0), Point(1, 0)))
def test_bool_as_set():
assert And(x <= 2, x >= -2).as_set() == Interval(-2, 2)
assert Or(x >= 2, x <= -2).as_set() == (Interval(-oo, -2, True) +
Interval(2, oo, False, True))
assert Not(x > 2, evaluate=False).as_set() == Interval(-oo, 2, True)
# issue sympy/sympy#10240
assert Not(And(x > 2, x < 3)).as_set() == \
Union(Interval(-oo, 2, True), Interval(3, oo, False, True))
assert true.as_set() == S.UniversalSet
assert false.as_set() == EmptySet()
def test_difference():
assert Interval(1, 3) - Interval(1, 2) == Interval(2, 3, True)
assert Interval(1, 3) - Interval(2, 3) == Interval(1, 2, False, True)
assert Interval(1, 3, True) - Interval(2, 3) == Interval(1, 2, True, True)
assert Interval(1, 3, True) - Interval(2, 3, True) == \
Interval(1, 2, True, False)
assert Interval(0, 2) - FiniteSet(1) == \
Union(Interval(0, 1, False, True), Interval(1, 2, True, False))
assert FiniteSet(1, 2, 3) - FiniteSet(2) == FiniteSet(1, 3)
assert (FiniteSet('ham', 'eggs') - FiniteSet('eggs') ==
Complement(FiniteSet('ham'), FiniteSet('eggs')))
assert FiniteSet(1, 2, 3, 4) - Interval(2, 10, True, False) == \
FiniteSet(1, 2)
assert FiniteSet(1, 2, 3, 4) - S.EmptySet == FiniteSet(1, 2, 3, 4)
assert Union(Interval(0, 2), FiniteSet(2, 3, 4)) - Interval(1, 3) == \
Union(Interval(0, 1, False, True), FiniteSet(4))
assert -1 in S.Reals - S.Naturals
def test_sympyissue_9637():
n = Symbol('n')
a = FiniteSet(n)
b = FiniteSet(2, n)
assert Complement(S.Reals, a) == Complement(S.Reals, a, evaluate=False)
assert Complement(Interval(1, 3), a) == Complement(Interval(1, 3), a, evaluate=False)
assert (Complement(Interval(1, 3), b) ==
Complement(Union(Interval(1, 2, right_open=True),
Interval(2, 3, left_open=True)), a, evaluate=False))
assert Complement(a, S.Reals) == Complement(a, S.Reals, evaluate=False)
assert Complement(a, Interval(1, 3)) == Complement(a, Interval(1, 3), evaluate=False)
def test_solve_poly_inequality():
assert psolve(Poly(0, x), '==') == [S.Reals]
assert psolve(Poly(1, x), '==') == [S.EmptySet]
assert psolve(PurePoly(x + 1, x), '>') == [Interval(-1, oo, True, True)]
pytest.raises(ValueError, lambda: psolve(x, '=='))
pytest.raises(ValueError, lambda: psolve(Poly(x, x), '??'))
assert (solve_poly_inequalities(
((Poly(x**2 - 3), '>'),
(Poly(-x**2 + 1), '>'))) == Union(Interval(-oo, -sqrt(3), True, True),
Interval(-1, 1, True, True),
Interval(sqrt(3), oo, True, True)))
def test_reduce_rational_inequalities_real_relational():
assert reduce_rational_inequalities([], x) is S.false
assert reduce_rational_inequalities(
[[(x**2 + 3*x + 2)/(x**2 - 16) >= 0]], x, relational=False) == \
Union(Interval.open(-oo, -4), Interval(-2, -1), Interval.open(4, oo))
assert reduce_rational_inequalities(
[[((-2*x - 10)*(3 - x))/((x**2 + 5)*(x - 2)**2) < 0]], x,
relational=False) == \
Union(Interval.open(-5, 2), Interval.open(2, 3))
assert reduce_rational_inequalities([[(x + 1)/(x - 5) <= 0]], x,
relational=False) == \
Interval.Ropen(-1, 5)
assert reduce_rational_inequalities([[(x**2 + 4*x + 3)/(x - 1) > 0]], x,
relational=False) == \
Union(Interval.open(-3, -1), Interval.open(1, oo))
assert reduce_rational_inequalities([[(x**2 - 16)/(x - 1)**2 < 0]], x,
relational=False) == \
Union(Interval.open(-4, 1), Interval.open(1, 4))
assert reduce_rational_inequalities([[(3*x + 1)/(x + 4) >= 1]], x,
relational=False) == \
Union(Interval.open(-oo, -4), Interval.Ropen(Rational(3, 2), oo))
assert reduce_rational_inequalities([[(x - 8)/x <= 3 - x]], x,
relational=False) == \
Union(Interval.Lopen(-oo, -2), Interval.Lopen(0, 4))
def test_solve_poly_inequality():
assert psolve(Integer(0).as_poly(x), '==') == [S.ExtendedReals]
assert psolve(Integer(1).as_poly(x), '==') == [S.EmptySet]
assert psolve(PurePoly(x + 1, x), '>') == [Interval(-1, oo, True, False)]
pytest.raises(ValueError, lambda: psolve(x, '=='))
pytest.raises(ValueError, lambda: psolve(x.as_poly(), '??'))
assert (solve_poly_inequalities(
(((x**2 - 3).as_poly(), '>'),
((-x**2 + 1).as_poly(),
'>'))) == Union(Interval(-oo, -sqrt(3), False, True),
Interval(-1, 1, True, True),
Interval(sqrt(3), oo, True, 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 3 not in Complement(Interval(0, 5), Interval(1, 4), evaluate=False)
assert -1 in Complement(S.Reals, S.Naturals, evaluate=False)
assert 1 not in Complement(S.Reals, S.Naturals, evaluate=False)
assert Complement(S.Integers, S.UniversalSet) == EmptySet()
assert S.UniversalSet.complement(S.Integers) == EmptySet()
assert (0 not in S.Reals.intersection(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)))
def test_solve_univariate_inequality():
assert isolve(x**2 >= 4,
x, relational=False) == Union(Interval(-oo, -2),
Interval(2, oo))
assert isolve(x**2 >= 4, x) == (Integer(2) <= x) | (x <= -2)
assert isolve((x - 1)*(x - 2)*(x - 3) >= 0, x, relational=False) == \
Union(Interval(1, 2), Interval(3, oo))
assert isolve((x - 1)*(x - 2)*(x - 3) >= 0, x) == \
((Integer(1) <= x) & (x <= 2)) | (Integer(3) <= x)
# issue sympy/sympy#2785:
assert isolve(x**3 - 2*x - 1 > 0, x, relational=False) == \
Union(Interval(-1, -sqrt(5)/2 + Rational(1, 2), True, True),
Interval(Rational(1, 2) + sqrt(5)/2, oo, True))
# issue sympy/sympy#2794:
assert isolve(x**3 - x**2 + x - 1 > 0, x, relational=False) == \
Interval(1, oo, True)
# XXX should be limited in domain, e.g. between 0 and 2*pi
assert isolve(sin(x) < Rational(1, 2),
x) == (x < pi / 6) | (5 * pi / 6 < x)
assert isolve(sin(x) > Rational(1, 2),
x) == (pi / 6 < x) & (x < 5 * pi / 6)
# numerical testing in valid() is needed
assert isolve(x**7 - x - 2 > 0, x) == (RootOf(x**7 - x - 2, 0) < x)
# handle numerator and denominator; although these would be handled as
# rational inequalities, these test confirm that the right thing is done
# when the domain is EX (e.g. when 2 is replaced with sqrt(2))
assert isolve(1 / (x - 2) > 0, x) == (Integer(2) < x)
den = ((x - 1) * (x - 2)).expand()
assert isolve((x - 1) / den <= 0,
x) == (x < 1) | ((Integer(1) < x) & (x < 2))
assert isolve(x > oo, x) is false
# issue sympy/sympy#10268
assert reduce_inequalities(log(x) < 300) == (-oo < x) & (x < E**300)
def test_union_contains():
i1 = Interval(0, 1)
i2 = Interval(2, 3)
i3 = Union(i1, i2)
pytest.raises(TypeError, lambda: x in i3)
e = i3.contains(x)
assert e == Or(And(0 <= x, x <= 1), And(2 <= x, x <= 3))
assert e.subs(x, -0.5) is false
assert e.subs(x, 0.5) is true
assert e.subs(x, 1.5) is false
assert e.subs(x, 2.5) is true
assert e.subs(x, 3.5) is false
U = Interval(0, 2, True, True) + Interval(10, oo) + FiniteSet(-1, 2, 5, 6)
assert all(el not in U for el in [0, 4, -oo])
assert all(el in U for el in [2, 5, 10])
def test_finite_basic():
assert isinstance(FiniteSet(evaluate=False), FiniteSet)
A = FiniteSet(1, 2, 3)
B = FiniteSet(3, 4, 5)
AorB = Union(A, B)
AandB = A.intersection(B)
assert A.is_subset(AorB) and B.is_subset(AorB)
assert AandB.is_subset(A)
assert AandB == FiniteSet(3)
assert A.inf == 1 and A.sup == 3
assert AorB.inf == 1 and AorB.sup == 5
assert FiniteSet(x, 1, 5).sup == Max(x, 5)
assert FiniteSet(x, 1, 5).inf == Min(x, 1)
# issue sympy/sympy#7335
assert FiniteSet(S.EmptySet) != S.EmptySet
assert FiniteSet(FiniteSet(1, 2, 3)) != FiniteSet(1, 2, 3)
assert FiniteSet((1, 2, 3)) != FiniteSet(1, 2, 3)
# Ensure a variety of types can exist in a FiniteSet
assert FiniteSet((1, 2), Float, A, -5, x, 'eggs', x**2, Interval)
assert (A > B) is False
assert (A >= B) is False
assert (A < B) is False
assert (A <= B) is False
assert AorB > A and AorB > B
assert AorB >= A and AorB >= B
assert A >= A and A <= A # pylint: disable=comparison-with-itself
assert A >= AandB and B >= AandB
assert A > AandB and B > AandB
assert (FiniteSet(pi, E).evalf() == FiniteSet(
Float('2.7182818284590451', dps=15), Float('3.1415926535897931',
dps=15)))
# issue sympy/sympy#10337
assert (FiniteSet(2) == 3) is False
assert (FiniteSet(2) != 3) is True
pytest.raises(TypeError, lambda: FiniteSet(2) < 3)
pytest.raises(TypeError, lambda: FiniteSet(2) <= 3)
pytest.raises(TypeError, lambda: FiniteSet(2) > 3)
pytest.raises(TypeError, lambda: FiniteSet(2) >= 3)
def test_complement():
assert Interval(0, 1).complement(S.Reals) == \
Union(Interval(-oo, 0, True, True), Interval(1, oo, True, True))
assert Interval(0, 1, True, False).complement(S.Reals) == \
Union(Interval(-oo, 0, True, False), Interval(1, oo, True, True))
assert Interval(0, 1, False, True).complement(S.Reals) == \
Union(Interval(-oo, 0, True, True), Interval(1, oo, False, True))
assert Interval(0, 1, True, True).complement(S.Reals) == \
Union(Interval(-oo, 0, True, False), Interval(1, oo, False, True))
assert S.UniversalSet.complement(S.EmptySet) == S.EmptySet
assert S.UniversalSet.complement(S.Reals) == S.EmptySet
assert S.UniversalSet.complement(S.UniversalSet) == S.EmptySet
assert S.EmptySet.complement(S.Reals) == S.Reals
assert Union(Interval(0, 1), Interval(2, 3)).complement(S.Reals) == \
Union(Interval(-oo, 0, True, True), Interval(1, 2, True, True),
Interval(3, oo, True, True))
assert FiniteSet(0).complement(S.Reals) == \
Union(Interval(-oo, 0, True, True), Interval(0, oo, True, True))
assert (FiniteSet(5) + Interval(-oo,
0)).complement(S.Reals) == \
Interval(0, 5, True, True) + Interval(5, oo, True, True)
assert FiniteSet(1, 2, 3).complement(S.Reals) == \
Interval(-oo, 1, True, True) + \
Interval(1, 2, True, True) + Interval(2, 3, True, True) +\
Interval(3, oo, True, True)
assert FiniteSet(x).complement(S.Reals) == Complement(
S.Reals, FiniteSet(x))
assert FiniteSet(0, x).complement(S.Reals) == Complement(
Interval(-oo, 0, True, True) + Interval(0, oo, True, True),
FiniteSet(x),
evaluate=False)
square = Interval(0, 1) * Interval(0, 1)
notsquare = square.complement(S.Reals * S.Reals)
assert all(pt in square for pt in [(0, 0), (.5, .5), (1, 0), (1, 1)])
assert not any(pt in notsquare
for pt in [(0, 0), (.5, .5), (1, 0), (1, 1)])
assert not any(pt in square for pt in [(-1, 0), (1.5, .5), (10, 10)])
assert all(pt in notsquare for pt in [(-1, 0), (1.5, .5), (10, 10)])
def test_Eq():
assert Eq(Interval(0, 1), Interval(0, 1))
assert Eq(Interval(0, 1), Union(Interval(2, 3),
Interval(4, 5))).is_Equality
assert Eq(Interval(0, 1), Interval(0, 2)) is S.false
s1 = FiniteSet(0, 1)
s2 = FiniteSet(1, 2)
assert Eq(s1, s1)
assert Eq(s1, s2) is S.false
assert Eq(FiniteSet(1, 2), FiniteSet(3, 4, 5)) is S.false
assert Eq(s1*s2, s1*s2)
assert Eq(s1*s2, s2*s1) is S.false
p1 = ProductSet(FiniteSet(1), FiniteSet(2))
assert Eq(p1, s1).is_Equality
p2 = ProductSet(FiniteSet(1), FiniteSet(2), FiniteSet(3))
assert Eq(p1, p2) is S.false
def test_finite_basic():
assert isinstance(FiniteSet(evaluate=False), FiniteSet)
A = FiniteSet(1, 2, 3)
B = FiniteSet(3, 4, 5)
AorB = Union(A, B)
AandB = A.intersection(B)
assert A.is_subset(AorB) and B.is_subset(AorB)
assert AandB.is_subset(A)
assert AandB == FiniteSet(3)
assert A.inf == 1 and A.sup == 3
assert AorB.inf == 1 and AorB.sup == 5
assert FiniteSet(x, 1, 5).sup == Max(x, 5)
assert FiniteSet(x, 1, 5).inf == Min(x, 1)
# issue sympy/sympy#7335
assert FiniteSet(S.EmptySet) != S.EmptySet
assert FiniteSet(FiniteSet(1, 2, 3)) != FiniteSet(1, 2, 3)
assert FiniteSet((1, 2, 3)) != FiniteSet(1, 2, 3)
# Ensure a variety of types can exist in a FiniteSet
assert FiniteSet((1, 2), Float, A, -5, x, 'eggs', x**2, Interval)
assert (A > B) is False
assert (A >= B) is False
assert (A < B) is False
assert (A <= B) is False
assert AorB > A and AorB > B
assert AorB >= A and AorB >= B
assert A >= A and A <= A
assert A >= AandB and B >= AandB
assert A > AandB and B > AandB
assert (FiniteSet(pi, E).evalf() ==
FiniteSet(Float('2.7182818284590451', prec=15),
Float('3.1415926535897931', prec=15)))
def test_reduce_poly_inequalities_real_interval():
assert reduce_rational_inequalities(
[[Eq(x**2, 0)]], x, relational=False) == FiniteSet(0)
assert reduce_rational_inequalities(
[[Le(x**2, 0)]], x, relational=False) == FiniteSet(0)
assert reduce_rational_inequalities(
[[Lt(x**2, 0)]], x, relational=False) == S.EmptySet
assert reduce_rational_inequalities(
[[Ge(x**2, 0)]], x, relational=False) == \
S.Reals if x.is_extended_real else Interval(-oo, oo)
assert reduce_rational_inequalities(
[[Gt(x**2, 0)]], x, relational=False) == \
FiniteSet(0).complement(S.Reals)
assert reduce_rational_inequalities(
[[Ne(x**2, 0)]], x, relational=False) == \
FiniteSet(0).complement(S.Reals)
assert reduce_rational_inequalities(
[[Eq(x**2, 1)]], x, relational=False) == FiniteSet(-1, 1)
assert reduce_rational_inequalities(
[[Le(x**2, 1)]], x, relational=False) == Interval(-1, 1)
assert reduce_rational_inequalities(
[[Lt(x**2, 1)]], x, relational=False) == Interval(-1, 1, True, True)
assert reduce_rational_inequalities(
[[Ge(x**2, 1)]], x, relational=False) == \
Union(Interval(-oo, -1, True), Interval(1, oo, False, True))
assert reduce_rational_inequalities(
[[Gt(x**2, 1)]], x, relational=False) == \
Interval(-1, 1).complement(S.Reals)
assert reduce_rational_inequalities(
[[Ne(x**2, 1)]], x, relational=False) == \
FiniteSet(-1, 1).complement(S.Reals)
assert reduce_rational_inequalities([[Eq(
x**2, 1.0)]], x, relational=False) == FiniteSet(-1.0, 1.0).evalf()
assert reduce_rational_inequalities(
[[Le(x**2, 1.0)]], x, relational=False) == Interval(-1.0, 1.0)
assert reduce_rational_inequalities([[Lt(
x**2, 1.0)]], x, relational=False) == Interval(-1.0, 1.0, True, True)
assert reduce_rational_inequalities(
[[Ge(x**2, 1.0)]], x, relational=False) == \
Union(Interval(-inf, -1.0, True), Interval(1.0, inf, False, True))
assert reduce_rational_inequalities(
[[Gt(x**2, 1.0)]], x, relational=False) == \
Union(Interval(-inf, -1.0, True, True),
Interval(1.0, inf, True, True))
assert reduce_rational_inequalities([[Ne(
x**2, 1.0)]], x, relational=False) == \
FiniteSet(-1.0, 1.0).complement(S.Reals)
s = sqrt(2)
assert reduce_rational_inequalities([[Lt(
x**2 - 1, 0), Gt(x**2 - 1, 0)]], x, relational=False) == S.EmptySet
assert reduce_rational_inequalities([[Le(x**2 - 1, 0), Ge(
x**2 - 1, 0)]], x, relational=False) == FiniteSet(-1, 1)
assert reduce_rational_inequalities(
[[Le(x**2 - 2, 0), Ge(x**2 - 1, 0)]], x, relational=False
) == Union(Interval(-s, -1, False, False), Interval(1, s, False, False))
assert reduce_rational_inequalities(
[[Le(x**2 - 2, 0), Gt(x**2 - 1, 0)]], x, relational=False
) == Union(Interval(-s, -1, False, True), Interval(1, s, True, False))
assert reduce_rational_inequalities(
[[Lt(x**2 - 2, 0), Ge(x**2 - 1, 0)]], x, relational=False
) == Union(Interval(-s, -1, True, False), Interval(1, s, False, True))
assert reduce_rational_inequalities(
[[Lt(x**2 - 2, 0), Gt(x**2 - 1, 0)]], x, relational=False
) == Union(Interval(-s, -1, True, True), Interval(1, s, True, True))
assert reduce_rational_inequalities(
[[Lt(x**2 - 2, 0), Ne(x**2 - 1, 0)]], x, relational=False
) == Union(Interval(-s, -1, True, True), Interval(-1, 1, True, True),
Interval(1, s, True, True))
# issue sympy/sympy#10237
assert reduce_rational_inequalities(
[[x < oo, x >= 0, -oo < x]], x, relational=False) == Interval(0, oo, False, True)
assert reduce_rational_inequalities([[Eq((x + 1)/(x**2 - 1),
0)]], x) is S.false
def test_sympyissue_9956():
assert Union(Interval(-oo, oo), FiniteSet(1)) == Interval(-oo, oo)
assert Interval(-oo, oo).contains(1) is S.true
def test_union_boundary_of_joining_sets():
""" Testing the boundary of unions is a hard problem """
assert (Union(Interval(0, 10), Interval(10, 15), evaluate=False).boundary ==
FiniteSet(0, 15))
