1307 lines
50 KiB
Python
1307 lines
50 KiB
Python
|
|
from sympy.core.expr import unchanged
|
|
from sympy.sets.contains import Contains
|
|
from sympy.sets.fancysets import (ImageSet, Range, normalize_theta_set,
|
|
ComplexRegion)
|
|
from sympy.sets.sets import (FiniteSet, Interval, Union, imageset,
|
|
Intersection, ProductSet, SetKind)
|
|
from sympy.sets.conditionset import ConditionSet
|
|
from sympy.simplify.simplify import simplify
|
|
from sympy.core.basic import Basic
|
|
from sympy.core.containers import Tuple, TupleKind
|
|
from sympy.core.function import Lambda
|
|
from sympy.core.kind import NumberKind
|
|
from sympy.core.numbers import (I, Rational, oo, pi)
|
|
from sympy.core.relational import Eq
|
|
from sympy.core.singleton import S
|
|
from sympy.core.symbol import (Dummy, Symbol, symbols)
|
|
from sympy.functions.elementary.complexes import Abs
|
|
from sympy.functions.elementary.exponential import (exp, log)
|
|
from sympy.functions.elementary.integers import floor
|
|
from sympy.functions.elementary.miscellaneous import sqrt
|
|
from sympy.functions.elementary.trigonometric import (cos, sin, tan)
|
|
from sympy.logic.boolalg import And
|
|
from sympy.matrices.dense import eye
|
|
from sympy.testing.pytest import XFAIL, raises
|
|
from sympy.abc import x, y, t, z
|
|
from sympy.core.mod import Mod
|
|
|
|
import itertools
|
|
|
|
|
|
def test_naturals():
|
|
N = S.Naturals
|
|
assert 5 in N
|
|
assert -5 not in N
|
|
assert 5.5 not in N
|
|
ni = iter(N)
|
|
a, b, c, d = next(ni), next(ni), next(ni), next(ni)
|
|
assert (a, b, c, d) == (1, 2, 3, 4)
|
|
assert isinstance(a, Basic)
|
|
|
|
assert N.intersect(Interval(-5, 5)) == Range(1, 6)
|
|
assert N.intersect(Interval(-5, 5, True, True)) == Range(1, 5)
|
|
|
|
assert N.boundary == N
|
|
assert N.is_open == False
|
|
assert N.is_closed == True
|
|
|
|
assert N.inf == 1
|
|
assert N.sup is oo
|
|
assert not N.contains(oo)
|
|
for s in (S.Naturals0, S.Naturals):
|
|
assert s.intersection(S.Reals) is s
|
|
assert s.is_subset(S.Reals)
|
|
|
|
assert N.as_relational(x) == And(Eq(floor(x), x), x >= 1, x < oo)
|
|
|
|
|
|
def test_naturals0():
|
|
N = S.Naturals0
|
|
assert 0 in N
|
|
assert -1 not in N
|
|
assert next(iter(N)) == 0
|
|
assert not N.contains(oo)
|
|
assert N.contains(sin(x)) == Contains(sin(x), N)
|
|
|
|
|
|
def test_integers():
|
|
Z = S.Integers
|
|
assert 5 in Z
|
|
assert -5 in Z
|
|
assert 5.5 not in Z
|
|
assert not Z.contains(oo)
|
|
assert not Z.contains(-oo)
|
|
|
|
zi = iter(Z)
|
|
a, b, c, d = next(zi), next(zi), next(zi), next(zi)
|
|
assert (a, b, c, d) == (0, 1, -1, 2)
|
|
assert isinstance(a, Basic)
|
|
|
|
assert Z.intersect(Interval(-5, 5)) == Range(-5, 6)
|
|
assert Z.intersect(Interval(-5, 5, True, True)) == Range(-4, 5)
|
|
assert Z.intersect(Interval(5, S.Infinity)) == Range(5, S.Infinity)
|
|
assert Z.intersect(Interval.Lopen(5, S.Infinity)) == Range(6, S.Infinity)
|
|
|
|
assert Z.inf is -oo
|
|
assert Z.sup is oo
|
|
|
|
assert Z.boundary == Z
|
|
assert Z.is_open == False
|
|
assert Z.is_closed == True
|
|
|
|
assert Z.as_relational(x) == And(Eq(floor(x), x), -oo < x, x < oo)
|
|
|
|
|
|
def test_ImageSet():
|
|
raises(ValueError, lambda: ImageSet(x, S.Integers))
|
|
assert ImageSet(Lambda(x, 1), S.Integers) == FiniteSet(1)
|
|
assert ImageSet(Lambda(x, y), S.Integers) == {y}
|
|
assert ImageSet(Lambda(x, 1), S.EmptySet) == S.EmptySet
|
|
empty = Intersection(FiniteSet(log(2)/pi), S.Integers)
|
|
assert unchanged(ImageSet, Lambda(x, 1), empty) # issue #17471
|
|
squares = ImageSet(Lambda(x, x**2), S.Naturals)
|
|
assert 4 in squares
|
|
assert 5 not in squares
|
|
assert FiniteSet(*range(10)).intersect(squares) == FiniteSet(1, 4, 9)
|
|
|
|
assert 16 not in squares.intersect(Interval(0, 10))
|
|
|
|
si = iter(squares)
|
|
a, b, c, d = next(si), next(si), next(si), next(si)
|
|
assert (a, b, c, d) == (1, 4, 9, 16)
|
|
|
|
harmonics = ImageSet(Lambda(x, 1/x), S.Naturals)
|
|
assert Rational(1, 5) in harmonics
|
|
assert Rational(.25) in harmonics
|
|
assert 0.25 not in harmonics
|
|
assert Rational(.3) not in harmonics
|
|
assert (1, 2) not in harmonics
|
|
|
|
assert harmonics.is_iterable
|
|
|
|
assert imageset(x, -x, Interval(0, 1)) == Interval(-1, 0)
|
|
|
|
assert ImageSet(Lambda(x, x**2), Interval(0, 2)).doit() == Interval(0, 4)
|
|
assert ImageSet(Lambda((x, y), 2*x), {4}, {3}).doit() == FiniteSet(8)
|
|
assert (ImageSet(Lambda((x, y), x+y), {1, 2, 3}, {10, 20, 30}).doit() ==
|
|
FiniteSet(11, 12, 13, 21, 22, 23, 31, 32, 33))
|
|
|
|
c = Interval(1, 3) * Interval(1, 3)
|
|
assert Tuple(2, 6) in ImageSet(Lambda(((x, y),), (x, 2*y)), c)
|
|
assert Tuple(2, S.Half) in ImageSet(Lambda(((x, y),), (x, 1/y)), c)
|
|
assert Tuple(2, -2) not in ImageSet(Lambda(((x, y),), (x, y**2)), c)
|
|
assert Tuple(2, -2) in ImageSet(Lambda(((x, y),), (x, -2)), c)
|
|
c3 = ProductSet(Interval(3, 7), Interval(8, 11), Interval(5, 9))
|
|
assert Tuple(8, 3, 9) in ImageSet(Lambda(((t, y, x),), (y, t, x)), c3)
|
|
assert Tuple(Rational(1, 8), 3, 9) in ImageSet(Lambda(((t, y, x),), (1/y, t, x)), c3)
|
|
assert 2/pi not in ImageSet(Lambda(((x, y),), 2/x), c)
|
|
assert 2/S(100) not in ImageSet(Lambda(((x, y),), 2/x), c)
|
|
assert Rational(2, 3) in ImageSet(Lambda(((x, y),), 2/x), c)
|
|
|
|
S1 = imageset(lambda x, y: x + y, S.Integers, S.Naturals)
|
|
assert S1.base_pset == ProductSet(S.Integers, S.Naturals)
|
|
assert S1.base_sets == (S.Integers, S.Naturals)
|
|
|
|
# Passing a set instead of a FiniteSet shouldn't raise
|
|
assert unchanged(ImageSet, Lambda(x, x**2), {1, 2, 3})
|
|
|
|
S2 = ImageSet(Lambda(((x, y),), x+y), {(1, 2), (3, 4)})
|
|
assert 3 in S2.doit()
|
|
# FIXME: This doesn't yet work:
|
|
#assert 3 in S2
|
|
assert S2._contains(3) is None
|
|
|
|
raises(TypeError, lambda: ImageSet(Lambda(x, x**2), 1))
|
|
|
|
|
|
def test_image_is_ImageSet():
|
|
assert isinstance(imageset(x, sqrt(sin(x)), Range(5)), ImageSet)
|
|
|
|
|
|
def test_halfcircle():
|
|
r, th = symbols('r, theta', real=True)
|
|
L = Lambda(((r, th),), (r*cos(th), r*sin(th)))
|
|
halfcircle = ImageSet(L, Interval(0, 1)*Interval(0, pi))
|
|
|
|
assert (1, 0) in halfcircle
|
|
assert (0, -1) not in halfcircle
|
|
assert (0, 0) in halfcircle
|
|
assert halfcircle._contains((r, 0)) is None
|
|
# This one doesn't work:
|
|
#assert (r, 2*pi) not in halfcircle
|
|
|
|
assert not halfcircle.is_iterable
|
|
|
|
|
|
def test_ImageSet_iterator_not_injective():
|
|
L = Lambda(x, x - x % 2) # produces 0, 2, 2, 4, 4, 6, 6, ...
|
|
evens = ImageSet(L, S.Naturals)
|
|
i = iter(evens)
|
|
# No repeats here
|
|
assert (next(i), next(i), next(i), next(i)) == (0, 2, 4, 6)
|
|
|
|
|
|
def test_inf_Range_len():
|
|
raises(ValueError, lambda: len(Range(0, oo, 2)))
|
|
assert Range(0, oo, 2).size is S.Infinity
|
|
assert Range(0, -oo, -2).size is S.Infinity
|
|
assert Range(oo, 0, -2).size is S.Infinity
|
|
assert Range(-oo, 0, 2).size is S.Infinity
|
|
|
|
|
|
def test_Range_set():
|
|
empty = Range(0)
|
|
|
|
assert Range(5) == Range(0, 5) == Range(0, 5, 1)
|
|
|
|
r = Range(10, 20, 2)
|
|
assert 12 in r
|
|
assert 8 not in r
|
|
assert 11 not in r
|
|
assert 30 not in r
|
|
|
|
assert list(Range(0, 5)) == list(range(5))
|
|
assert list(Range(5, 0, -1)) == list(range(5, 0, -1))
|
|
|
|
|
|
assert Range(5, 15).sup == 14
|
|
assert Range(5, 15).inf == 5
|
|
assert Range(15, 5, -1).sup == 15
|
|
assert Range(15, 5, -1).inf == 6
|
|
assert Range(10, 67, 10).sup == 60
|
|
assert Range(60, 7, -10).inf == 10
|
|
|
|
assert len(Range(10, 38, 10)) == 3
|
|
|
|
assert Range(0, 0, 5) == empty
|
|
assert Range(oo, oo, 1) == empty
|
|
assert Range(oo, 1, 1) == empty
|
|
assert Range(-oo, 1, -1) == empty
|
|
assert Range(1, oo, -1) == empty
|
|
assert Range(1, -oo, 1) == empty
|
|
assert Range(1, -4, oo) == empty
|
|
ip = symbols('ip', positive=True)
|
|
assert Range(0, ip, -1) == empty
|
|
assert Range(0, -ip, 1) == empty
|
|
assert Range(1, -4, -oo) == Range(1, 2)
|
|
assert Range(1, 4, oo) == Range(1, 2)
|
|
assert Range(-oo, oo).size == oo
|
|
assert Range(oo, -oo, -1).size == oo
|
|
raises(ValueError, lambda: Range(-oo, oo, 2))
|
|
raises(ValueError, lambda: Range(x, pi, y))
|
|
raises(ValueError, lambda: Range(x, y, 0))
|
|
|
|
assert 5 in Range(0, oo, 5)
|
|
assert -5 in Range(-oo, 0, 5)
|
|
assert oo not in Range(0, oo)
|
|
ni = symbols('ni', integer=False)
|
|
assert ni not in Range(oo)
|
|
u = symbols('u', integer=None)
|
|
assert Range(oo).contains(u) is not False
|
|
inf = symbols('inf', infinite=True)
|
|
assert inf not in Range(-oo, oo)
|
|
raises(ValueError, lambda: Range(0, oo, 2)[-1])
|
|
raises(ValueError, lambda: Range(0, -oo, -2)[-1])
|
|
assert Range(-oo, 1, 1)[-1] is S.Zero
|
|
assert Range(oo, 1, -1)[-1] == 2
|
|
assert inf not in Range(oo)
|
|
assert Range(1, 10, 1)[-1] == 9
|
|
assert all(i.is_Integer for i in Range(0, -1, 1))
|
|
it = iter(Range(-oo, 0, 2))
|
|
raises(TypeError, lambda: next(it))
|
|
|
|
assert empty.intersect(S.Integers) == empty
|
|
assert Range(-1, 10, 1).intersect(S.Complexes) == Range(-1, 10, 1)
|
|
assert Range(-1, 10, 1).intersect(S.Reals) == Range(-1, 10, 1)
|
|
assert Range(-1, 10, 1).intersect(S.Rationals) == Range(-1, 10, 1)
|
|
assert Range(-1, 10, 1).intersect(S.Integers) == Range(-1, 10, 1)
|
|
assert Range(-1, 10, 1).intersect(S.Naturals) == Range(1, 10, 1)
|
|
assert Range(-1, 10, 1).intersect(S.Naturals0) == Range(0, 10, 1)
|
|
|
|
# test slicing
|
|
assert Range(1, 10, 1)[5] == 6
|
|
assert Range(1, 12, 2)[5] == 11
|
|
assert Range(1, 10, 1)[-1] == 9
|
|
assert Range(1, 10, 3)[-1] == 7
|
|
raises(ValueError, lambda: Range(oo,0,-1)[1:3:0])
|
|
raises(ValueError, lambda: Range(oo,0,-1)[:1])
|
|
raises(ValueError, lambda: Range(1, oo)[-2])
|
|
raises(ValueError, lambda: Range(-oo, 1)[2])
|
|
raises(IndexError, lambda: Range(10)[-20])
|
|
raises(IndexError, lambda: Range(10)[20])
|
|
raises(ValueError, lambda: Range(2, -oo, -2)[2:2:0])
|
|
assert Range(2, -oo, -2)[2:2:2] == empty
|
|
assert Range(2, -oo, -2)[:2:2] == Range(2, -2, -4)
|
|
raises(ValueError, lambda: Range(-oo, 4, 2)[:2:2])
|
|
assert Range(-oo, 4, 2)[::-2] == Range(2, -oo, -4)
|
|
raises(ValueError, lambda: Range(-oo, 4, 2)[::2])
|
|
assert Range(oo, 2, -2)[::] == Range(oo, 2, -2)
|
|
assert Range(-oo, 4, 2)[:-2:-2] == Range(2, 0, -4)
|
|
assert Range(-oo, 4, 2)[:-2:2] == Range(-oo, 0, 4)
|
|
raises(ValueError, lambda: Range(-oo, 4, 2)[:0:-2])
|
|
raises(ValueError, lambda: Range(-oo, 4, 2)[:2:-2])
|
|
assert Range(-oo, 4, 2)[-2::-2] == Range(0, -oo, -4)
|
|
raises(ValueError, lambda: Range(-oo, 4, 2)[-2:0:-2])
|
|
raises(ValueError, lambda: Range(-oo, 4, 2)[0::2])
|
|
assert Range(oo, 2, -2)[0::] == Range(oo, 2, -2)
|
|
raises(ValueError, lambda: Range(-oo, 4, 2)[0:-2:2])
|
|
assert Range(oo, 2, -2)[0:-2:] == Range(oo, 6, -2)
|
|
raises(ValueError, lambda: Range(oo, 2, -2)[0:2:])
|
|
raises(ValueError, lambda: Range(-oo, 4, 2)[2::-1])
|
|
assert Range(-oo, 4, 2)[-2::2] == Range(0, 4, 4)
|
|
assert Range(oo, 0, -2)[-10:0:2] == empty
|
|
raises(ValueError, lambda: Range(oo, 0, -2)[0])
|
|
raises(ValueError, lambda: Range(oo, 0, -2)[-10:10:2])
|
|
raises(ValueError, lambda: Range(oo, 0, -2)[0::-2])
|
|
assert Range(oo, 0, -2)[0:-4:-2] == empty
|
|
assert Range(oo, 0, -2)[:0:2] == empty
|
|
raises(ValueError, lambda: Range(oo, 0, -2)[:1:-1])
|
|
|
|
# test empty Range
|
|
assert Range(x, x, y) == empty
|
|
assert empty.reversed == empty
|
|
assert 0 not in empty
|
|
assert list(empty) == []
|
|
assert len(empty) == 0
|
|
assert empty.size is S.Zero
|
|
assert empty.intersect(FiniteSet(0)) is S.EmptySet
|
|
assert bool(empty) is False
|
|
raises(IndexError, lambda: empty[0])
|
|
assert empty[:0] == empty
|
|
raises(NotImplementedError, lambda: empty.inf)
|
|
raises(NotImplementedError, lambda: empty.sup)
|
|
assert empty.as_relational(x) is S.false
|
|
|
|
AB = [None] + list(range(12))
|
|
for R in [
|
|
Range(1, 10),
|
|
Range(1, 10, 2),
|
|
]:
|
|
r = list(R)
|
|
for a, b, c in itertools.product(AB, AB, [-3, -1, None, 1, 3]):
|
|
for reverse in range(2):
|
|
r = list(reversed(r))
|
|
R = R.reversed
|
|
result = list(R[a:b:c])
|
|
ans = r[a:b:c]
|
|
txt = ('\n%s[%s:%s:%s] = %s -> %s' % (
|
|
R, a, b, c, result, ans))
|
|
check = ans == result
|
|
assert check, txt
|
|
|
|
assert Range(1, 10, 1).boundary == Range(1, 10, 1)
|
|
|
|
for r in (Range(1, 10, 2), Range(1, oo, 2)):
|
|
rev = r.reversed
|
|
assert r.inf == rev.inf and r.sup == rev.sup
|
|
assert r.step == -rev.step
|
|
|
|
builtin_range = range
|
|
|
|
raises(TypeError, lambda: Range(builtin_range(1)))
|
|
assert S(builtin_range(10)) == Range(10)
|
|
assert S(builtin_range(1000000000000)) == Range(1000000000000)
|
|
|
|
# test Range.as_relational
|
|
assert Range(1, 4).as_relational(x) == (x >= 1) & (x <= 3) & Eq(Mod(x, 1), 0)
|
|
assert Range(oo, 1, -2).as_relational(x) == (x >= 3) & (x < oo) & Eq(Mod(x + 1, -2), 0)
|
|
|
|
|
|
def test_Range_symbolic():
|
|
# symbolic Range
|
|
xr = Range(x, x + 4, 5)
|
|
sr = Range(x, y, t)
|
|
i = Symbol('i', integer=True)
|
|
ip = Symbol('i', integer=True, positive=True)
|
|
ipr = Range(ip)
|
|
inr = Range(0, -ip, -1)
|
|
ir = Range(i, i + 19, 2)
|
|
ir2 = Range(i, i*8, 3*i)
|
|
i = Symbol('i', integer=True)
|
|
inf = symbols('inf', infinite=True)
|
|
raises(ValueError, lambda: Range(inf))
|
|
raises(ValueError, lambda: Range(inf, 0, -1))
|
|
raises(ValueError, lambda: Range(inf, inf, 1))
|
|
raises(ValueError, lambda: Range(1, 1, inf))
|
|
# args
|
|
assert xr.args == (x, x + 5, 5)
|
|
assert sr.args == (x, y, t)
|
|
assert ir.args == (i, i + 20, 2)
|
|
assert ir2.args == (i, 10*i, 3*i)
|
|
# reversed
|
|
raises(ValueError, lambda: xr.reversed)
|
|
raises(ValueError, lambda: sr.reversed)
|
|
assert ipr.reversed.args == (ip - 1, -1, -1)
|
|
assert inr.reversed.args == (-ip + 1, 1, 1)
|
|
assert ir.reversed.args == (i + 18, i - 2, -2)
|
|
assert ir2.reversed.args == (7*i, -2*i, -3*i)
|
|
# contains
|
|
assert inf not in sr
|
|
assert inf not in ir
|
|
assert 0 in ipr
|
|
assert 0 in inr
|
|
raises(TypeError, lambda: 1 in ipr)
|
|
raises(TypeError, lambda: -1 in inr)
|
|
assert .1 not in sr
|
|
assert .1 not in ir
|
|
assert i + 1 not in ir
|
|
assert i + 2 in ir
|
|
raises(TypeError, lambda: x in xr) # XXX is this what contains is supposed to do?
|
|
raises(TypeError, lambda: 1 in sr) # XXX is this what contains is supposed to do?
|
|
# iter
|
|
raises(ValueError, lambda: next(iter(xr)))
|
|
raises(ValueError, lambda: next(iter(sr)))
|
|
assert next(iter(ir)) == i
|
|
assert next(iter(ir2)) == i
|
|
assert sr.intersect(S.Integers) == sr
|
|
assert sr.intersect(FiniteSet(x)) == Intersection({x}, sr)
|
|
raises(ValueError, lambda: sr[:2])
|
|
raises(ValueError, lambda: xr[0])
|
|
raises(ValueError, lambda: sr[0])
|
|
# len
|
|
assert len(ir) == ir.size == 10
|
|
assert len(ir2) == ir2.size == 3
|
|
raises(ValueError, lambda: len(xr))
|
|
raises(ValueError, lambda: xr.size)
|
|
raises(ValueError, lambda: len(sr))
|
|
raises(ValueError, lambda: sr.size)
|
|
# bool
|
|
assert bool(Range(0)) == False
|
|
assert bool(xr)
|
|
assert bool(ir)
|
|
assert bool(ipr)
|
|
assert bool(inr)
|
|
raises(ValueError, lambda: bool(sr))
|
|
raises(ValueError, lambda: bool(ir2))
|
|
# inf
|
|
raises(ValueError, lambda: xr.inf)
|
|
raises(ValueError, lambda: sr.inf)
|
|
assert ipr.inf == 0
|
|
assert inr.inf == -ip + 1
|
|
assert ir.inf == i
|
|
raises(ValueError, lambda: ir2.inf)
|
|
# sup
|
|
raises(ValueError, lambda: xr.sup)
|
|
raises(ValueError, lambda: sr.sup)
|
|
assert ipr.sup == ip - 1
|
|
assert inr.sup == 0
|
|
assert ir.inf == i
|
|
raises(ValueError, lambda: ir2.sup)
|
|
# getitem
|
|
raises(ValueError, lambda: xr[0])
|
|
raises(ValueError, lambda: sr[0])
|
|
raises(ValueError, lambda: sr[-1])
|
|
raises(ValueError, lambda: sr[:2])
|
|
assert ir[:2] == Range(i, i + 4, 2)
|
|
assert ir[0] == i
|
|
assert ir[-2] == i + 16
|
|
assert ir[-1] == i + 18
|
|
assert ir2[:2] == Range(i, 7*i, 3*i)
|
|
assert ir2[0] == i
|
|
assert ir2[-2] == 4*i
|
|
assert ir2[-1] == 7*i
|
|
raises(ValueError, lambda: Range(i)[-1])
|
|
assert ipr[0] == ipr.inf == 0
|
|
assert ipr[-1] == ipr.sup == ip - 1
|
|
assert inr[0] == inr.sup == 0
|
|
assert inr[-1] == inr.inf == -ip + 1
|
|
raises(ValueError, lambda: ipr[-2])
|
|
assert ir.inf == i
|
|
assert ir.sup == i + 18
|
|
raises(ValueError, lambda: Range(i).inf)
|
|
# as_relational
|
|
assert ir.as_relational(x) == ((x >= i) & (x <= i + 18) &
|
|
Eq(Mod(-i + x, 2), 0))
|
|
assert ir2.as_relational(x) == Eq(
|
|
Mod(-i + x, 3*i), 0) & (((x >= i) & (x <= 7*i) & (3*i >= 1)) |
|
|
((x <= i) & (x >= 7*i) & (3*i <= -1)))
|
|
assert Range(i, i + 1).as_relational(x) == Eq(x, i)
|
|
assert sr.as_relational(z) == Eq(
|
|
Mod(t, 1), 0) & Eq(Mod(x, 1), 0) & Eq(Mod(-x + z, t), 0
|
|
) & (((z >= x) & (z <= -t + y) & (t >= 1)) |
|
|
((z <= x) & (z >= -t + y) & (t <= -1)))
|
|
assert xr.as_relational(z) == Eq(z, x) & Eq(Mod(x, 1), 0)
|
|
# symbols can clash if user wants (but it must be integer)
|
|
assert xr.as_relational(x) == Eq(Mod(x, 1), 0)
|
|
# contains() for symbolic values (issue #18146)
|
|
e = Symbol('e', integer=True, even=True)
|
|
o = Symbol('o', integer=True, odd=True)
|
|
assert Range(5).contains(i) == And(i >= 0, i <= 4)
|
|
assert Range(1).contains(i) == Eq(i, 0)
|
|
assert Range(-oo, 5, 1).contains(i) == (i <= 4)
|
|
assert Range(-oo, oo).contains(i) == True
|
|
assert Range(0, 8, 2).contains(i) == Contains(i, Range(0, 8, 2))
|
|
assert Range(0, 8, 2).contains(e) == And(e >= 0, e <= 6)
|
|
assert Range(0, 8, 2).contains(2*i) == And(2*i >= 0, 2*i <= 6)
|
|
assert Range(0, 8, 2).contains(o) == False
|
|
assert Range(1, 9, 2).contains(e) == False
|
|
assert Range(1, 9, 2).contains(o) == And(o >= 1, o <= 7)
|
|
assert Range(8, 0, -2).contains(o) == False
|
|
assert Range(9, 1, -2).contains(o) == And(o >= 3, o <= 9)
|
|
assert Range(-oo, 8, 2).contains(i) == Contains(i, Range(-oo, 8, 2))
|
|
|
|
|
|
def test_range_range_intersection():
|
|
for a, b, r in [
|
|
(Range(0), Range(1), S.EmptySet),
|
|
(Range(3), Range(4, oo), S.EmptySet),
|
|
(Range(3), Range(-3, -1), S.EmptySet),
|
|
(Range(1, 3), Range(0, 3), Range(1, 3)),
|
|
(Range(1, 3), Range(1, 4), Range(1, 3)),
|
|
(Range(1, oo, 2), Range(2, oo, 2), S.EmptySet),
|
|
(Range(0, oo, 2), Range(oo), Range(0, oo, 2)),
|
|
(Range(0, oo, 2), Range(100), Range(0, 100, 2)),
|
|
(Range(2, oo, 2), Range(oo), Range(2, oo, 2)),
|
|
(Range(0, oo, 2), Range(5, 6), S.EmptySet),
|
|
(Range(2, 80, 1), Range(55, 71, 4), Range(55, 71, 4)),
|
|
(Range(0, 6, 3), Range(-oo, 5, 3), S.EmptySet),
|
|
(Range(0, oo, 2), Range(5, oo, 3), Range(8, oo, 6)),
|
|
(Range(4, 6, 2), Range(2, 16, 7), S.EmptySet),]:
|
|
assert a.intersect(b) == r
|
|
assert a.intersect(b.reversed) == r
|
|
assert a.reversed.intersect(b) == r
|
|
assert a.reversed.intersect(b.reversed) == r
|
|
a, b = b, a
|
|
assert a.intersect(b) == r
|
|
assert a.intersect(b.reversed) == r
|
|
assert a.reversed.intersect(b) == r
|
|
assert a.reversed.intersect(b.reversed) == r
|
|
|
|
|
|
def test_range_interval_intersection():
|
|
p = symbols('p', positive=True)
|
|
assert isinstance(Range(3).intersect(Interval(p, p + 2)), Intersection)
|
|
assert Range(4).intersect(Interval(0, 3)) == Range(4)
|
|
assert Range(4).intersect(Interval(-oo, oo)) == Range(4)
|
|
assert Range(4).intersect(Interval(1, oo)) == Range(1, 4)
|
|
assert Range(4).intersect(Interval(1.1, oo)) == Range(2, 4)
|
|
assert Range(4).intersect(Interval(0.1, 3)) == Range(1, 4)
|
|
assert Range(4).intersect(Interval(0.1, 3.1)) == Range(1, 4)
|
|
assert Range(4).intersect(Interval.open(0, 3)) == Range(1, 3)
|
|
assert Range(4).intersect(Interval.open(0.1, 0.5)) is S.EmptySet
|
|
assert Interval(-1, 5).intersect(S.Complexes) == Interval(-1, 5)
|
|
assert Interval(-1, 5).intersect(S.Reals) == Interval(-1, 5)
|
|
assert Interval(-1, 5).intersect(S.Integers) == Range(-1, 6)
|
|
assert Interval(-1, 5).intersect(S.Naturals) == Range(1, 6)
|
|
assert Interval(-1, 5).intersect(S.Naturals0) == Range(0, 6)
|
|
|
|
# Null Range intersections
|
|
assert Range(0).intersect(Interval(0.2, 0.8)) is S.EmptySet
|
|
assert Range(0).intersect(Interval(-oo, oo)) is S.EmptySet
|
|
|
|
|
|
def test_range_is_finite_set():
|
|
assert Range(-100, 100).is_finite_set is True
|
|
assert Range(2, oo).is_finite_set is False
|
|
assert Range(-oo, 50).is_finite_set is False
|
|
assert Range(-oo, oo).is_finite_set is False
|
|
assert Range(oo, -oo).is_finite_set is True
|
|
assert Range(0, 0).is_finite_set is True
|
|
assert Range(oo, oo).is_finite_set is True
|
|
assert Range(-oo, -oo).is_finite_set is True
|
|
n = Symbol('n', integer=True)
|
|
m = Symbol('m', integer=True)
|
|
assert Range(n, n + 49).is_finite_set is True
|
|
assert Range(n, 0).is_finite_set is True
|
|
assert Range(-3, n + 7).is_finite_set is True
|
|
assert Range(n, m).is_finite_set is True
|
|
assert Range(n + m, m - n).is_finite_set is True
|
|
assert Range(n, n + m + n).is_finite_set is True
|
|
assert Range(n, oo).is_finite_set is False
|
|
assert Range(-oo, n).is_finite_set is False
|
|
assert Range(n, -oo).is_finite_set is True
|
|
assert Range(oo, n).is_finite_set is True
|
|
|
|
|
|
def test_Range_is_iterable():
|
|
assert Range(-100, 100).is_iterable is True
|
|
assert Range(2, oo).is_iterable is False
|
|
assert Range(-oo, 50).is_iterable is False
|
|
assert Range(-oo, oo).is_iterable is False
|
|
assert Range(oo, -oo).is_iterable is True
|
|
assert Range(0, 0).is_iterable is True
|
|
assert Range(oo, oo).is_iterable is True
|
|
assert Range(-oo, -oo).is_iterable is True
|
|
n = Symbol('n', integer=True)
|
|
m = Symbol('m', integer=True)
|
|
p = Symbol('p', integer=True, positive=True)
|
|
assert Range(n, n + 49).is_iterable is True
|
|
assert Range(n, 0).is_iterable is False
|
|
assert Range(-3, n + 7).is_iterable is False
|
|
assert Range(-3, p + 7).is_iterable is False # Should work with better __iter__
|
|
assert Range(n, m).is_iterable is False
|
|
assert Range(n + m, m - n).is_iterable is False
|
|
assert Range(n, n + m + n).is_iterable is False
|
|
assert Range(n, oo).is_iterable is False
|
|
assert Range(-oo, n).is_iterable is False
|
|
x = Symbol('x')
|
|
assert Range(x, x + 49).is_iterable is False
|
|
assert Range(x, 0).is_iterable is False
|
|
assert Range(-3, x + 7).is_iterable is False
|
|
assert Range(x, m).is_iterable is False
|
|
assert Range(x + m, m - x).is_iterable is False
|
|
assert Range(x, x + m + x).is_iterable is False
|
|
assert Range(x, oo).is_iterable is False
|
|
assert Range(-oo, x).is_iterable is False
|
|
|
|
|
|
def test_Integers_eval_imageset():
|
|
ans = ImageSet(Lambda(x, 2*x + Rational(3, 7)), S.Integers)
|
|
im = imageset(Lambda(x, -2*x + Rational(3, 7)), S.Integers)
|
|
assert im == ans
|
|
im = imageset(Lambda(x, -2*x - Rational(11, 7)), S.Integers)
|
|
assert im == ans
|
|
y = Symbol('y')
|
|
L = imageset(x, 2*x + y, S.Integers)
|
|
assert y + 4 in L
|
|
a, b, c = 0.092, 0.433, 0.341
|
|
assert a in imageset(x, a + c*x, S.Integers)
|
|
assert b in imageset(x, b + c*x, S.Integers)
|
|
|
|
_x = symbols('x', negative=True)
|
|
eq = _x**2 - _x + 1
|
|
assert imageset(_x, eq, S.Integers).lamda.expr == _x**2 + _x + 1
|
|
eq = 3*_x - 1
|
|
assert imageset(_x, eq, S.Integers).lamda.expr == 3*_x + 2
|
|
|
|
assert imageset(x, (x, 1/x), S.Integers) == \
|
|
ImageSet(Lambda(x, (x, 1/x)), S.Integers)
|
|
|
|
|
|
def test_Range_eval_imageset():
|
|
a, b, c = symbols('a b c')
|
|
assert imageset(x, a*(x + b) + c, Range(3)) == \
|
|
imageset(x, a*x + a*b + c, Range(3))
|
|
eq = (x + 1)**2
|
|
assert imageset(x, eq, Range(3)).lamda.expr == eq
|
|
eq = a*(x + b) + c
|
|
r = Range(3, -3, -2)
|
|
imset = imageset(x, eq, r)
|
|
assert imset.lamda.expr != eq
|
|
assert list(imset) == [eq.subs(x, i).expand() for i in list(r)]
|
|
|
|
|
|
def test_fun():
|
|
assert (FiniteSet(*ImageSet(Lambda(x, sin(pi*x/4)),
|
|
Range(-10, 11))) == FiniteSet(-1, -sqrt(2)/2, 0, sqrt(2)/2, 1))
|
|
|
|
|
|
def test_Range_is_empty():
|
|
i = Symbol('i', integer=True)
|
|
n = Symbol('n', negative=True, integer=True)
|
|
p = Symbol('p', positive=True, integer=True)
|
|
|
|
assert Range(0).is_empty
|
|
assert not Range(1).is_empty
|
|
assert Range(1, 0).is_empty
|
|
assert not Range(-1, 0).is_empty
|
|
assert Range(i).is_empty is None
|
|
assert Range(n).is_empty
|
|
assert Range(p).is_empty is False
|
|
assert Range(n, 0).is_empty is False
|
|
assert Range(n, p).is_empty is False
|
|
assert Range(p, n).is_empty
|
|
assert Range(n, -1).is_empty is None
|
|
assert Range(p, n, -1).is_empty is False
|
|
|
|
|
|
def test_Reals():
|
|
assert 5 in S.Reals
|
|
assert S.Pi in S.Reals
|
|
assert -sqrt(2) in S.Reals
|
|
assert (2, 5) not in S.Reals
|
|
assert sqrt(-1) not in S.Reals
|
|
assert S.Reals == Interval(-oo, oo)
|
|
assert S.Reals != Interval(0, oo)
|
|
assert S.Reals.is_subset(Interval(-oo, oo))
|
|
assert S.Reals.intersect(Range(-oo, oo)) == Range(-oo, oo)
|
|
assert S.ComplexInfinity not in S.Reals
|
|
assert S.NaN not in S.Reals
|
|
assert x + S.ComplexInfinity not in S.Reals
|
|
|
|
|
|
def test_Complex():
|
|
assert 5 in S.Complexes
|
|
assert 5 + 4*I in S.Complexes
|
|
assert S.Pi in S.Complexes
|
|
assert -sqrt(2) in S.Complexes
|
|
assert -I in S.Complexes
|
|
assert sqrt(-1) in S.Complexes
|
|
assert S.Complexes.intersect(S.Reals) == S.Reals
|
|
assert S.Complexes.union(S.Reals) == S.Complexes
|
|
assert S.Complexes == ComplexRegion(S.Reals*S.Reals)
|
|
assert (S.Complexes == ComplexRegion(Interval(1, 2)*Interval(3, 4))) == False
|
|
assert str(S.Complexes) == "Complexes"
|
|
assert repr(S.Complexes) == "Complexes"
|
|
|
|
|
|
def take(n, iterable):
|
|
"Return first n items of the iterable as a list"
|
|
return list(itertools.islice(iterable, n))
|
|
|
|
|
|
def test_intersections():
|
|
assert S.Integers.intersect(S.Reals) == S.Integers
|
|
assert 5 in S.Integers.intersect(S.Reals)
|
|
assert 5 in S.Integers.intersect(S.Reals)
|
|
assert -5 not in S.Naturals.intersect(S.Reals)
|
|
assert 5.5 not in S.Integers.intersect(S.Reals)
|
|
assert 5 in S.Integers.intersect(Interval(3, oo))
|
|
assert -5 in S.Integers.intersect(Interval(-oo, 3))
|
|
assert all(x.is_Integer
|
|
for x in take(10, S.Integers.intersect(Interval(3, oo)) ))
|
|
|
|
|
|
def test_infinitely_indexed_set_1():
|
|
from sympy.abc import n, m
|
|
assert imageset(Lambda(n, n), S.Integers) == imageset(Lambda(m, m), S.Integers)
|
|
|
|
assert imageset(Lambda(n, 2*n), S.Integers).intersect(
|
|
imageset(Lambda(m, 2*m + 1), S.Integers)) is S.EmptySet
|
|
|
|
assert imageset(Lambda(n, 2*n), S.Integers).intersect(
|
|
imageset(Lambda(n, 2*n + 1), S.Integers)) is S.EmptySet
|
|
|
|
assert imageset(Lambda(m, 2*m), S.Integers).intersect(
|
|
imageset(Lambda(n, 3*n), S.Integers)).dummy_eq(
|
|
ImageSet(Lambda(t, 6*t), S.Integers))
|
|
|
|
assert imageset(x, x/2 + Rational(1, 3), S.Integers).intersect(S.Integers) is S.EmptySet
|
|
assert imageset(x, x/2 + S.Half, S.Integers).intersect(S.Integers) is S.Integers
|
|
|
|
# https://github.com/sympy/sympy/issues/17355
|
|
S53 = ImageSet(Lambda(n, 5*n + 3), S.Integers)
|
|
assert S53.intersect(S.Integers) == S53
|
|
|
|
|
|
def test_infinitely_indexed_set_2():
|
|
from sympy.abc import n
|
|
a = Symbol('a', integer=True)
|
|
assert imageset(Lambda(n, n), S.Integers) == \
|
|
imageset(Lambda(n, n + a), S.Integers)
|
|
assert imageset(Lambda(n, n + pi), S.Integers) == \
|
|
imageset(Lambda(n, n + a + pi), S.Integers)
|
|
assert imageset(Lambda(n, n), S.Integers) == \
|
|
imageset(Lambda(n, -n + a), S.Integers)
|
|
assert imageset(Lambda(n, -6*n), S.Integers) == \
|
|
ImageSet(Lambda(n, 6*n), S.Integers)
|
|
assert imageset(Lambda(n, 2*n + pi), S.Integers) == \
|
|
ImageSet(Lambda(n, 2*n + pi - 2), S.Integers)
|
|
|
|
|
|
def test_imageset_intersect_real():
|
|
from sympy.abc import n
|
|
assert imageset(Lambda(n, n + (n - 1)*(n + 1)*I), S.Integers).intersect(S.Reals) == FiniteSet(-1, 1)
|
|
im = (n - 1)*(n + S.Half)
|
|
assert imageset(Lambda(n, n + im*I), S.Integers
|
|
).intersect(S.Reals) == FiniteSet(1)
|
|
assert imageset(Lambda(n, n + im*(n + 1)*I), S.Naturals0
|
|
).intersect(S.Reals) == FiniteSet(1)
|
|
assert imageset(Lambda(n, n/2 + im.expand()*I), S.Integers
|
|
).intersect(S.Reals) == ImageSet(Lambda(x, x/2), ConditionSet(
|
|
n, Eq(n**2 - n/2 - S(1)/2, 0), S.Integers))
|
|
assert imageset(Lambda(n, n/(1/n - 1) + im*(n + 1)*I), S.Integers
|
|
).intersect(S.Reals) == FiniteSet(S.Half)
|
|
assert imageset(Lambda(n, n/(n - 6) +
|
|
(n - 3)*(n + 1)*I/(2*n + 2)), S.Integers).intersect(
|
|
S.Reals) == FiniteSet(-1)
|
|
assert imageset(Lambda(n, n/(n**2 - 9) +
|
|
(n - 3)*(n + 1)*I/(2*n + 2)), S.Integers).intersect(
|
|
S.Reals) is S.EmptySet
|
|
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_imageset_intersect_interval():
|
|
from sympy.abc import n
|
|
f1 = ImageSet(Lambda(n, n*pi), S.Integers)
|
|
f2 = ImageSet(Lambda(n, 2*n), Interval(0, pi))
|
|
f3 = ImageSet(Lambda(n, 2*n*pi + pi/2), S.Integers)
|
|
# complex expressions
|
|
f4 = ImageSet(Lambda(n, n*I*pi), S.Integers)
|
|
f5 = ImageSet(Lambda(n, 2*I*n*pi + pi/2), S.Integers)
|
|
# non-linear expressions
|
|
f6 = ImageSet(Lambda(n, log(n)), S.Integers)
|
|
f7 = ImageSet(Lambda(n, n**2), S.Integers)
|
|
f8 = ImageSet(Lambda(n, Abs(n)), S.Integers)
|
|
f9 = ImageSet(Lambda(n, exp(n)), S.Naturals0)
|
|
|
|
assert f1.intersect(Interval(-1, 1)) == FiniteSet(0)
|
|
assert f1.intersect(Interval(0, 2*pi, False, True)) == FiniteSet(0, pi)
|
|
assert f2.intersect(Interval(1, 2)) == Interval(1, 2)
|
|
assert f3.intersect(Interval(-1, 1)) == S.EmptySet
|
|
assert f3.intersect(Interval(-5, 5)) == FiniteSet(pi*Rational(-3, 2), pi/2)
|
|
assert f4.intersect(Interval(-1, 1)) == FiniteSet(0)
|
|
assert f4.intersect(Interval(1, 2)) == S.EmptySet
|
|
assert f5.intersect(Interval(0, 1)) == S.EmptySet
|
|
assert f6.intersect(Interval(0, 1)) == FiniteSet(S.Zero, log(2))
|
|
assert f7.intersect(Interval(0, 10)) == Intersection(f7, Interval(0, 10))
|
|
assert f8.intersect(Interval(0, 2)) == Intersection(f8, Interval(0, 2))
|
|
assert f9.intersect(Interval(1, 2)) == Intersection(f9, Interval(1, 2))
|
|
|
|
|
|
def test_imageset_intersect_diophantine():
|
|
from sympy.abc import m, n
|
|
# Check that same lambda variable for both ImageSets is handled correctly
|
|
img1 = ImageSet(Lambda(n, 2*n + 1), S.Integers)
|
|
img2 = ImageSet(Lambda(n, 4*n + 1), S.Integers)
|
|
assert img1.intersect(img2) == img2
|
|
# Empty solution set returned by diophantine:
|
|
assert ImageSet(Lambda(n, 2*n), S.Integers).intersect(
|
|
ImageSet(Lambda(n, 2*n + 1), S.Integers)) == S.EmptySet
|
|
# Check intersection with S.Integers:
|
|
assert ImageSet(Lambda(n, 9/n + 20*n/3), S.Integers).intersect(
|
|
S.Integers) == FiniteSet(-61, -23, 23, 61)
|
|
# Single solution (2, 3) for diophantine solution:
|
|
assert ImageSet(Lambda(n, (n - 2)**2), S.Integers).intersect(
|
|
ImageSet(Lambda(n, -(n - 3)**2), S.Integers)) == FiniteSet(0)
|
|
# Single parametric solution for diophantine solution:
|
|
assert ImageSet(Lambda(n, n**2 + 5), S.Integers).intersect(
|
|
ImageSet(Lambda(m, 2*m), S.Integers)).dummy_eq(ImageSet(
|
|
Lambda(n, 4*n**2 + 4*n + 6), S.Integers))
|
|
# 4 non-parametric solution couples for dioph. equation:
|
|
assert ImageSet(Lambda(n, n**2 - 9), S.Integers).intersect(
|
|
ImageSet(Lambda(m, -m**2), S.Integers)) == FiniteSet(-9, 0)
|
|
# Double parametric solution for diophantine solution:
|
|
assert ImageSet(Lambda(m, m**2 + 40), S.Integers).intersect(
|
|
ImageSet(Lambda(n, 41*n), S.Integers)).dummy_eq(Intersection(
|
|
ImageSet(Lambda(m, m**2 + 40), S.Integers),
|
|
ImageSet(Lambda(n, 41*n), S.Integers)))
|
|
# Check that diophantine returns *all* (8) solutions (permute=True)
|
|
assert ImageSet(Lambda(n, n**4 - 2**4), S.Integers).intersect(
|
|
ImageSet(Lambda(m, -m**4 + 3**4), S.Integers)) == FiniteSet(0, 65)
|
|
assert ImageSet(Lambda(n, pi/12 + n*5*pi/12), S.Integers).intersect(
|
|
ImageSet(Lambda(n, 7*pi/12 + n*11*pi/12), S.Integers)).dummy_eq(ImageSet(
|
|
Lambda(n, 55*pi*n/12 + 17*pi/4), S.Integers))
|
|
# TypeError raised by diophantine (#18081)
|
|
assert ImageSet(Lambda(n, n*log(2)), S.Integers).intersection(
|
|
S.Integers).dummy_eq(Intersection(ImageSet(
|
|
Lambda(n, n*log(2)), S.Integers), S.Integers))
|
|
# NotImplementedError raised by diophantine (no solver for cubic_thue)
|
|
assert ImageSet(Lambda(n, n**3 + 1), S.Integers).intersect(
|
|
ImageSet(Lambda(n, n**3), S.Integers)).dummy_eq(Intersection(
|
|
ImageSet(Lambda(n, n**3 + 1), S.Integers),
|
|
ImageSet(Lambda(n, n**3), S.Integers)))
|
|
|
|
|
|
def test_infinitely_indexed_set_3():
|
|
from sympy.abc import n, m
|
|
assert imageset(Lambda(m, 2*pi*m), S.Integers).intersect(
|
|
imageset(Lambda(n, 3*pi*n), S.Integers)).dummy_eq(
|
|
ImageSet(Lambda(t, 6*pi*t), S.Integers))
|
|
assert imageset(Lambda(n, 2*n + 1), S.Integers) == \
|
|
imageset(Lambda(n, 2*n - 1), S.Integers)
|
|
assert imageset(Lambda(n, 3*n + 2), S.Integers) == \
|
|
imageset(Lambda(n, 3*n - 1), S.Integers)
|
|
|
|
|
|
def test_ImageSet_simplification():
|
|
from sympy.abc import n, m
|
|
assert imageset(Lambda(n, n), S.Integers) == S.Integers
|
|
assert imageset(Lambda(n, sin(n)),
|
|
imageset(Lambda(m, tan(m)), S.Integers)) == \
|
|
imageset(Lambda(m, sin(tan(m))), S.Integers)
|
|
assert imageset(n, 1 + 2*n, S.Naturals) == Range(3, oo, 2)
|
|
assert imageset(n, 1 + 2*n, S.Naturals0) == Range(1, oo, 2)
|
|
assert imageset(n, 1 - 2*n, S.Naturals) == Range(-1, -oo, -2)
|
|
|
|
|
|
def test_ImageSet_contains():
|
|
assert (2, S.Half) in imageset(x, (x, 1/x), S.Integers)
|
|
assert imageset(x, x + I*3, S.Integers).intersection(S.Reals) is S.EmptySet
|
|
i = Dummy(integer=True)
|
|
q = imageset(x, x + I*y, S.Integers).intersection(S.Reals)
|
|
assert q.subs(y, I*i).intersection(S.Integers) is S.Integers
|
|
q = imageset(x, x + I*y/x, S.Integers).intersection(S.Reals)
|
|
assert q.subs(y, 0) is S.Integers
|
|
assert q.subs(y, I*i*x).intersection(S.Integers) is S.Integers
|
|
z = cos(1)**2 + sin(1)**2 - 1
|
|
q = imageset(x, x + I*z, S.Integers).intersection(S.Reals)
|
|
assert q is not S.EmptySet
|
|
|
|
|
|
def test_ComplexRegion_contains():
|
|
r = Symbol('r', real=True)
|
|
# contains in ComplexRegion
|
|
a = Interval(2, 3)
|
|
b = Interval(4, 6)
|
|
c = Interval(7, 9)
|
|
c1 = ComplexRegion(a*b)
|
|
c2 = ComplexRegion(Union(a*b, c*a))
|
|
assert 2.5 + 4.5*I in c1
|
|
assert 2 + 4*I in c1
|
|
assert 3 + 4*I in c1
|
|
assert 8 + 2.5*I in c2
|
|
assert 2.5 + 6.1*I not in c1
|
|
assert 4.5 + 3.2*I not in c1
|
|
assert c1.contains(x) == Contains(x, c1, evaluate=False)
|
|
assert c1.contains(r) == False
|
|
assert c2.contains(x) == Contains(x, c2, evaluate=False)
|
|
assert c2.contains(r) == False
|
|
|
|
r1 = Interval(0, 1)
|
|
theta1 = Interval(0, 2*S.Pi)
|
|
c3 = ComplexRegion(r1*theta1, polar=True)
|
|
assert (0.5 + I*6/10) in c3
|
|
assert (S.Half + I*6/10) in c3
|
|
assert (S.Half + .6*I) in c3
|
|
assert (0.5 + .6*I) in c3
|
|
assert I in c3
|
|
assert 1 in c3
|
|
assert 0 in c3
|
|
assert 1 + I not in c3
|
|
assert 1 - I not in c3
|
|
assert c3.contains(x) == Contains(x, c3, evaluate=False)
|
|
assert c3.contains(r + 2*I) == Contains(
|
|
r + 2*I, c3, evaluate=False) # is in fact False
|
|
assert c3.contains(1/(1 + r**2)) == Contains(
|
|
1/(1 + r**2), c3, evaluate=False) # is in fact True
|
|
|
|
r2 = Interval(0, 3)
|
|
theta2 = Interval(pi, 2*pi, left_open=True)
|
|
c4 = ComplexRegion(r2*theta2, polar=True)
|
|
assert c4.contains(0) == True
|
|
assert c4.contains(2 + I) == False
|
|
assert c4.contains(-2 + I) == False
|
|
assert c4.contains(-2 - I) == True
|
|
assert c4.contains(2 - I) == True
|
|
assert c4.contains(-2) == False
|
|
assert c4.contains(2) == True
|
|
assert c4.contains(x) == Contains(x, c4, evaluate=False)
|
|
assert c4.contains(3/(1 + r**2)) == Contains(
|
|
3/(1 + r**2), c4, evaluate=False) # is in fact True
|
|
|
|
raises(ValueError, lambda: ComplexRegion(r1*theta1, polar=2))
|
|
|
|
|
|
def test_symbolic_Range():
|
|
n = Symbol('n')
|
|
raises(ValueError, lambda: Range(n)[0])
|
|
raises(IndexError, lambda: Range(n, n)[0])
|
|
raises(ValueError, lambda: Range(n, n+1)[0])
|
|
raises(ValueError, lambda: Range(n).size)
|
|
|
|
n = Symbol('n', integer=True)
|
|
raises(ValueError, lambda: Range(n)[0])
|
|
raises(IndexError, lambda: Range(n, n)[0])
|
|
assert Range(n, n+1)[0] == n
|
|
raises(ValueError, lambda: Range(n).size)
|
|
assert Range(n, n+1).size == 1
|
|
|
|
n = Symbol('n', integer=True, nonnegative=True)
|
|
raises(ValueError, lambda: Range(n)[0])
|
|
raises(IndexError, lambda: Range(n, n)[0])
|
|
assert Range(n+1)[0] == 0
|
|
assert Range(n, n+1)[0] == n
|
|
assert Range(n).size == n
|
|
assert Range(n+1).size == n+1
|
|
assert Range(n, n+1).size == 1
|
|
|
|
n = Symbol('n', integer=True, positive=True)
|
|
assert Range(n)[0] == 0
|
|
assert Range(n, n+1)[0] == n
|
|
assert Range(n).size == n
|
|
assert Range(n, n+1).size == 1
|
|
|
|
m = Symbol('m', integer=True, positive=True)
|
|
|
|
assert Range(n, n+m)[0] == n
|
|
assert Range(n, n+m).size == m
|
|
assert Range(n, n+1).size == 1
|
|
assert Range(n, n+m, 2).size == floor(m/2)
|
|
|
|
m = Symbol('m', integer=True, positive=True, even=True)
|
|
assert Range(n, n+m, 2).size == m/2
|
|
|
|
|
|
def test_issue_18400():
|
|
n = Symbol('n', integer=True)
|
|
raises(ValueError, lambda: imageset(lambda x: x*2, Range(n)))
|
|
|
|
n = Symbol('n', integer=True, positive=True)
|
|
# No exception
|
|
assert imageset(lambda x: x*2, Range(n)) == imageset(lambda x: x*2, Range(n))
|
|
|
|
|
|
def test_ComplexRegion_intersect():
|
|
# Polar form
|
|
X_axis = ComplexRegion(Interval(0, oo)*FiniteSet(0, S.Pi), polar=True)
|
|
|
|
unit_disk = ComplexRegion(Interval(0, 1)*Interval(0, 2*S.Pi), polar=True)
|
|
upper_half_unit_disk = ComplexRegion(Interval(0, 1)*Interval(0, S.Pi), polar=True)
|
|
upper_half_disk = ComplexRegion(Interval(0, oo)*Interval(0, S.Pi), polar=True)
|
|
lower_half_disk = ComplexRegion(Interval(0, oo)*Interval(S.Pi, 2*S.Pi), polar=True)
|
|
right_half_disk = ComplexRegion(Interval(0, oo)*Interval(-S.Pi/2, S.Pi/2), polar=True)
|
|
first_quad_disk = ComplexRegion(Interval(0, oo)*Interval(0, S.Pi/2), polar=True)
|
|
|
|
assert upper_half_disk.intersect(unit_disk) == upper_half_unit_disk
|
|
assert right_half_disk.intersect(first_quad_disk) == first_quad_disk
|
|
assert upper_half_disk.intersect(right_half_disk) == first_quad_disk
|
|
assert upper_half_disk.intersect(lower_half_disk) == X_axis
|
|
|
|
c1 = ComplexRegion(Interval(0, 4)*Interval(0, 2*S.Pi), polar=True)
|
|
assert c1.intersect(Interval(1, 5)) == Interval(1, 4)
|
|
assert c1.intersect(Interval(4, 9)) == FiniteSet(4)
|
|
assert c1.intersect(Interval(5, 12)) is S.EmptySet
|
|
|
|
# Rectangular form
|
|
X_axis = ComplexRegion(Interval(-oo, oo)*FiniteSet(0))
|
|
|
|
unit_square = ComplexRegion(Interval(-1, 1)*Interval(-1, 1))
|
|
upper_half_unit_square = ComplexRegion(Interval(-1, 1)*Interval(0, 1))
|
|
upper_half_plane = ComplexRegion(Interval(-oo, oo)*Interval(0, oo))
|
|
lower_half_plane = ComplexRegion(Interval(-oo, oo)*Interval(-oo, 0))
|
|
right_half_plane = ComplexRegion(Interval(0, oo)*Interval(-oo, oo))
|
|
first_quad_plane = ComplexRegion(Interval(0, oo)*Interval(0, oo))
|
|
|
|
assert upper_half_plane.intersect(unit_square) == upper_half_unit_square
|
|
assert right_half_plane.intersect(first_quad_plane) == first_quad_plane
|
|
assert upper_half_plane.intersect(right_half_plane) == first_quad_plane
|
|
assert upper_half_plane.intersect(lower_half_plane) == X_axis
|
|
|
|
c1 = ComplexRegion(Interval(-5, 5)*Interval(-10, 10))
|
|
assert c1.intersect(Interval(2, 7)) == Interval(2, 5)
|
|
assert c1.intersect(Interval(5, 7)) == FiniteSet(5)
|
|
assert c1.intersect(Interval(6, 9)) is S.EmptySet
|
|
|
|
# unevaluated object
|
|
C1 = ComplexRegion(Interval(0, 1)*Interval(0, 2*S.Pi), polar=True)
|
|
C2 = ComplexRegion(Interval(-1, 1)*Interval(-1, 1))
|
|
assert C1.intersect(C2) == Intersection(C1, C2, evaluate=False)
|
|
|
|
|
|
def test_ComplexRegion_union():
|
|
# Polar form
|
|
c1 = ComplexRegion(Interval(0, 1)*Interval(0, 2*S.Pi), polar=True)
|
|
c2 = ComplexRegion(Interval(0, 1)*Interval(0, S.Pi), polar=True)
|
|
c3 = ComplexRegion(Interval(0, oo)*Interval(0, S.Pi), polar=True)
|
|
c4 = ComplexRegion(Interval(0, oo)*Interval(S.Pi, 2*S.Pi), polar=True)
|
|
|
|
p1 = Union(Interval(0, 1)*Interval(0, 2*S.Pi), Interval(0, 1)*Interval(0, S.Pi))
|
|
p2 = Union(Interval(0, oo)*Interval(0, S.Pi), Interval(0, oo)*Interval(S.Pi, 2*S.Pi))
|
|
|
|
assert c1.union(c2) == ComplexRegion(p1, polar=True)
|
|
assert c3.union(c4) == ComplexRegion(p2, polar=True)
|
|
|
|
# Rectangular form
|
|
c5 = ComplexRegion(Interval(2, 5)*Interval(6, 9))
|
|
c6 = ComplexRegion(Interval(4, 6)*Interval(10, 12))
|
|
c7 = ComplexRegion(Interval(0, 10)*Interval(-10, 0))
|
|
c8 = ComplexRegion(Interval(12, 16)*Interval(14, 20))
|
|
|
|
p3 = Union(Interval(2, 5)*Interval(6, 9), Interval(4, 6)*Interval(10, 12))
|
|
p4 = Union(Interval(0, 10)*Interval(-10, 0), Interval(12, 16)*Interval(14, 20))
|
|
|
|
assert c5.union(c6) == ComplexRegion(p3)
|
|
assert c7.union(c8) == ComplexRegion(p4)
|
|
|
|
assert c1.union(Interval(2, 4)) == Union(c1, Interval(2, 4), evaluate=False)
|
|
assert c5.union(Interval(2, 4)) == Union(c5, ComplexRegion.from_real(Interval(2, 4)))
|
|
|
|
|
|
def test_ComplexRegion_from_real():
|
|
c1 = ComplexRegion(Interval(0, 1) * Interval(0, 2 * S.Pi), polar=True)
|
|
|
|
raises(ValueError, lambda: c1.from_real(c1))
|
|
assert c1.from_real(Interval(-1, 1)) == ComplexRegion(Interval(-1, 1) * FiniteSet(0), False)
|
|
|
|
|
|
def test_ComplexRegion_measure():
|
|
a, b = Interval(2, 5), Interval(4, 8)
|
|
theta1, theta2 = Interval(0, 2*S.Pi), Interval(0, S.Pi)
|
|
c1 = ComplexRegion(a*b)
|
|
c2 = ComplexRegion(Union(a*theta1, b*theta2), polar=True)
|
|
|
|
assert c1.measure == 12
|
|
assert c2.measure == 9*pi
|
|
|
|
|
|
def test_normalize_theta_set():
|
|
# Interval
|
|
assert normalize_theta_set(Interval(pi, 2*pi)) == \
|
|
Union(FiniteSet(0), Interval.Ropen(pi, 2*pi))
|
|
assert normalize_theta_set(Interval(pi*Rational(9, 2), 5*pi)) == Interval(pi/2, pi)
|
|
assert normalize_theta_set(Interval(pi*Rational(-3, 2), pi/2)) == Interval.Ropen(0, 2*pi)
|
|
assert normalize_theta_set(Interval.open(pi*Rational(-3, 2), pi/2)) == \
|
|
Union(Interval.Ropen(0, pi/2), Interval.open(pi/2, 2*pi))
|
|
assert normalize_theta_set(Interval.open(pi*Rational(-7, 2), pi*Rational(-3, 2))) == \
|
|
Union(Interval.Ropen(0, pi/2), Interval.open(pi/2, 2*pi))
|
|
assert normalize_theta_set(Interval(-pi/2, pi/2)) == \
|
|
Union(Interval(0, pi/2), Interval.Ropen(pi*Rational(3, 2), 2*pi))
|
|
assert normalize_theta_set(Interval.open(-pi/2, pi/2)) == \
|
|
Union(Interval.Ropen(0, pi/2), Interval.open(pi*Rational(3, 2), 2*pi))
|
|
assert normalize_theta_set(Interval(-4*pi, 3*pi)) == Interval.Ropen(0, 2*pi)
|
|
assert normalize_theta_set(Interval(pi*Rational(-3, 2), -pi/2)) == Interval(pi/2, pi*Rational(3, 2))
|
|
assert normalize_theta_set(Interval.open(0, 2*pi)) == Interval.open(0, 2*pi)
|
|
assert normalize_theta_set(Interval.Ropen(-pi/2, pi/2)) == \
|
|
Union(Interval.Ropen(0, pi/2), Interval.Ropen(pi*Rational(3, 2), 2*pi))
|
|
assert normalize_theta_set(Interval.Lopen(-pi/2, pi/2)) == \
|
|
Union(Interval(0, pi/2), Interval.open(pi*Rational(3, 2), 2*pi))
|
|
assert normalize_theta_set(Interval(-pi/2, pi/2)) == \
|
|
Union(Interval(0, pi/2), Interval.Ropen(pi*Rational(3, 2), 2*pi))
|
|
assert normalize_theta_set(Interval.open(4*pi, pi*Rational(9, 2))) == Interval.open(0, pi/2)
|
|
assert normalize_theta_set(Interval.Lopen(4*pi, pi*Rational(9, 2))) == Interval.Lopen(0, pi/2)
|
|
assert normalize_theta_set(Interval.Ropen(4*pi, pi*Rational(9, 2))) == Interval.Ropen(0, pi/2)
|
|
assert normalize_theta_set(Interval.open(3*pi, 5*pi)) == \
|
|
Union(Interval.Ropen(0, pi), Interval.open(pi, 2*pi))
|
|
|
|
# FiniteSet
|
|
assert normalize_theta_set(FiniteSet(0, pi, 3*pi)) == FiniteSet(0, pi)
|
|
assert normalize_theta_set(FiniteSet(0, pi/2, pi, 2*pi)) == FiniteSet(0, pi/2, pi)
|
|
assert normalize_theta_set(FiniteSet(0, -pi/2, -pi, -2*pi)) == FiniteSet(0, pi, pi*Rational(3, 2))
|
|
assert normalize_theta_set(FiniteSet(pi*Rational(-3, 2), pi/2)) == \
|
|
FiniteSet(pi/2)
|
|
assert normalize_theta_set(FiniteSet(2*pi)) == FiniteSet(0)
|
|
|
|
# Unions
|
|
assert normalize_theta_set(Union(Interval(0, pi/3), Interval(pi/2, pi))) == \
|
|
Union(Interval(0, pi/3), Interval(pi/2, pi))
|
|
assert normalize_theta_set(Union(Interval(0, pi), Interval(2*pi, pi*Rational(7, 3)))) == \
|
|
Interval(0, pi)
|
|
|
|
# ValueError for non-real sets
|
|
raises(ValueError, lambda: normalize_theta_set(S.Complexes))
|
|
|
|
# NotImplementedError for subset of reals
|
|
raises(NotImplementedError, lambda: normalize_theta_set(Interval(0, 1)))
|
|
|
|
# NotImplementedError without pi as coefficient
|
|
raises(NotImplementedError, lambda: normalize_theta_set(Interval(1, 2*pi)))
|
|
raises(NotImplementedError, lambda: normalize_theta_set(Interval(2*pi, 10)))
|
|
raises(NotImplementedError, lambda: normalize_theta_set(FiniteSet(0, 3, 3*pi)))
|
|
|
|
|
|
def test_ComplexRegion_FiniteSet():
|
|
x, y, z, a, b, c = symbols('x y z a b c')
|
|
|
|
# Issue #9669
|
|
assert ComplexRegion(FiniteSet(a, b, c)*FiniteSet(x, y, z)) == \
|
|
FiniteSet(a + I*x, a + I*y, a + I*z, b + I*x, b + I*y,
|
|
b + I*z, c + I*x, c + I*y, c + I*z)
|
|
assert ComplexRegion(FiniteSet(2)*FiniteSet(3)) == FiniteSet(2 + 3*I)
|
|
|
|
|
|
def test_union_RealSubSet():
|
|
assert (S.Complexes).union(Interval(1, 2)) == S.Complexes
|
|
assert (S.Complexes).union(S.Integers) == S.Complexes
|
|
|
|
|
|
def test_SetKind_fancySet():
|
|
G = lambda *args: ImageSet(Lambda(x, x ** 2), *args)
|
|
assert G(Interval(1, 4)).kind is SetKind(NumberKind)
|
|
assert G(FiniteSet(1, 4)).kind is SetKind(NumberKind)
|
|
assert S.Rationals.kind is SetKind(NumberKind)
|
|
assert S.Naturals.kind is SetKind(NumberKind)
|
|
assert S.Integers.kind is SetKind(NumberKind)
|
|
assert Range(3).kind is SetKind(NumberKind)
|
|
a = Interval(2, 3)
|
|
b = Interval(4, 6)
|
|
c1 = ComplexRegion(a*b)
|
|
assert c1.kind is SetKind(TupleKind(NumberKind, NumberKind))
|
|
|
|
|
|
def test_issue_9980():
|
|
c1 = ComplexRegion(Interval(1, 2)*Interval(2, 3))
|
|
c2 = ComplexRegion(Interval(1, 5)*Interval(1, 3))
|
|
R = Union(c1, c2)
|
|
assert simplify(R) == ComplexRegion(Union(Interval(1, 2)*Interval(2, 3), \
|
|
Interval(1, 5)*Interval(1, 3)), False)
|
|
assert c1.func(*c1.args) == c1
|
|
assert R.func(*R.args) == R
|
|
|
|
|
|
def test_issue_11732():
|
|
interval12 = Interval(1, 2)
|
|
finiteset1234 = FiniteSet(1, 2, 3, 4)
|
|
pointComplex = Tuple(1, 5)
|
|
|
|
assert (interval12 in S.Naturals) == False
|
|
assert (interval12 in S.Naturals0) == False
|
|
assert (interval12 in S.Integers) == False
|
|
assert (interval12 in S.Complexes) == False
|
|
|
|
assert (finiteset1234 in S.Naturals) == False
|
|
assert (finiteset1234 in S.Naturals0) == False
|
|
assert (finiteset1234 in S.Integers) == False
|
|
assert (finiteset1234 in S.Complexes) == False
|
|
|
|
assert (pointComplex in S.Naturals) == False
|
|
assert (pointComplex in S.Naturals0) == False
|
|
assert (pointComplex in S.Integers) == False
|
|
assert (pointComplex in S.Complexes) == True
|
|
|
|
|
|
def test_issue_11730():
|
|
unit = Interval(0, 1)
|
|
square = ComplexRegion(unit ** 2)
|
|
|
|
assert Union(S.Complexes, FiniteSet(oo)) != S.Complexes
|
|
assert Union(S.Complexes, FiniteSet(eye(4))) != S.Complexes
|
|
assert Union(unit, square) == square
|
|
assert Intersection(S.Reals, square) == unit
|
|
|
|
|
|
def test_issue_11938():
|
|
unit = Interval(0, 1)
|
|
ival = Interval(1, 2)
|
|
cr1 = ComplexRegion(ival * unit)
|
|
|
|
assert Intersection(cr1, S.Reals) == ival
|
|
assert Intersection(cr1, unit) == FiniteSet(1)
|
|
|
|
arg1 = Interval(0, S.Pi)
|
|
arg2 = FiniteSet(S.Pi)
|
|
arg3 = Interval(S.Pi / 4, 3 * S.Pi / 4)
|
|
cp1 = ComplexRegion(unit * arg1, polar=True)
|
|
cp2 = ComplexRegion(unit * arg2, polar=True)
|
|
cp3 = ComplexRegion(unit * arg3, polar=True)
|
|
|
|
assert Intersection(cp1, S.Reals) == Interval(-1, 1)
|
|
assert Intersection(cp2, S.Reals) == Interval(-1, 0)
|
|
assert Intersection(cp3, S.Reals) == FiniteSet(0)
|
|
|
|
|
|
def test_issue_11914():
|
|
a, b = Interval(0, 1), Interval(0, pi)
|
|
c, d = Interval(2, 3), Interval(pi, 3 * pi / 2)
|
|
cp1 = ComplexRegion(a * b, polar=True)
|
|
cp2 = ComplexRegion(c * d, polar=True)
|
|
|
|
assert -3 in cp1.union(cp2)
|
|
assert -3 in cp2.union(cp1)
|
|
assert -5 not in cp1.union(cp2)
|
|
|
|
|
|
def test_issue_9543():
|
|
assert ImageSet(Lambda(x, x**2), S.Naturals).is_subset(S.Reals)
|
|
|
|
|
|
def test_issue_16871():
|
|
assert ImageSet(Lambda(x, x), FiniteSet(1)) == {1}
|
|
assert ImageSet(Lambda(x, x - 3), S.Integers
|
|
).intersection(S.Integers) is S.Integers
|
|
|
|
|
|
@XFAIL
|
|
def test_issue_16871b():
|
|
assert ImageSet(Lambda(x, x - 3), S.Integers).is_subset(S.Integers)
|
|
|
|
|
|
def test_issue_18050():
|
|
assert imageset(Lambda(x, I*x + 1), S.Integers
|
|
) == ImageSet(Lambda(x, I*x + 1), S.Integers)
|
|
assert imageset(Lambda(x, 3*I*x + 4 + 8*I), S.Integers
|
|
) == ImageSet(Lambda(x, 3*I*x + 4 + 2*I), S.Integers)
|
|
# no 'Mod' for next 2 tests:
|
|
assert imageset(Lambda(x, 2*x + 3*I), S.Integers
|
|
) == ImageSet(Lambda(x, 2*x + 3*I), S.Integers)
|
|
r = Symbol('r', positive=True)
|
|
assert imageset(Lambda(x, r*x + 10), S.Integers
|
|
) == ImageSet(Lambda(x, r*x + 10), S.Integers)
|
|
# reduce real part:
|
|
assert imageset(Lambda(x, 3*x + 8 + 5*I), S.Integers
|
|
) == ImageSet(Lambda(x, 3*x + 2 + 5*I), S.Integers)
|
|
|
|
|
|
def test_Rationals():
|
|
assert S.Integers.is_subset(S.Rationals)
|
|
assert S.Naturals.is_subset(S.Rationals)
|
|
assert S.Naturals0.is_subset(S.Rationals)
|
|
assert S.Rationals.is_subset(S.Reals)
|
|
assert S.Rationals.inf is -oo
|
|
assert S.Rationals.sup is oo
|
|
it = iter(S.Rationals)
|
|
assert [next(it) for i in range(12)] == [
|
|
0, 1, -1, S.Half, 2, Rational(-1, 2), -2,
|
|
Rational(1, 3), 3, Rational(-1, 3), -3, Rational(2, 3)]
|
|
assert Basic() not in S.Rationals
|
|
assert S.Half in S.Rationals
|
|
assert S.Rationals.contains(0.5) == Contains(0.5, S.Rationals, evaluate=False)
|
|
assert 2 in S.Rationals
|
|
r = symbols('r', rational=True)
|
|
assert r in S.Rationals
|
|
raises(TypeError, lambda: x in S.Rationals)
|
|
# issue #18134:
|
|
assert S.Rationals.boundary == S.Reals
|
|
assert S.Rationals.closure == S.Reals
|
|
assert S.Rationals.is_open == False
|
|
assert S.Rationals.is_closed == False
|
|
|
|
|
|
def test_NZQRC_unions():
|
|
# check that all trivial number set unions are simplified:
|
|
nbrsets = (S.Naturals, S.Naturals0, S.Integers, S.Rationals,
|
|
S.Reals, S.Complexes)
|
|
unions = (Union(a, b) for a in nbrsets for b in nbrsets)
|
|
assert all(u.is_Union is False for u in unions)
|
|
|
|
|
|
def test_imageset_intersection():
|
|
n = Dummy()
|
|
s = ImageSet(Lambda(n, -I*(I*(2*pi*n - pi/4) +
|
|
log(Abs(sqrt(-I))))), S.Integers)
|
|
assert s.intersect(S.Reals) == ImageSet(
|
|
Lambda(n, 2*pi*n + pi*Rational(7, 4)), S.Integers)
|
|
|
|
|
|
def test_issue_17858():
|
|
assert 1 in Range(-oo, oo)
|
|
assert 0 in Range(oo, -oo, -1)
|
|
assert oo not in Range(-oo, oo)
|
|
assert -oo not in Range(-oo, oo)
|
|
|
|
def test_issue_17859():
|
|
r = Range(-oo,oo)
|
|
raises(ValueError,lambda: r[::2])
|
|
raises(ValueError, lambda: r[::-2])
|
|
r = Range(oo,-oo,-1)
|
|
raises(ValueError,lambda: r[::2])
|
|
raises(ValueError, lambda: r[::-2])
|