def test_to_nnf():
assert to_nnf(true) is true
assert to_nnf(false) is false
assert to_nnf(A) == A
assert (~A).to_nnf() == ~A
class Boo(BooleanFunction):
pass
pytest.raises(ValueError, lambda: to_nnf(~Boo(A)))
assert to_nnf(A | ~A | B) is true
assert to_nnf(A & ~A & B) is false
assert to_nnf(A >> B) == ~A | B
assert to_nnf(Equivalent(A, B, C)) == (~A | B) & (~B | C) & (~C | A)
assert to_nnf(A ^ B ^ C) == \
(A | B | C) & (~A | ~B | C) & (A | ~B | ~C) & (~A | B | ~C)
assert to_nnf(ITE(A, B, C)) == (~A | B) & (A | C)
assert to_nnf(Not(A | B | C)) == ~A & ~B & ~C
assert to_nnf(Not(A & B & C)) == ~A | ~B | ~C
assert to_nnf(Not(A >> B)) == A & ~B
assert to_nnf(Not(Equivalent(A, B, C))) == And(Or(A, B, C), Or(~A, ~B, ~C))
assert to_nnf(Not(A ^ B ^ C)) == \
(~A | B | C) & (A | ~B | C) & (A | B | ~C) & (~A | ~B | ~C)
assert to_nnf(Not(ITE(A, B, C))) == (~A | ~B) & (A | ~C)
assert to_nnf((A >> B) ^ (B >> A)) == (A & ~B) | (~A & B)
assert to_nnf((A >> B) ^ (B >> A), False) == \
(~A | ~B | A | B) & ((A & ~B) | (~A & B))
def test_bool_symbol():
assert And(a, True) == a
assert And(a, True, True) == a
assert And(a, False) is false
assert And(a, True, False) is false
assert Or(a, True) is true
assert Or(a, False) == a
def test_issue_7173():
assert laplace_transform(sinh(a*x)*cosh(a*x), x, s) == \
(a/(s**2 - 4*a**2), 0,
And(Or(Abs(periodic_argument(exp_polar(I*pi)*polar_lift(a), oo)) <
pi/2, Abs(periodic_argument(exp_polar(I*pi)*polar_lift(a), oo)) <=
pi/2), Or(Abs(periodic_argument(a, oo)) < pi/2,
Abs(periodic_argument(a, oo)) <= pi/2)))
def test_reduce_piecewise_inequalities():
e = abs(x - 5) < 3
ans = And(Lt(2, x), Lt(x, 8))
assert reduce_inequalities(e) == ans
assert reduce_inequalities(e, x) == ans
assert reduce_inequalities(abs(x - 5)) == Eq(x, 5)
assert reduce_inequalities(
abs(2*x + 3) >= 8) == Or(And(Le(Rational(5, 2), x), Lt(x, oo)),
And(Le(x, -Rational(11, 2)), Lt(-oo, x)))
assert reduce_inequalities(abs(x - 4) + abs(
3*x - 5) < 7) == And(Lt(Rational(1, 2), x), Lt(x, 4))
assert reduce_inequalities(abs(x - 4) + abs(3*abs(x) - 5) < 7) == \
Or(And(Integer(-2) < x, x < -1), And(Rational(1, 2) < x, x < 4))
nr = Symbol('nr', extended_real=False)
pytest.raises(TypeError, lambda: reduce_inequalities(abs(nr - 5) < 3))
# sympy/sympy#10198
assert reduce_inequalities(-1 + 1/abs(1/x - 1) < 0) == \
Or(And(S.Zero < x, x < S.Half), And(-oo < x, x < S.Zero))
# sympy/sympy#10255
assert reduce_inequalities(Piecewise((1, x < 1), (3, True)) > 1) == \
And(S.One <= x, x < oo)
assert reduce_inequalities(Piecewise((x**2, x < 0), (2*x, x >= 0)) < 1) == \
And(-S.One < x, x < S.Half)
def test_is_literal():
assert is_literal(True) is True
assert is_literal(False) is True
assert is_literal(A) is True
assert is_literal(~A) is True
assert is_literal(Or(A, B)) is False
assert is_literal(Or(A, B)) is False
def test_solve_univariate_inequality():
assert isolve(x**2 >= 4, x, relational=False) == Union(Interval(-oo, -2, True),
Interval(2, oo, False, True))
assert isolve(x**2 >= 4, x) == Or(And(Le(2, x), Lt(x, oo)), And(Le(x, -2),
Lt(-oo, x)))
assert isolve((x - 1)*(x - 2)*(x - 3) >= 0, x, relational=False) == \
Union(Interval(1, 2), Interval(3, oo, False, True))
assert isolve((x - 1)*(x - 2)*(x - 3) >= 0, x) == \
Or(And(Le(1, x), Le(x, 2)), And(Le(3, x), Lt(x, oo)))
# issue sympy/sympy#2785:
assert isolve(x**3 - 2*x - 1 > 0, x, relational=False) == \
Union(Interval(-1, -sqrt(5)/2 + Rational(1, 2), True, True),
Interval(Rational(1, 2) + sqrt(5)/2, oo, True, True))
# issue sympy/sympy#2794:
assert isolve(x**3 - x**2 + x - 1 > 0, x, relational=False) == \
Interval(1, oo, True, True)
# XXX should be limited in domain, e.g. between 0 and 2*pi
assert isolve(sin(x) < S.Half, x) == \
Or(And(-oo < x, x < pi/6), And(5*pi/6 < x, x < oo))
assert isolve(sin(x) > S.Half, x) == And(pi/6 < x, x < 5*pi/6)
# numerical testing in valid() is needed
assert isolve(x**7 - x - 2 > 0, x) == \
And(RootOf(x**7 - x - 2, 0) < x, x < oo)
# handle numerator and denominator; although these would be handled as
# rational inequalities, these test confirm that the right thing is done
# when the domain is EX (e.g. when 2 is replaced with sqrt(2))
assert isolve(1/(x - 2) > 0, x) == And(Integer(2) < x, x < oo)
den = ((x - 1)*(x - 2)).expand()
assert isolve((x - 1)/den <= 0, x) == \
Or(And(-oo < x, x < 1), And(Integer(1) < x, x < 2))
assert isolve(x > oo, x) is S.false
def test_bool_symbol():
"""Test that mixing symbols with boolean values works as expected."""
assert And(A, True) == A
assert And(A, True, True) == A
assert And(A, False) is false
assert And(A, True, False) is false
assert Or(A, True) is true
assert Or(A, False) == A
def test_overloading():
"""Test that |, & are overloaded as expected."""
assert A & B == And(A, B)
assert A | B == Or(A, B)
assert (A & B) | C == Or(And(A, B), C)
assert A >> B == Implies(A, B)
assert A << B == Implies(B, A)
assert ~A == Not(A)
assert A ^ B == Xor(A, B)
def test_to_dnf():
assert to_dnf(true) == true
assert to_dnf((~B) & (~C)) == (~B) & (~C)
assert to_dnf(~(B | C)) == And(Not(B), Not(C))
assert to_dnf(A & (B | C)) == Or(And(A, B), And(A, C))
assert to_dnf(A >> B) == (~A) | B
assert to_dnf(A >> (B & C)) == (~A) | (B & C)
assert to_dnf(Equivalent(A, B), True) == \
Or(And(A, B), And(Not(A), Not(B)))
assert to_dnf(Equivalent(A, B & C), True) == \
Or(And(A, B, C), And(Not(A), Not(B)), And(Not(A), Not(C)))
def test_laplace_transform_2():
LT = laplace_transform
# issue sympy/sympy#7173
assert LT(sinh(a*x)*cosh(a*x), x, s) == \
(a/(s**2 - 4*a**2), 0,
And(Or(abs(periodic_argument(exp_polar(I*pi)*polar_lift(a), oo)) <
pi/2, abs(periodic_argument(exp_polar(I*pi)*polar_lift(a), oo)) <=
pi/2), Or(abs(periodic_argument(a, oo)) < pi/2,
abs(periodic_argument(a, oo)) <= pi/2)))
# issues sympy/sympy#8368 and sympy/sympy#7173
assert LT(sinh(x) * cosh(x), x, s) == (1 / (s**2 - 4), 2, Ne(s / 2, 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_equals():
assert Not(Or(A, B)).equals( And(Not(A), Not(B)) ) is True
assert Equivalent(A, B).equals((A >> B) & (B >> A)) is True
assert ((A | ~B) & (~A | B)).equals((~A & ~B) | (A & B)) is True
assert (A >> B).equals(~A >> ~B) is False
assert (A >> (B >> A)).equals(A >> (C >> A)) is False
pytest.raises(NotImplementedError, lambda: And(A, A < B).equals(And(A, B > A)))
def test_satisfiable_all_models():
assert next(satisfiable(False, all_models=True)) is False
assert list(satisfiable((a >> ~a) & a, all_models=True)) == [False]
assert list(satisfiable(True, all_models=True)) == [{true: true}]
assert next(satisfiable(a & ~a, all_models=True)) is False
models = [{a: True, b: False}, {a: False, b: True}]
result = satisfiable(a ^ b, all_models=True)
models.remove(next(result))
models.remove(next(result))
pytest.raises(StopIteration, lambda: next(result))
assert not models
assert list(satisfiable(Equivalent(a, b),
all_models=True)) == [{a: False, b: False},
{a: True, b: True}]
models = [{a: False, b: False}, {a: False, b: True}, {a: True, b: True}]
for model in satisfiable(a >> b, all_models=True):
models.remove(model)
assert not models
# This is a santiy test to check that only the required number
# of solutions are generated. The expr below has 2**100 - 1 models
# which would time out the test if all are generated at once.
X = [Symbol(f'x{i}') for i in range(100)]
result = satisfiable(Or(*X), all_models=True)
for _ in range(10):
assert next(result)
def test_satisfiable_all_models():
assert next(satisfiable(False, all_models=True)) is False
assert list(satisfiable((A >> ~A) & A, all_models=True)) == [False]
assert list(satisfiable(True, all_models=True)) == [{true: true}]
models = [{A: True, B: False}, {A: False, B: True}]
result = satisfiable(A ^ B, all_models=True)
models.remove(next(result))
models.remove(next(result))
pytest.raises(StopIteration, lambda: next(result))
assert not models
assert list(satisfiable(Equivalent(A, B), all_models=True)) == \
[{A: False, B: False}, {A: True, B: True}]
models = [{A: False, B: False}, {A: False, B: True}, {A: True, B: True}]
for model in satisfiable(A >> B, all_models=True):
models.remove(model)
assert not models
# This is a santiy test to check that only the required number
# of solutions are generated. The expr below has 2**100 - 1 models
# which would time out the test if all are generated at once.
sym = numbered_symbols()
X = [next(sym) for i in range(100)]
result = satisfiable(Or(*X), all_models=True)
for i in range(10):
assert next(result)
def test_FiniteRV():
F = FiniteRV('F', {1: Rational(1, 2), 2: Rational(1, 4), 3: Rational(1, 4)})
assert dict(density(F).items()) == {1: Rational(1, 2), 2: Rational(1, 4), 3: Rational(1, 4)}
assert P(F >= 2) == Rational(1, 2)
assert pspace(F).domain.as_boolean() == Or(
*[Eq(F.symbol, i) for i in [1, 2, 3]])
def test_FiniteRV():
F = FiniteRV('F', {1: S.Half, 2: S.One/4, 3: S.One/4})
assert dict(density(F).items()) == {Integer(1): S.Half, Integer(2): S.One/4, Integer(3): S.One/4}
assert P(F >= 2) == S.Half
assert pspace(F).domain.as_boolean() == Or(
*[Eq(F.symbol, i) for i in [1, 2, 3]])
def test_sympyissue_8235():
assert reduce_inequalities(x**2 - 1 < 0) == \
And(Integer(-1) < x, x < Integer(1))
assert reduce_inequalities(x**2 - 1 <= 0) == \
And(Integer(-1) <= x, x <= 1)
assert reduce_inequalities(x**2 - 1 > 0) == \
Or(And(-oo < x, x < -1), And(x < oo, Integer(1) < x))
assert reduce_inequalities(x**2 - 1 >= 0) == \
Or(And(-oo < x, x <= Integer(-1)), And(Integer(1) <= x, x < oo))
eq = x**8 + x - 9 # we want RootOf solns here
sol = reduce_inequalities(eq >= 0)
tru = Or(And(RootOf(eq, 1) <= x, x < oo), And(-oo < x, x <= RootOf(eq, 0)))
assert sol == tru
# recast vanilla as real
assert reduce_inequalities(sqrt((-x + 1)**2) < 1) == And(Integer(0) < x, x < 2)
def test_basic():
assert lambdarepr(x * y) == "x*y"
assert lambdarepr(x + y) in ["y + x", "x + y"]
assert lambdarepr(x**y) == "x**y"
assert lambdarepr(And(x, y)) == "((x) and (y))"
assert lambdarepr(Or(x, y)) == "((x) or (y))"
assert lambdarepr(Not(x)) == "(not (x))"
assert lambdarepr(false) == "False"
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_to_cnf():
assert to_cnf(~(B | C)) == And(Not(B), Not(C))
assert to_cnf((A & B) | C) == And(Or(A, C), Or(B, C))
assert to_cnf(A >> B) == (~A) | B
assert to_cnf(A >> (B & C)) == (~A | B) & (~A | C)
assert to_cnf(A & (B | C) | ~A & (B | C), True) == B | C
assert to_cnf(Equivalent(A, B)) == And(Or(A, Not(B)), Or(B, Not(A)))
assert to_cnf(Equivalent(A, B & C)) == \
(~A | B) & (~A | C) & (~B | ~C | A)
assert to_cnf(Equivalent(A, B | C), True) == \
And(Or(Not(B), A), Or(Not(C), A), Or(B, C, Not(A)))
assert to_cnf(~(A | B) | C) == And(Or(Not(A), C), Or(Not(B), C))
def test_numpy_logical_ops():
and_func = lambdify((x, y), And(x, y), modules="numpy")
or_func = lambdify((x, y), Or(x, y), modules="numpy")
not_func = lambdify((x), Not(x), modules="numpy")
arr1 = numpy.array([True, True])
arr2 = numpy.array([False, True])
numpy.testing.assert_array_equal(and_func(arr1, arr2), numpy.array([False, True]))
numpy.testing.assert_array_equal(or_func(arr1, arr2), numpy.array([True, True]))
numpy.testing.assert_array_equal(not_func(arr2), numpy.array([True, False]))
def test_basic():
assert lambdarepr(x * y) == 'x*y'
assert lambdarepr(x + y) in ['y + x', 'x + y']
assert lambdarepr(x**y) == 'x**y'
assert lambdarepr(And(x, y)) == '((x) and (y))'
assert lambdarepr(Or(x, y)) == '((x) or (y))'
assert lambdarepr(Not(x)) == '(not (x))'
assert lambdarepr(false) == 'False'
assert lambdarepr(Dummy('f(x)')) == '_f_lpar_x_rpar_'
def test_sympyissue_2787():
n, k = symbols('n k', positive=True, integer=True)
p = symbols('p', positive=True)
binomial_dist = binomial(n, k) * p**k * (1 - p)**(n - k)
s = summation(binomial_dist * k, (k, 0, n))
assert s.simplify() == Piecewise(
(n * p, And(Or(-n + 1 < 0, Ne(p / (p - 1), 1)), p / abs(p - 1) <= 1)),
(Sum(k * p**k * (-p + 1)**(-k) * (-p + 1)**n * binomial(n, k),
(k, 0, n)), True))
def test_fcode_precedence():
assert fcode(And(x < y, y < x + 1), source_format='free') == \
'x < y .and. y < x + 1'
assert fcode(Or(x < y, y < x + 1), source_format='free') == \
'x < y .or. y < x + 1'
assert fcode(Xor(x < y, y < x + 1, evaluate=False),
source_format='free') == 'x < y .neqv. y < x + 1'
assert fcode(Equivalent(x < y, y < x + 1), source_format='free') == \
'x < y .eqv. y < x + 1'
def test_bool_as_set():
assert And(x <= 2, x >= -2).as_set() == Interval(-2, 2)
assert Or(x >= 2, x <= -2).as_set() == (Interval(-oo, -2, True) +
Interval(2, oo, False, True))
assert Not(x > 2, evaluate=False).as_set() == Interval(-oo, 2, True)
# issue sympy/sympy#10240
assert Not(And(x > 2, x < 3)).as_set() == \
Union(Interval(-oo, 2, True), Interval(3, oo, False, True))
assert true.as_set() == S.UniversalSet
assert false.as_set() == EmptySet()
def test_piecewise_integrate_symbolic_conditions():
a = Symbol('a', real=True)
b = Symbol('b', real=True)
x = Symbol('x', real=True)
y = Symbol('y', real=True)
p0 = Piecewise((0, Or(x < a, x > b)), (1, True))
p1 = Piecewise((0, x < a), (0, x > b), (1, True))
p2 = Piecewise((0, x > b), (0, x < a), (1, True))
p3 = Piecewise((0, x < a), (1, x < b), (0, True))
p4 = Piecewise((0, x > b), (1, x > a), (0, True))
p5 = Piecewise((1, And(a < x, x < b)), (0, True))
assert integrate(p0, (x, -oo, y)) == Min(b, y) - Min(a, b, y)
assert integrate(p1, (x, -oo, y)) == Min(b, y) - Min(a, b, y)
assert integrate(p2, (x, -oo, y)) == Min(b, y) - Min(a, b, y)
assert integrate(p3, (x, -oo, y)) == Min(b, y) - Min(a, b, y)
assert integrate(p4, (x, -oo, y)) == Min(b, y) - Min(a, b, y)
assert integrate(p5, (x, -oo, y)) == Min(b, y) - Min(a, b, y)
assert integrate(p0, (x, y, oo)) == Max(a, b, y) - Max(a, y)
assert integrate(p1, (x, y, oo)) == Max(a, b, y) - Max(a, y)
assert integrate(p2, (x, y, oo)) == Max(a, b, y) - Max(a, y)
assert integrate(p3, (x, y, oo)) == Max(a, b, y) - Max(a, y)
assert integrate(p4, (x, y, oo)) == Max(a, b, y) - Max(a, y)
assert integrate(p5, (x, y, oo)) == Max(a, b, y) - Max(a, y)
assert integrate(p0, x) == Piecewise((0, Or(x < a, x > b)), (x, True))
assert integrate(p1, x) == Piecewise((0, Or(x < a, x > b)), (x, True))
assert integrate(p2, x) == Piecewise((0, Or(x < a, x > b)), (x, True))
p1 = Piecewise((0, x < a), (0.5, x > b), (1, True))
p2 = Piecewise((0.5, x > b), (0, x < a), (1, True))
p3 = Piecewise((0, x < a), (1, x < b), (0.5, True))
p4 = Piecewise((0.5, x > b), (1, x > a), (0, True))
p5 = Piecewise((1, And(a < x, x < b)), (0.5, x > b), (0, True))
assert integrate(p1,
(x, -oo, y)) == 0.5 * y + 0.5 * Min(b, y) - Min(a, b, y)
assert integrate(p2,
(x, -oo, y)) == 0.5 * y + 0.5 * Min(b, y) - Min(a, b, y)
assert integrate(p3,
(x, -oo, y)) == 0.5 * y + 0.5 * Min(b, y) - Min(a, b, y)
assert integrate(p4,
(x, -oo, y)) == 0.5 * y + 0.5 * Min(b, y) - Min(a, b, y)
assert integrate(p5,
(x, -oo, y)) == 0.5 * y + 0.5 * Min(b, y) - Min(a, b, y)
def test_is_nnf():
assert is_nnf(true) is True
assert is_nnf(A) is True
assert is_nnf(~A) is True
assert is_nnf(A & B) is True
assert is_nnf((A & B) | (~A & A) | (~B & B) | (~A & ~B), False) is True
assert is_nnf((A | B) & (~A | ~B)) is True
assert is_nnf(Not(Or(A, B))) is False
assert is_nnf(A ^ B) is False
assert is_nnf((A & B) | (~A & A) | (~B & B) | (~A & ~B), True) is False
def plot_and_save(name):
# implicit plot tests
plot_implicit(Eq(y, cos(x)), (x, -5, 5), (y, -2, 2)).save(tmp_file(name))
plot_implicit(Eq(y**2, x**3 - x), (x, -5, 5), (y, -4, 4),
show=False).save(tmp_file(name))
plot_implicit(y > 1 / x, (x, -5, 5), (y, -2, 2),
show=False).save(tmp_file(name))
plot_implicit(y < 1 / tan(x), (x, -5, 5), (y, -2, 2),
show=False).save(tmp_file(name))
plot_implicit(y >= 2 * sin(x) * cos(x), (x, -5, 5), (y, -2, 2),
show=False).save(tmp_file(name))
plot_implicit(y <= x**2, (x, -3, 3), (y, -1, 5),
show=False).save(tmp_file(name))
plot_implicit(Or(And(x < y, x > y**2),
sin(y) > x), show=False).save(tmp_file(name))
plot_implicit(Or(And(x < y, x > y**2), sin(y)),
show=False).save(tmp_file(name))
plot_implicit(Or(x < y, sin(x) >= y), show=False).save(tmp_file(name))
# Test all input args for plot_implicit
plot_implicit(Eq(y**2, x**3 - x), show=False).save(tmp_file(name))
plot_implicit(Eq(y**2, x**3 - x), adaptive=False,
show=False).save(tmp_file(name))
plot_implicit(Eq(y**2, x**3 - x), adaptive=False, points=500,
show=False).save(tmp_file(name))
plot_implicit(y > x, (x, -5, 5), show=False).save(tmp_file(name))
plot_implicit(And(y > exp(x), y > x + 2), show=False).save(tmp_file(name))
plot_implicit(Or(y > x, y > -x), show=False).save(tmp_file(name))
plot_implicit(x**2 - 1, (x, -5, 5), show=False).save(tmp_file(name))
plot_implicit(x**2 - 1, show=False).save(tmp_file(name))
plot_implicit(y > x, depth=-5, show=False).save(tmp_file(name))
plot_implicit(y > x, depth=5, show=False).save(tmp_file(name))
plot_implicit(y > cos(x), adaptive=False, show=False).save(tmp_file(name))
plot_implicit(y < cos(x), adaptive=False, show=False).save(tmp_file(name))
plot_implicit(y - cos(pi / x), show=False).save(tmp_file(name))
pytest.raises(ValueError, lambda: plot_implicit(y > x, (x, -1, 1, 2)))
# issue sympy/sympy#17719
plot_implicit(((x - 1)**2 + y**2 < 2) ^ ((x + 1)**2 + y**2 < 2),
show=False).save(tmp_file(name))
def test_all_or_nothing():
args = x >= -oo, x <= oo
v = And(*args)
if isinstance(v, And):
assert len(v.args) == len(args) - args.count(true)
else:
assert v
v = Or(*args)
if isinstance(v, Or):
assert len(v.args) == 2
else:
assert v
def plot_and_save(name):
x = Symbol('x')
y = Symbol('y')
z = Symbol('z')
# implicit plot tests
plot_implicit(Eq(y, cos(x)), (x, -5, 5), (y, -2, 2)).save(tmp_file(name))
plot_implicit(Eq(y**2, x**3 - x), (x, -5, 5),
(y, -4, 4)).save(tmp_file(name))
plot_implicit(y > 1 / x, (x, -5, 5), (y, -2, 2)).save(tmp_file(name))
plot_implicit(y < 1 / tan(x), (x, -5, 5), (y, -2, 2)).save(tmp_file(name))
plot_implicit(y >= 2 * sin(x) * cos(x), (x, -5, 5),
(y, -2, 2)).save(tmp_file(name))
plot_implicit(y <= x**2, (x, -3, 3), (y, -1, 5)).save(tmp_file(name))
# Test all input args for plot_implicit
plot_implicit(Eq(y**2, x**3 - x)).save(tmp_file())
plot_implicit(Eq(y**2, x**3 - x), adaptive=False).save(tmp_file())
plot_implicit(Eq(y**2, x**3 - x), adaptive=False,
points=500).save(tmp_file())
plot_implicit(y > x, (x, -5, 5)).save(tmp_file())
plot_implicit(And(y > exp(x), y > x + 2)).save(tmp_file())
plot_implicit(Or(y > x, y > -x)).save(tmp_file())
plot_implicit(x**2 - 1, (x, -5, 5)).save(tmp_file())
plot_implicit(x**2 - 1).save(tmp_file())
plot_implicit(y > x, depth=-5).save(tmp_file())
plot_implicit(y > x, depth=5).save(tmp_file())
plot_implicit(y > cos(x), adaptive=False).save(tmp_file())
plot_implicit(y < cos(x), adaptive=False).save(tmp_file())
plot_implicit(And(y > cos(x), Or(y > x, Eq(y, x)))).save(tmp_file())
plot_implicit(y - cos(pi / x)).save(tmp_file())
# Test plots which cannot be rendered using the adaptive algorithm
# TODO: catch the warning.
plot_implicit(Eq(y, re(cos(x) + I * sin(x)))).save(tmp_file(name))
with warnings.catch_warnings(record=True) as w:
plot_implicit(x**2 - 1, legend='An implicit plot').save(tmp_file())
assert len(w) == 1
assert issubclass(w[-1].category, UserWarning)
assert 'No labeled objects found' in str(w[0].message)
