|
|
|
|
|
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) |
|
|
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 harmonics.contains(.25) == Contains( |
|
|
0.25, ImageSet(Lambda(x, 1/x), S.Naturals), evaluate=False) |
|
|
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) |
|
|
|
|
|
|
|
|
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() |
|
|
|
|
|
|
|
|
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 |
|
|
assert not halfcircle.is_iterable |
|
|
|
|
|
|
|
|
@XFAIL |
|
|
def test_halfcircle_fail(): |
|
|
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 (r, 2*pi) not in halfcircle |
|
|
|
|
|
|
|
|
def test_ImageSet_iterator_not_injective(): |
|
|
L = Lambda(x, x - x % 2) |
|
|
evens = ImageSet(L, S.Naturals) |
|
|
i = iter(evens) |
|
|
|
|
|
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) |
|
|
|
|
|
|
|
|
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]) |
|
|
|
|
|
|
|
|
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) |
|
|
|
|
|
|
|
|
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(): |
|
|
|
|
|
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)) |
|
|
|
|
|
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) |
|
|
|
|
|
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) |
|
|
|
|
|
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) |
|
|
raises(TypeError, lambda: 1 in sr) |
|
|
|
|
|
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]) |
|
|
|
|
|
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) |
|
|
|
|
|
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)) |
|
|
|
|
|
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) |
|
|
|
|
|
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) |
|
|
|
|
|
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) |
|
|
|
|
|
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) |
|
|
|
|
|
assert xr.as_relational(x) == Eq(Mod(x, 1), 0) |
|
|
|
|
|
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) |
|
|
|
|
|
|
|
|
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 |
|
|
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 |
|
|
|
|
|
|
|
|
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) |
|
|
|
|
|
|
|
|
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) |
|
|
|
|
|
f4 = ImageSet(Lambda(n, n*I*pi), S.Integers) |
|
|
f5 = ImageSet(Lambda(n, 2*I*n*pi + pi/2), S.Integers) |
|
|
|
|
|
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 |
|
|
|
|
|
img1 = ImageSet(Lambda(n, 2*n + 1), S.Integers) |
|
|
img2 = ImageSet(Lambda(n, 4*n + 1), S.Integers) |
|
|
assert img1.intersect(img2) == img2 |
|
|
|
|
|
assert ImageSet(Lambda(n, 2*n), S.Integers).intersect( |
|
|
ImageSet(Lambda(n, 2*n + 1), S.Integers)) == S.EmptySet |
|
|
|
|
|
assert ImageSet(Lambda(n, 9/n + 20*n/3), S.Integers).intersect( |
|
|
S.Integers) == FiniteSet(-61, -23, 23, 61) |
|
|
|
|
|
assert ImageSet(Lambda(n, (n - 2)**2), S.Integers).intersect( |
|
|
ImageSet(Lambda(n, -(n - 3)**2), S.Integers)) == FiniteSet(0) |
|
|
|
|
|
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)) |
|
|
|
|
|
assert ImageSet(Lambda(n, n**2 - 9), S.Integers).intersect( |
|
|
ImageSet(Lambda(m, -m**2), S.Integers)) == FiniteSet(-9, 0) |
|
|
|
|
|
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))) |
|
|
|
|
|
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)) |
|
|
|
|
|
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)) |
|
|
|
|
|
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) |
|
|
|
|
|
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) |
|
|
assert c3.contains(1/(1 + r**2)) == Contains( |
|
|
1/(1 + r**2), c3, evaluate=False) |
|
|
|
|
|
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) |
|
|
|
|
|
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) |
|
|
|
|
|
assert imageset(lambda x: x*2, Range(n)) == imageset(lambda x: x*2, Range(n)) |
|
|
|
|
|
|
|
|
def test_ComplexRegion_intersect(): |
|
|
|
|
|
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 |
|
|
|
|
|
|
|
|
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 |
|
|
|
|
|
|
|
|
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(): |
|
|
|
|
|
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) |
|
|
|
|
|
|
|
|
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(): |
|
|
|
|
|
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)) |
|
|
|
|
|
|
|
|
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) |
|
|
|
|
|
|
|
|
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) |
|
|
|
|
|
|
|
|
raises(ValueError, lambda: normalize_theta_set(S.Complexes)) |
|
|
|
|
|
|
|
|
raises(NotImplementedError, lambda: normalize_theta_set(Interval(0, 1))) |
|
|
|
|
|
|
|
|
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') |
|
|
|
|
|
|
|
|
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) |
|
|
|
|
|
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) |
|
|
|
|
|
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) |
|
|
|
|
|
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(): |
|
|
|
|
|
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]) |
|
|
|
