def test_product_basic():
H, T = 'H', 'T'
unit_line = Interval(0, 1)
d6 = FiniteSet(1, 2, 3, 4, 5, 6)
d4 = FiniteSet(1, 2, 3, 4)
coin = FiniteSet(H, T)
square = unit_line * unit_line
assert (0, 0) in square
assert 0 not in square
assert (H, T) in coin ** 2
assert (.5, .5, .5) in square * unit_line
assert (H, 3, 3) in coin*d6*d6
HH, TT = sympify(H), sympify(T)
assert set(coin**2) == {(HH, HH), (HH, TT), (TT, HH), (TT, TT)}
assert (d4*d4).is_subset(d6*d6)
assert (square.complement(Interval(-oo, oo)*Interval(-oo, oo)) ==
Union((Interval(-oo, 0, True, True) +
Interval(1, oo, True, True))*Interval(-oo, oo),
Interval(-oo, oo)*(Interval(-oo, 0, True, True) +
Interval(1, oo, True, True))))
assert (Interval(-5, 5)**3).is_subset(Interval(-10, 10)**3)
assert not (Interval(-10, 10)**3).is_subset(Interval(-5, 5)**3)
assert not (Interval(-5, 5)**2).is_subset(Interval(-10, 10)**3)
assert (Interval(.2, .5)*FiniteSet(.5)).is_subset(square) # segment in square
assert len(coin*coin*coin) == 8
assert len(S.EmptySet*S.EmptySet) == 0
assert len(S.EmptySet*coin) == 0
pytest.raises(TypeError, lambda: len(coin*Interval(0, 2)))
def test_is_superset():
assert Interval(0, 1).is_superset(Interval(0, 2)) is False
assert Interval(0, 3).is_superset(Interval(0, 2))
assert FiniteSet(1, 2).is_superset(FiniteSet(1, 2, 3, 4)) is False
assert FiniteSet(4, 5).is_superset(FiniteSet(1, 2, 3, 4)) is False
assert FiniteSet(1).is_superset(Interval(0, 2)) is False
assert FiniteSet(1, 2).is_superset(Interval(0, 2, True, True)) is False
assert (Interval(1, 2) + FiniteSet(3)).is_superset(
(Interval(0, 2, False, True) + FiniteSet(2, 3))) is False
assert Interval(3, 4).is_superset(Union(Interval(0, 1), Interval(
2, 5))) is False
assert FiniteSet(1, 2, 3, 4).is_superset(Interval(0, 5)) is False
assert S.EmptySet.is_superset(FiniteSet(1, 2, 3)) is False
assert Interval(0, 1).is_superset(S.EmptySet) is True
assert S.EmptySet.is_superset(S.EmptySet) is True
pytest.raises(ValueError, lambda: S.EmptySet.is_superset(1))
# tests for the issuperset alias
assert Interval(0, 1).issuperset(S.EmptySet) is True
assert S.EmptySet.issuperset(S.EmptySet) is True
def test_functions():
g = WildFunction('g')
p = Wild('p')
q = Wild('q')
f = cos(5 * x)
notf = x
assert f.match(p * cos(q * x)) == {p: 1, q: 5}
assert f.match(p * g) == {p: 1, g: cos(5 * x)}
assert notf.match(g) is None
F = WildFunction('F', nargs=2)
assert F.nargs == FiniteSet(2)
f = Function('f')
assert f(x).match(F) is None
F = WildFunction('F', nargs=(1, 2))
assert F.nargs == FiniteSet(1, 2)
# issue sympy/sympy#2711
f = meijerg(((), ()), ((0, ), ()), x)
a = Wild('a')
b = Wild('b')
assert f.find(a) == {
0: 1,
x: 1,
meijerg(((), ()), ((0, ), ()), x): 1,
(): 3,
(0, ): 1,
((), ()): 1,
((0, ), ()): 1
}
assert f.find(a + b) == {0: 1, x: 1, meijerg(((), ()), ((0, ), ()), x): 1}
assert f.find(a**2) == {x: 1, meijerg(((), ()), ((0, ), ()), x): 1}
def test_domains():
X, Y = Die('x', 6), Die('y', 6)
x, y = X.symbol, Y.symbol
# Domains
d = where(X > Y)
assert d.condition == (x > y)
d = where(And(X > Y, Y > 3))
assert d.as_boolean() == Or(And(Eq(x, 5), Eq(y,
4)), And(Eq(x, 6), Eq(y, 5)),
And(Eq(x, 6), Eq(y, 4)))
assert len(d.elements) == 3
assert len(pspace(X + Y).domain.elements) == 36
Z = Die('x', 4)
pytest.raises(ValueError,
lambda: P(X > Z)) # Two domains with same internal symbol
assert pspace(X + Y).domain.set == FiniteSet(1, 2, 3, 4, 5, 6)**2
assert where(X > 3).set == FiniteSet(4, 5, 6)
assert X.pspace.domain.dict == FiniteSet(
*[Dict({X.symbol: i}) for i in range(1, 7)])
assert where(X > Y).dict == FiniteSet(*[
Dict({
X.symbol: i,
Y.symbol: j
}) for i in range(1, 7) for j in range(1, 7) if i > j
])
def test_measure():
a = Symbol('a', extended_real=True)
assert Interval(1, 3).measure == 2
assert Interval(0, a).measure == a
assert Interval(1, a).measure == a - 1
assert Union(Interval(1, 2), Interval(3, 4)).measure == 2
assert Union(Interval(1, 2), Interval(3, 4), FiniteSet(5, 6, 7)).measure \
== 2
assert FiniteSet(1, 2, oo, a, -oo, -5).measure == 0
assert S.EmptySet.measure == 0
square = Interval(0, 10) * Interval(0, 10)
offsetsquare = Interval(5, 15) * Interval(5, 15)
band = Interval(-oo, oo) * Interval(2, 4)
assert square.measure == offsetsquare.measure == 100
assert (square + offsetsquare).measure == 175 # there is some overlap
assert (square - offsetsquare).measure == 75
assert (square * FiniteSet(1, 2, 3)).measure == 0
assert (square.intersection(band)).measure == 20
assert (square + band).measure == oo
assert (band * FiniteSet(1, 2, 3)).measure == nan
def test_sympyissue_9637():
n = Symbol('n')
a = FiniteSet(n)
b = FiniteSet(2, n)
assert Complement(S.Reals, a) == Complement(S.Reals, a, evaluate=False)
assert Complement(Interval(1, 3), a) == Complement(Interval(1, 3), a, evaluate=False)
assert (Complement(Interval(1, 3), b) ==
Complement(Union(Interval(1, 2, right_open=True),
Interval(2, 3, left_open=True)), a, evaluate=False))
assert Complement(a, S.Reals) == Complement(a, S.Reals, evaluate=False)
assert Complement(a, Interval(1, 3)) == Complement(a, Interval(1, 3), evaluate=False)
def test_Eq():
assert Eq(Interval(0, 1), Interval(0, 1))
assert Eq(Interval(0, 1), Interval(0, 2)) is S.false
s1 = FiniteSet(0, 1)
s2 = FiniteSet(1, 2)
assert Eq(s1, s1)
assert Eq(s1, s2) is S.false
assert Eq(s1 * s2, s1 * s2)
assert Eq(s1 * s2, s2 * s1) is S.false
def test_contains():
assert Interval(0, 2).contains(1) is true
assert Interval(0, 2).contains(3) is false
assert Interval(0, 2, True, False).contains(0) is false
assert Interval(0, 2, True, False).contains(2) is true
assert Interval(0, 2, False, True).contains(0) is true
assert Interval(0, 2, False, True).contains(2) is false
assert Interval(0, 2, True, True).contains(0) is false
assert Interval(0, 2, True, True).contains(2) is false
assert Interval(0, 2) not in Interval(0, 2)
# issue sympy/sympy#10326
assert S.Reals.contains(oo) is false
assert S.Reals.contains(-oo) is false
assert Interval(-oo, oo, True).contains(oo) is true
assert Interval(-oo, oo).contains(-oo) is true
bad = [EmptySet(), FiniteSet(1), Interval(1, 2), zoo,
I, oo, nan, -oo]
assert all(i not in Interval(0, 5) for i in bad)
assert FiniteSet(1, 2, 3).contains(2) is true
assert FiniteSet(1, 2, x).contains(x) is true
# issue sympy/sympy#8197
assert isinstance(FiniteSet(b).contains(-a), Contains)
assert isinstance(FiniteSet(b).contains(a), Contains)
assert isinstance(FiniteSet(a).contains(1), Contains)
pytest.raises(TypeError, lambda: 1 in FiniteSet(a))
# issue sympy/sympy#8209
rad1 = Integer(4)
rad2 = Pow(2, 2, evaluate=False)
s1 = FiniteSet(rad1)
s2 = FiniteSet(rad2)
assert s1 - s2 == S.EmptySet
items = [1, 2, oo, Symbol('ham'), -1.1]
fset = FiniteSet(*items)
assert all(item in fset for item in items)
assert all(fset.contains(item) is true for item in items)
assert Union(Interval(0, 1), Interval(2, 5)).contains(3) is true
assert Union(Interval(0, 1), Interval(2, 5)).contains(6) is false
assert Union(Interval(0, 1), FiniteSet(2, 5)).contains(3) is false
assert S.EmptySet.contains(1) is false
assert FiniteSet(RootOf(x**3 + x - 1, 0)).contains(oo) is false
assert RootOf(x**5 + x**3 + 1, 0) in S.Reals
assert not RootOf(x**5 + x**3 + 1, 1) in S.Reals
def test_booleans():
"""Test basic unions and intersections."""
assert Union(l1, l2).equal(l1)
assert Intersection(l1, l2).equal(l1)
assert Intersection(l1, l4) == FiniteSet(Point(1, 1))
assert Intersection(Union(l1, l4),
l3) == FiniteSet(Point(-1 / 3, -1 / 3), Point(5, 1))
assert Intersection(l1, FiniteSet(Point(7, -7))) == EmptySet()
assert Intersection(Circle(Point(0, 0), 3),
Line(p1, p2)) == FiniteSet(Point(-3, 0), Point(3, 0))
fs = FiniteSet(Point(1 / 3, 1), Point(2 / 3, 0), Point(9 / 5, 1 / 5),
Point(7 / 3, 1))
# test the intersection of polygons
assert Intersection(poly1, poly2) == fs
# make sure if we union polygons with subsets, the subsets go away
assert Union(poly1, poly2, fs) == Union(poly1, poly2)
# make sure that if we union with a FiniteSet that isn't a subset,
# that the points in the intersection stop being listed
assert Union(poly1, FiniteSet(Point(0, 0),
Point(3,
5))) == Union(poly1,
FiniteSet(Point(3, 5)))
# intersect two polygons that share an edge
assert Intersection(poly1, poly3) == Union(
FiniteSet(Point(3 / 2, 1), Point(2, 1)),
Segment(Point(0, 0), Point(1, 0)))
def test_Lambda():
e = Lambda(x, x**2)
assert e(4) == 16
assert e(x) == x**2
assert e(y) == y**2
assert Lambda(x, x**2) == Lambda(x, x**2)
assert Lambda(x, x**2) == Lambda(y, y**2)
assert Lambda(x, x**2) != Lambda(y, y**2 + 1)
assert Lambda((x, y), x**y) == Lambda((y, x), y**x)
assert Lambda((x, y), x**y) != Lambda((x, y), y**x)
assert Lambda((x, y), x**y)(x, y) == x**y
assert Lambda((x, y), x**y)(3, 3) == 3**3
assert Lambda((x, y), x**y)(x, 3) == x**3
assert Lambda((x, y), x**y)(3, y) == 3**y
assert Lambda(x, f(x))(x) == f(x)
assert Lambda(x, x**2)(e(x)) == x**4
assert e(e(x)) == x**4
assert Lambda((x, y), x + y).nargs == FiniteSet(2)
p = x, y, z, t
assert Lambda(p, t*(x + y + z))(*p) == t * (x + y + z)
assert Lambda(x, 2*x) + Lambda(y, 2*y) == 2*Lambda(x, 2*x)
assert Lambda(x, 2*x) not in [ Lambda(x, x) ]
pytest.raises(TypeError, lambda: Lambda(1, x))
assert Lambda(x, 1)(1) is Integer(1)
assert (2*x).canonical_variables == {}
assert Lambda(x, 2*x).canonical_variables == {x: Symbol('0_')}
x_ = Symbol('x_')
assert Lambda(x_, 2*x_).canonical_variables == {x_: Symbol('0__')}
def test_atan():
assert atan(nan) == nan
assert atan.nargs == FiniteSet(1)
assert atan(oo) == pi/2
assert atan(-oo) == -pi/2
assert atan(0) == 0
assert atan(1) == pi/4
assert atan(sqrt(3)) == pi/3
assert atan(oo) == pi/2
assert atan(x).diff(x) == 1/(1 + x**2)
assert atan(r).is_extended_real is True
assert atan(-2*I) == -I*atanh(2)
assert atan(p).is_positive is True
assert atan(n).is_positive is False
assert atan(x).is_positive is None
assert atan(0, evaluate=False).is_rational
assert atan(1, evaluate=False).is_rational is False
z = Symbol('z', zero=True)
rn = Symbol('rn', rational=True, nonzero=True)
assert atan(z).is_rational
assert atan(rn).is_rational is False
assert atan(x).is_rational is None
pytest.raises(ArgumentIndexError, lambda: atan(x).fdiff(2))
def test_powerset():
# EmptySet
A = FiniteSet()
pset = A.powerset()
assert len(pset) == 1
assert pset == FiniteSet(S.EmptySet)
# FiniteSets
A = FiniteSet(1, 2)
pset = A.powerset()
assert len(pset) == 2**len(A)
assert pset == FiniteSet(FiniteSet(), FiniteSet(1),
FiniteSet(2), A)
# Not finite sets
I = Interval(0, 1)
pytest.raises(NotImplementedError, I.powerset)
def test_real():
x = Symbol('x', real=True)
I = Interval(0, 5)
J = Interval(10, 20)
A = FiniteSet(1, 2, 30, x, pi)
B = FiniteSet(-4, 0)
C = FiniteSet(100)
D = FiniteSet('Ham', 'Eggs')
assert all(s.is_subset(S.Reals) for s in [I, J, A, B, C])
assert not D.is_subset(S.Reals)
assert all((a + b).is_subset(S.Reals) for a in [I, J, A, B, C] for b in [I, J, A, B, C])
assert not any((a + D).is_subset(S.Reals) for a in [I, J, A, B, C, D])
assert not (I + A + D).is_subset(S.Reals)
def test_intersection():
# iterable
i = Intersection(FiniteSet(1, 2, 3), Interval(2, 5), evaluate=False)
assert i.is_iterable
assert set(i) == {Integer(2), Integer(3)}
# challenging intervals
x = Symbol('x', extended_real=True)
i = Intersection(Interval(0, 3), Interval(x, 6))
assert (5 in i) is False
pytest.raises(TypeError, lambda: 2 in i)
# Singleton special cases
assert Intersection(Interval(0, 1), S.EmptySet) == S.EmptySet
assert Intersection(S.Reals, Interval(-oo, x,
True)) == Interval(-oo, x, True)
# Products
line = Interval(0, 5)
i = Intersection(line**2, line**3, evaluate=False)
assert (2, 2) not in i
assert (2, 2, 2) not in i
pytest.raises(ValueError, lambda: list(i))
assert (Intersection(Intersection(S.Integers, S.Naturals, evaluate=False),
S.Reals,
evaluate=False) == Intersection(S.Integers,
S.Naturals,
S.Reals,
evaluate=False))
def test_acot():
assert acot(nan) == nan
assert acot.nargs == FiniteSet(1)
assert acot(-oo) == 0
assert acot(oo) == 0
assert acot(1) == pi/4
assert acot(0) == pi/2
assert acot(sqrt(3)/3) == pi/3
assert acot(1/sqrt(3)) == pi/3
assert acot(-1/sqrt(3)) == -pi/3
assert acot(x).diff(x) == -1/(1 + x**2)
assert acot(r).is_extended_real is True
assert acot(I*pi) == -I*acoth(pi)
assert acot(-2*I) == I*acoth(2)
assert acot(x).is_positive is None
assert acot(p).is_positive is True
assert acot(I).is_positive is False
assert acot(0, evaluate=False).is_rational is False
q = Symbol('q', rational=True)
assert acot(q).is_rational is False
assert acot(x).is_rational is None
pytest.raises(ArgumentIndexError, lambda: acot(x).fdiff(2))
def test_sympyissue_9808():
assert (Complement(FiniteSet(y),
FiniteSet(1)) == Complement(FiniteSet(y),
FiniteSet(1),
evaluate=False))
assert (Complement(FiniteSet(1, 2, x),
FiniteSet(x, y, 2, 3)) == Complement(FiniteSet(1),
FiniteSet(y),
evaluate=False))
def test_Function():
class MyFunc(Function):
@classmethod
def eval(cls, x): # one arg
return
assert MyFunc.nargs == FiniteSet(1)
assert MyFunc(x).nargs == FiniteSet(1)
pytest.raises(TypeError, lambda: MyFunc(x, y).nargs)
class MyFunc(Function):
@classmethod
def eval(cls, *x): # star args
return
assert MyFunc.nargs == S.Naturals0
assert MyFunc(x).nargs == S.Naturals0
def test_image_piecewise():
f = Piecewise((x, x <= -1), (1 / x**2, x <= 5), (x**3, True))
f1 = Piecewise((0, x <= 1), (1, x <= 2), (2, True))
f2 = Piecewise((x, x <= -1), (x**3, True))
assert imageset(x, f, Interval(-5, 5)) == Union(
Interval(-5, -1), Interval(Rational(1, 25), oo, false, true))
assert imageset(x, f1, Interval(1, 2)) == FiniteSet(0, 1)
assert imageset(x, f2, Interval(-2, 2)) == Interval(-2, 8)
def test_dice():
# TODO: Make iid method!
X, Y, Z = Die('X', 6), Die('Y', 6), Die('Z', 6)
a, b = symbols('a b')
assert E(X) == 3 + Rational(1, 2)
assert variance(X) == Rational(35, 12)
assert E(X + Y) == 7
assert E(X + X) == 7
assert E(a * X + b) == a * E(X) + b
assert variance(X + Y) == variance(X) + variance(Y) == cmoment(X + Y, 2)
assert variance(X + X) == 4 * variance(X) == cmoment(X + X, 2)
assert cmoment(X, 0) == 1
assert cmoment(4 * X, 3) == 64 * cmoment(X, 3)
assert covariance(X, Y) == 0
assert covariance(X, X + Y) == variance(X)
assert density(Eq(cos(X * pi), 1))[True] == Rational(1, 2)
assert correlation(X, Y) == 0
assert correlation(X, Y) == correlation(Y, X)
assert smoment(X + Y, 3) == skewness(X + Y)
assert smoment(X, 0) == 1
assert P(X > 3) == Rational(1, 2)
assert P(2 * X > 6) == Rational(1, 2)
assert P(X > Y) == Rational(5, 12)
assert P(Eq(X, Y)) == P(Eq(X, 1))
assert E(X, X > 3) == 5 == moment(X, 1, 0, X > 3)
assert E(X, Y > 3) == E(X) == moment(X, 1, 0, Y > 3)
assert E(X + Y, Eq(X, Y)) == E(2 * X)
assert moment(X, 0) == 1
assert moment(5 * X, 2) == 25 * moment(X, 2)
assert P(X > 3, X > 3) == 1
assert P(X > Y, Eq(Y, 6)) == 0
assert P(Eq(X + Y, 12)) == Rational(1, 36)
assert P(Eq(X + Y, 12), Eq(X, 6)) == Rational(1, 6)
assert density(X + Y) == density(Y + Z) != density(X + X)
d = density(2 * X + Y**Z)
assert d[22] == Rational(1, 108) and d[4100] == Rational(
1, 216) and 3130 not in d
assert pspace(X).domain.as_boolean() == Or(
*[Eq(X.symbol, i) for i in [1, 2, 3, 4, 5, 6]])
assert where(X > 3).set == FiniteSet(4, 5, 6)
X = Die('X', 2)
x = X.symbol
assert X.pspace.compute_cdf(X) == {1: Rational(1, 2), 2: 1}
assert X.pspace.sorted_cdf(X) == [(1, Rational(1, 2)), (2, 1)]
assert X.pspace.compute_density(X)(1) == Rational(1, 2)
assert X.pspace.compute_density(X)(0) == 0
assert X.pspace.compute_density(X)(8) == 0
assert X.pspace.density == x
def test_SymmetricDifference():
assert (SymmetricDifference(FiniteSet(0, 1, 2, 3, 4, 5),
FiniteSet(2, 4, 6, 8, 10)) == FiniteSet(
0, 1, 3, 5, 6, 8, 10))
assert (SymmetricDifference(FiniteSet(2, 3, 4),
FiniteSet(2, 3, 4, 5)) == FiniteSet(5))
assert (FiniteSet(1, 2, 3, 4, 5) ^ FiniteSet(1, 2, 5, 6) == FiniteSet(
3, 4, 6))
assert (Set(1, 2, 3) ^ Set(2, 3, 4) == Union(
Set(1, 2, 3) - Set(2, 3, 4),
Set(2, 3, 4) - Set(1, 2, 3)))
assert (Interval(0, 4) ^ Interval(2, 5) == Union(
Interval(0, 4) - Interval(2, 5),
Interval(2, 5) - Interval(0, 4)))
def test_imageset_intersection_real():
assert (imageset(Lambda(n, n + (n - 1) * (n + 1) * I),
S.Integers).intersection(S.Reals) == FiniteSet(-1, 1))
s = ImageSet(
Lambda(n, -I * (I * (2 * pi * n - pi / 4) + log(abs(sqrt(-I))))),
S.Integers)
assert s.intersection(S.Reals) == imageset(Lambda(n, 2 * n * pi - pi / 4),
S.Integers)
def test_functions():
g = WildFunction('g')
p = Wild('p')
q = Wild('q')
f = cos(5 * x)
notf = x
assert f.match(p * cos(q * x)) == {p: 1, q: 5}
assert f.match(p * g) == {p: 1, g: cos(5 * x)}
assert notf.match(g) is None
F = WildFunction('F', nargs=2)
assert F.nargs == FiniteSet(2)
f = Function('f')
assert f(x).match(F) is None
F = WildFunction('F', nargs=(1, 2))
assert F.nargs == FiniteSet(1, 2)
def test_univariate_relational_as_set():
assert (x > 0).as_set() == Interval(0, oo, True)
assert (x >= 0).as_set() == Interval(0, oo)
assert (x < 0).as_set() == Interval(-oo, 0, False, True)
assert (x <= 0).as_set() == Interval(-oo, 0)
assert Eq(x, 0).as_set() == FiniteSet(0)
assert Ne(x, 0).as_set() == Interval(-oo, 0, False, True) + Interval(0, oo, True)
assert (x**2 >= 4).as_set() == Interval(-oo, -2) + Interval(2, oo)
def test_ImageSet():
squares = ImageSet(Lambda(x, x**2), S.Naturals)
assert 4 in squares
assert 5 not in squares
assert FiniteSet(*range(10)).intersection(squares) == FiniteSet(1, 4, 9)
assert 16 not in squares.intersection(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 harmonics.is_iterable
def test_sympyissue_11732():
interval12 = Interval(1, 2)
finiteset1234 = FiniteSet(1, 2, 3, 4)
assert (interval12 in S.Naturals) is False
assert (interval12 in S.Naturals0) is False
assert (interval12 in S.Integers) is False
assert (finiteset1234 in S.Naturals) is False
assert (finiteset1234 in S.Naturals0) is False
assert (finiteset1234 in S.Integers) is False
def test_range_interval_intersection():
# Intersection with intervals
assert FiniteSet(*Range(0, 10, 1).intersection(Interval(2, 6))) == \
FiniteSet(2, 3, 4, 5, 6)
# Open Intervals are removed
assert (FiniteSet(*Range(0, 10, 1).intersection(Interval(
2, 6, True, True))) == FiniteSet(3, 4, 5))
# Try this with large steps
assert (FiniteSet(
*Range(0, 100, 10).intersection(Interval(15, 55))) == FiniteSet(
20, 30, 40, 50))
# Going backwards
assert (FiniteSet(
*Range(10, -9, -3).intersection(Interval(-5, 6))) == FiniteSet(
-5, -2, 1, 4))
assert (FiniteSet(
*Range(10, -9, -3).intersection(Interval(-5, 6, True))) == FiniteSet(
-2, 1, 4))
def test_asin():
assert asin(nan) == nan
assert asin.nargs == FiniteSet(1)
assert asin(oo) == -I*oo
assert asin(-oo) == I*oo
# Note: asin(-x) = - asin(x)
assert asin(0) == 0
assert asin(1) == pi/2
assert asin(-1) == -pi/2
assert asin(sqrt(3)/2) == pi/3
assert asin(-sqrt(3)/2) == -pi/3
assert asin(sqrt(2)/2) == pi/4
assert asin(-sqrt(2)/2) == -pi/4
assert asin(sqrt((5 - sqrt(5))/8)) == pi/5
assert asin(-sqrt((5 - sqrt(5))/8)) == -pi/5
assert asin(Rational(1, 2)) == pi/6
assert asin(-Rational(1, 2)) == -pi/6
assert asin((sqrt(2 - sqrt(2)))/2) == pi/8
assert asin(-(sqrt(2 - sqrt(2)))/2) == -pi/8
assert asin((sqrt(5) - 1)/4) == pi/10
assert asin(-(sqrt(5) - 1)/4) == -pi/10
assert asin((sqrt(3) - 1)/sqrt(2**3)) == pi/12
assert asin(-(sqrt(3) - 1)/sqrt(2**3)) == -pi/12
assert asin(x).diff(x) == 1/sqrt(1 - x**2)
assert asin(c).is_complex
assert asin(x).is_complex is None
assert asin(0.2).is_extended_real is True
assert asin(-2).is_extended_real is False
assert asin(r).is_extended_real is None
assert asin(0, evaluate=False).is_rational
assert asin(1, evaluate=False).is_rational is False
z = Symbol('z', zero=True)
rn = Symbol('rn', rational=True, nonzero=True)
assert asin(z).is_rational
assert asin(rn).is_rational is False
assert asin(x).is_rational is None
assert asin(-2*I) == -I*asinh(2)
assert asin(Rational(1, 7), evaluate=False).is_positive is True
assert asin(Rational(-1, 7), evaluate=False).is_positive is False
assert asin(p).is_positive is None
pytest.raises(ArgumentIndexError, lambda: asin(x).fdiff(2))
def test_sympyissue_10337():
assert (FiniteSet(2) == 3) is False
assert (FiniteSet(2) != 3) is True
pytest.raises(TypeError, lambda: FiniteSet(2) < 3)
pytest.raises(TypeError, lambda: FiniteSet(2) <= 3)
pytest.raises(TypeError, lambda: FiniteSet(2) > 3)
pytest.raises(TypeError, lambda: FiniteSet(2) >= 3)
def test_nargs():
f = Function('f')
assert f.nargs == S.Naturals0
assert f(1).nargs == S.Naturals0
assert Function('f', nargs=2)(1, 2).nargs == FiniteSet(2)
assert sin.nargs == FiniteSet(1)
assert sin(2).nargs == FiniteSet(1)
assert log.nargs == FiniteSet(1, 2)
assert log(2).nargs == FiniteSet(1, 2)
assert Function('f', nargs=2).nargs == FiniteSet(2)
assert Function('f', nargs=0).nargs == FiniteSet(0)
assert Function('f', nargs=(0, 1)).nargs == FiniteSet(0, 1)
assert Function('f', nargs=None).nargs == S.Naturals0
pytest.raises(ValueError, lambda: Function('f', nargs=()))
p = Function('g', nargs=(1, 2))(1)
assert p.args == (1,) and p.nargs == FiniteSet(1, 2)
pytest.raises(ValueError, lambda: sin(x, no_such_option=1))
def test_finite_basic():
assert isinstance(FiniteSet(evaluate=False), FiniteSet)
A = FiniteSet(1, 2, 3)
B = FiniteSet(3, 4, 5)
AorB = Union(A, B)
AandB = A.intersection(B)
assert A.is_subset(AorB) and B.is_subset(AorB)
assert AandB.is_subset(A)
assert AandB == FiniteSet(3)
assert A.inf == 1 and A.sup == 3
assert AorB.inf == 1 and AorB.sup == 5
assert FiniteSet(x, 1, 5).sup == Max(x, 5)
assert FiniteSet(x, 1, 5).inf == Min(x, 1)
# issue sympy/sympy#7335
assert FiniteSet(S.EmptySet) != S.EmptySet
assert FiniteSet(FiniteSet(1, 2, 3)) != FiniteSet(1, 2, 3)
assert FiniteSet((1, 2, 3)) != FiniteSet(1, 2, 3)
# Ensure a variety of types can exist in a FiniteSet
assert FiniteSet((1, 2), Float, A, -5, x, 'eggs', x**2, Interval)
assert (A > B) is False
assert (A >= B) is False
assert (A < B) is False
assert (A <= B) is False
assert AorB > A and AorB > B
assert AorB >= A and AorB >= B
assert A >= A and A <= A
assert A >= AandB and B >= AandB
assert A > AandB and B > AandB
assert (FiniteSet(pi, E).evalf() ==
FiniteSet(Float('2.7182818284590451', dps=15),
Float('3.1415926535897931', dps=15)))
def test_boundary_ProductSet():
open_square = Interval(0, 1, True, True) ** 2
assert open_square.boundary == (FiniteSet(0, 1) * Interval(0, 1) +
Interval(0, 1) * FiniteSet(0, 1))
second_square = Interval(1, 2, True, True) * Interval(0, 1, True, True)
assert ((open_square + second_square).boundary ==
(FiniteSet(0, 1)*Interval(0, 1) + FiniteSet(1, 2)*Interval(0, 1) +
Interval(0, 1)*FiniteSet(0, 1) + Interval(1, 2)*FiniteSet(0, 1)))
def test_Eq():
assert Eq(Interval(0, 1), Interval(0, 1))
assert Eq(Interval(0, 1), Union(Interval(2, 3),
Interval(4, 5))).is_Equality
assert Eq(Interval(0, 1), Interval(0, 2)) is S.false
s1 = FiniteSet(0, 1)
s2 = FiniteSet(1, 2)
assert Eq(s1, s1)
assert Eq(s1, s2) is S.false
assert Eq(FiniteSet(1, 2), FiniteSet(3, 4, 5)) is S.false
assert Eq(s1*s2, s1*s2)
assert Eq(s1*s2, s2*s1) is S.false
p1 = ProductSet(FiniteSet(1), FiniteSet(2))
assert Eq(p1, s1).is_Equality
p2 = ProductSet(FiniteSet(1), FiniteSet(2), FiniteSet(3))
assert Eq(p1, p2) is S.false
def test_union_contains():
i1 = Interval(0, 1)
i2 = Interval(2, 3)
i3 = Union(i1, i2)
pytest.raises(TypeError, lambda: x in i3)
e = i3.contains(x)
assert e == Or(And(0 <= x, x <= 1), And(2 <= x, x <= 3))
assert e.subs(x, -0.5) is false
assert e.subs(x, 0.5) is true
assert e.subs(x, 1.5) is false
assert e.subs(x, 2.5) is true
assert e.subs(x, 3.5) is false
U = Interval(0, 2, True, True) + Interval(10, oo) + FiniteSet(-1, 2, 5, 6)
assert all(el not in U for el in [0, 4, -oo])
assert all(el in U for el in [2, 5, 10])
def test_boundary_Union():
assert (Interval(0, 1) + Interval(2, 3)).boundary == FiniteSet(0, 1, 2, 3)
assert ((Interval(0, 1, False, True) +
Interval(1, 2, True, False)).boundary == FiniteSet(0, 1, 2))
assert (Interval(0, 1) + FiniteSet(2)).boundary == FiniteSet(0, 1, 2)
assert (Union(Interval(0, 10), Interval(5, 15), evaluate=False).boundary ==
FiniteSet(0, 15))
assert (Union(Interval(0, 10), Interval(0, 1), evaluate=False).boundary ==
FiniteSet(0, 10))
assert (Union(Interval(0, 10, True, True),
Interval(10, 15, True, True), evaluate=False).boundary ==
FiniteSet(0, 10, 15))
