예제 #1
0
def test_infinitely_indexed_set_1():
    assert imageset(Lambda(n, n),
                    S.Integers) == imageset(Lambda(m, m), S.Integers)

    assert (imageset(Lambda(n, 2 * n), S.Integers).intersection(
        imageset(Lambda(m, 2 * m + 1), S.Integers)) == EmptySet())

    assert (imageset(Lambda(n, 2 * n), S.Integers).intersection(
        imageset(Lambda(n, 2 * n + 1), S.Integers)) == EmptySet())

    assert (imageset(Lambda(m, 2 * m), S.Integers).intersection(
        imageset(Lambda(n, 3 * n),
                 S.Integers)) == ImageSet(Lambda(t, 6 * t), S.Integers))
예제 #2
0
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)))
예제 #3
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()
예제 #4
0
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)))
예제 #5
0
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
예제 #6
0
def test_bool_as_set():
    assert ((x <= 2) & (x >= -2)).as_set() == Interval(-2, 2)
    assert ((x >= 2) | (x <= -2)).as_set() == (Interval(-oo, -2) + Interval(2, oo, False))
    assert Not(x > 2, evaluate=False).as_set() == Interval(-oo, 2, True)
    assert true.as_set() == S.UniversalSet
    assert false.as_set() == EmptySet()