def test_coins():
C, D = Coin('C'), Coin('D')
H, T = symbols('H, T')
assert P(Eq(C, D)) == S.Half
assert density(Tuple(C, D)) == {(H, H): S.One/4, (H, T): S.One/4,
(T, H): S.One/4, (T, T): S.One/4}
assert dict(density(C).items()) == {H: S.Half, T: S.Half}
F = Coin('F', S.One/10)
assert P(Eq(F, H)) == S(1)/10
d = pspace(C).domain
assert d.as_boolean() == Or(Eq(C.symbol, H), Eq(C.symbol, T))
raises(ValueError, lambda: P(C > D)) # Can't intelligently compare H to T
def test_FiniteRV():
F = FiniteRV('F', {1: S.Half, 2: Rational(1, 4), 3: Rational(1, 4)})
p = Symbol("p", positive=True)
assert dict(density(F).items()) == {S.One: S.Half, S(2): Rational(1, 4), S(3): Rational(1, 4)}
assert P(F >= 2) == S.Half
assert quantile(F)(p) == Piecewise((nan, p > S.One), (S.One, p <= S.Half),\
(S(2), p <= Rational(3, 4)),(S(3), True))
assert pspace(F).domain.as_boolean() == Or(
*[Eq(F.symbol, i) for i in [1, 2, 3]])
raises(ValueError, lambda: FiniteRV('F', {1: S.Half, 2: S.Half, 3: S.Half}))
raises(ValueError, lambda: FiniteRV('F', {1: S.Half, 2: Rational(-1, 2), 3: S.One}))
raises(ValueError, lambda: FiniteRV('F', {1: S.One, 2: Rational(3, 2), 3: S.Zero,\
4: Rational(-1, 2), 5: Rational(-3, 4), 6: Rational(-1, 4)}))
def test_contains():
assert Interval(0, 2).contains(1) is S.true
assert Interval(0, 2).contains(3) is S.false
assert Interval(0, 2, True, False).contains(0) is S.false
assert Interval(0, 2, True, False).contains(2) is S.true
assert Interval(0, 2, False, True).contains(0) is S.true
assert Interval(0, 2, False, True).contains(2) is S.false
assert Interval(0, 2, True, True).contains(0) is S.false
assert Interval(0, 2, True, True).contains(2) is S.false
assert FiniteSet(1, 2, 3).contains(2) is S.true
assert FiniteSet(1, 2, Symbol('x')).contains(Symbol('x')) is S.true
# issue 8197
from sympy.abc import a, b
assert isinstance(FiniteSet(b).contains(-a), Contains)
assert isinstance(FiniteSet(b).contains(a), Contains)
assert isinstance(FiniteSet(a).contains(1), Contains)
raises(TypeError, lambda: 1 in FiniteSet(a))
# issue 8209
rad1 = Pow(Pow(2, S(1)/3) - 1, S(1)/3)
rad2 = Pow(S(1)/9, S(1)/3) - Pow(S(2)/9, S(1)/3) + Pow(S(4)/9, S(1)/3)
s1 = FiniteSet(rad1)
s2 = FiniteSet(rad2)
assert s1 - s2 == S.EmptySet
items = [1, 2, S.Infinity, S('ham'), -1.1]
fset = FiniteSet(*items)
assert all(item in fset for item in items)
assert all(fset.contains(item) is S.true for item in items)
assert Union(Interval(0, 1), Interval(2, 5)).contains(3) is S.true
assert Union(Interval(0, 1), Interval(2, 5)).contains(6) is S.false
assert Union(Interval(0, 1), FiniteSet(2, 5)).contains(3) is S.false
assert S.EmptySet.contains(1) is S.false
assert FiniteSet(rootof(x**3 + x - 1, 0)).contains(S.Infinity) is S.false
assert rootof(x**5 + x**3 + 1, 0) in S.Reals
assert not rootof(x**5 + x**3 + 1, 1) in S.Reals
# non-bool results
assert Union(Interval(1, 2), Interval(3, 4)).contains(x) == \
Or(And(x <= 2, x >= 1), And(x <= 4, x >= 3))
assert Intersection(Interval(1, x), Interval(2, 3)).contains(y) == \
And(y <= 3, y <= x, y >= 1, y >= 2)
def test_reduce_poly_inequalities_complex_relational():
cond = Eq(im(x), 0)
assert reduce_rational_inequalities(
[[Eq(x**2, 0)]], x, relational=True) == And(Eq(re(x), 0), cond)
assert reduce_rational_inequalities(
[[Le(x**2, 0)]], x, relational=True) == And(Eq(re(x), 0), cond)
assert reduce_rational_inequalities(
[[Lt(x**2, 0)]], x, relational=True) == False
assert reduce_rational_inequalities(
[[Ge(x**2, 0)]], x, relational=True) == cond
assert reduce_rational_inequalities([[Gt(x**2, 0)]], x, relational=True) == \
And(Or(Lt(re(x), 0), Gt(re(x), 0)), cond)
assert reduce_rational_inequalities([[Ne(x**2, 0)]], x, relational=True) == \
And(Or(Lt(re(x), 0), Gt(re(x), 0)), cond)
assert reduce_rational_inequalities([[Eq(x**2, 1)]], x, relational=True) == \
And(Or(Eq(re(x), -1), Eq(re(x), 1)), cond)
assert reduce_rational_inequalities([[Le(x**2, 1)]], x, relational=True) == \
And(And(Le(-1, re(x)), Le(re(x), 1)), cond)
assert reduce_rational_inequalities([[Lt(x**2, 1)]], x, relational=True) == \
And(And(Lt(-1, re(x)), Lt(re(x), 1)), cond)
assert reduce_rational_inequalities([[Ge(x**2, 1)]], x, relational=True) == \
And(Or(Le(re(x), -1), Ge(re(x), 1)), cond)
assert reduce_rational_inequalities([[Gt(x**2, 1)]], x, relational=True) == \
And(Or(Lt(re(x), -1), Gt(re(x), 1)), cond)
assert reduce_rational_inequalities([[Ne(x**2, 1)]], x, relational=True) == \
And(Or(Lt(re(x), -1), And(Lt(-1, re(x)), Lt(re(x), 1)), Gt(re(x), 1)), cond)
assert reduce_rational_inequalities([[Le(x**2, 1.0)]], x, relational=True) == \
And(And(Le(-1.0, re(x)), Le(re(x), 1.0)), cond)
assert reduce_rational_inequalities([[Lt(x**2, 1.0)]], x, relational=True) == \
And(And(Lt(-1.0, re(x)), Lt(re(x), 1.0)), cond)
assert reduce_rational_inequalities([[Ge(x**2, 1.0)]], x, relational=True) == \
And(Or(Le(re(x), -1.0), Ge(re(x), 1.0)), cond)
assert reduce_rational_inequalities([[Gt(x**2, 1.0)]], x, relational=True) == \
And(Or(Lt(re(x), -1.0), Gt(re(x), 1.0)), cond)
assert reduce_rational_inequalities([[Ne(x**2, 1.0)]], x, relational=True) == \
And(Or(Lt(re(x), -1.0), And(Lt(-1.0, re(x)), Lt(re(x), 1.0)), Gt(re(x), 1.0)), cond)
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 + S.Half
assert variance(X) == S(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) == S.Zero
assert covariance(X, X + Y) == variance(X)
assert density(Eq(cos(X * S.Pi), 1))[True] == S.Half
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) == S.Half
assert P(2 * X > 6) == S.Half
assert P(X > Y) == S(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) == S.One
assert P(X > Y, Eq(Y, 6)) == S.Zero
assert P(Eq(X + Y, 12)) == S.One / 36
assert P(Eq(X + Y, 12), Eq(X, 6)) == S.One / 6
assert density(X + Y) == density(Y + Z) != density(X + X)
d = density(2 * X + Y**Z)
assert d[S(22)] == S.One / 108 and d[S(4100)] == S.One / 216 and S(
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)
def test_union_contains():
x = Symbol('x')
i1 = Interval(0, 1)
i2 = Interval(2, 3)
i3 = Union(i1, i2)
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_reduce_poly_inequalities_real_relational():
with assuming(Q.real(x), Q.real(y)):
assert reduce_rational_inequalities(
[[Eq(x**2, 0)]], x, relational=True) == Eq(x, 0)
assert reduce_rational_inequalities(
[[Le(x**2, 0)]], x, relational=True) == Eq(x, 0)
assert reduce_rational_inequalities(
[[Lt(x**2, 0)]], x, relational=True) == False
assert reduce_rational_inequalities(
[[Ge(x**2, 0)]], x, relational=True) == True
assert reduce_rational_inequalities(
[[Gt(x**2, 0)]], x, relational=True) == Or(Lt(x, 0), Gt(x, 0))
assert reduce_rational_inequalities(
[[Ne(x**2, 0)]], x, relational=True) == Or(Lt(x, 0), Gt(x, 0))
assert reduce_rational_inequalities(
[[Eq(x**2, 1)]], x, relational=True) == Or(Eq(x, -1), Eq(x, 1))
assert reduce_rational_inequalities(
[[Le(x**2, 1)]], x, relational=True) == And(Le(-1, x), Le(x, 1))
assert reduce_rational_inequalities(
[[Lt(x**2, 1)]], x, relational=True) == And(Lt(-1, x), Lt(x, 1))
assert reduce_rational_inequalities(
[[Ge(x**2, 1)]], x, relational=True) == Or(Le(x, -1), Ge(x, 1))
assert reduce_rational_inequalities(
[[Gt(x**2, 1)]], x, relational=True) == Or(Lt(x, -1), Gt(x, 1))
assert reduce_rational_inequalities([[Ne(x**2, 1)]], x, relational=True) == Or(
Lt(x, -1), And(Lt(-1, x), Lt(x, 1)), Gt(x, 1))
assert reduce_rational_inequalities(
[[Le(x**2, 1.0)]], x, relational=True) == And(Le(-1.0, x), Le(x, 1.0))
assert reduce_rational_inequalities(
[[Lt(x**2, 1.0)]], x, relational=True) == And(Lt(-1.0, x), Lt(x, 1.0))
assert reduce_rational_inequalities(
[[Ge(x**2, 1.0)]], x, relational=True) == Or(Le(x, -1.0), Ge(x, 1.0))
assert reduce_rational_inequalities(
[[Gt(x**2, 1.0)]], x, relational=True) == Or(Lt(x, -1.0), Gt(x, 1.0))
assert reduce_rational_inequalities([[Ne(x**2, 1.0)]], x, relational=True) == \
Or(Lt(x, -1.0), And(Lt(-1.0, x), Lt(x, 1.0)), Gt(x, 1.0))
def is_complete(self) -> bool:
"""
Check whether the automaton is complete.
:return: True if the automaton is complete, False otherwise.
"""
# all the state must have an outgoing transition.
if not all(state in self._transition_function.keys()
for state in self.states):
return False
for source in self._transition_function:
guards = self._transition_function[source].values()
negated_guards = Not(Or(*guards))
if satisfiable(negated_guards):
return False
return True
def test_holes():
nan = Undefined
assert Piecewise((1, x < 2)).integrate(x) == Piecewise(
(x, x < 2), (nan, True))
assert Piecewise((1, And(x > 1, x < 2))).integrate(x) == Piecewise(
(nan, x < 1), (x - 1, x < 2), (nan, True))
assert Piecewise((1, And(x > 1, x < 2))).integrate((x, 0, 3)) == nan
assert Piecewise((1, And(x > 0, x < 4))).integrate((x, 1, 3)) == 2
# this also tests that the integrate method is used on non-Piecwise
# arguments in _eval_integral
A, B = symbols("A B")
a, b = symbols('a b', real=True)
assert Piecewise((A, And(x < 0, a < 1)), (B, Or(x < 1, a > 2))
).integrate(x) == Piecewise(
(B*x, (a > 2)),
(Piecewise((A*x, x < 0), (B*x, x < 1), (nan, True)), a < 1),
(Piecewise((B*x, x < 1), (nan, True)), True))
def test_piecewise_fold_piecewise_in_cond():
p1 = Piecewise((cos(x), x < 0), (0, True))
p2 = Piecewise((0, Eq(p1, 0)), (p1 / Abs(p1), True))
p3 = piecewise_fold(p2)
assert (p2.subs(x, -pi / 2) == 0.0)
assert (p2.subs(x, 1) == 0.0)
assert (p2.subs(x, -pi / 4) == 1.0)
p4 = Piecewise((0, Eq(p1, 0)), (1, True))
assert (piecewise_fold(p4) == Piecewise(
(0, Or(And(Eq(cos(x), 0), x < 0), Not(x < 0))), (1, True)))
r1 = 1 < Piecewise((1, x < 1), (3, True))
assert (piecewise_fold(r1) == Not(x < 1))
p5 = Piecewise((1, x < 0), (3, True))
p6 = Piecewise((1, x < 1), (3, True))
p7 = piecewise_fold(Piecewise((1, p5 < p6), (0, True)))
assert (Piecewise((1, And(Not(x < 1), x < 0)), (0, True)))
def test_FiniteRV():
F = FiniteRV('F', {
1: S.Half,
2: Rational(1, 4),
3: Rational(1, 4)
},
check=True)
p = Symbol("p", positive=True)
assert dict(density(F).items()) == {
S.One: S.Half,
S(2): Rational(1, 4),
S(3): Rational(1, 4)
}
assert P(F >= 2) == S.Half
assert quantile(F)(p) == Piecewise((nan, p > S.One), (S.One, p <= S.Half),\
(S(2), p <= Rational(3, 4)),(S(3), True))
assert pspace(F).domain.as_boolean() == Or(
*[Eq(F.symbol, i) for i in [1, 2, 3]])
assert F.pspace.domain.set == FiniteSet(1, 2, 3)
raises(
ValueError,
lambda: FiniteRV('F', {
1: S.Half,
2: S.Half,
3: S.Half
}, check=True))
raises(
ValueError, lambda: FiniteRV('F', {
1: S.Half,
2: Rational(-1, 2),
3: S.One
},
check=True))
raises(ValueError, lambda: FiniteRV('F', {1: S.One, 2: Rational(3, 2), 3: S.Zero,\
4: Rational(-1, 2), 5: Rational(-3, 4), 6: Rational(-1, 4)}, check=True))
# purposeful invalid pmf but it should not raise since check=False
# see test_drv_types.test_ContinuousRV for explanation
X = FiniteRV('X', {1: 1, 2: 2})
assert E(X) == 5
assert P(X <= 2) + P(X > 2) != 1
def test_piecewise_integrate1cb():
y = symbols('y', real=True)
g = Piecewise(
(0, Or(x <= -1, x >= 1)),
(1 - x, x > 0),
(1 + x, True)
)
gy1 = g.integrate((x, y, 1))
g1y = g.integrate((x, 1, y))
assert g.integrate((x, -2, 1)) == gy1.subs(y, -2)
assert g.integrate((x, 1, -2)) == g1y.subs(y, -2)
assert g.integrate((x, 0, 1)) == gy1.subs(y, 0)
assert g.integrate((x, 1, 0)) == g1y.subs(y, 0)
assert g.integrate((x, 2, 1)) == gy1.subs(y, 2)
assert g.integrate((x, 1, 2)) == g1y.subs(y, 2)
assert piecewise_fold(gy1.rewrite(Piecewise)) == \
Piecewise(
(1, y <= -1),
(-y**2/2 - y + S(1)/2, y <= 0),
(y**2/2 - y + S(1)/2, y < 1),
(0, True))
assert piecewise_fold(g1y.rewrite(Piecewise)) == \
Piecewise(
(-1, y <= -1),
(y**2/2 + y - S(1)/2, y <= 0),
(-y**2/2 + y - S(1)/2, y < 1),
(0, True))
# g1y and gy1 should simplify if the condition that y < 1
# is applied, e.g. Min(1, Max(-1, y)) --> Max(-1, y)
assert gy1 == Piecewise(
(
-Min(1, Max(-1, y))**2/2 - Min(1, Max(-1, y)) +
Min(1, Max(0, y))**2 + S(1)/2, y < 1),
(0, True)
)
assert g1y == Piecewise(
(
Min(1, Max(-1, y))**2/2 + Min(1, Max(-1, y)) -
Min(1, Max(0, y))**2 - S(1)/2, y < 1),
(0, True))
def test_count_ops_non_visual():
def count(val):
return count_ops(val, visual=False)
assert count(x) == 0
assert count(x) is not S.Zero
assert count(x + y) == 1
assert count(x + y) is not S.One
assert count(x + y*x + 2*y) == 4
assert count({x + y: x}) == 1
assert count({x + y: S(2) + x}) is not S.One
assert count(Or(x,y)) == 1
assert count(And(x,y)) == 1
assert count(Not(x)) == 0
assert count(Nor(x,y)) == 1
assert count(Nand(x,y)) == 1
assert count(Xor(x,y)) == 3
assert count(Implies(x,y)) == 1
assert count(Equivalent(x,y)) == 1
assert count(ITE(x,y,z)) == 3
assert count(ITE(True,x,y)) == 0
def parse_pside(self, pside):
"""
Translate property-side combinations into a logical expression
:param pside: a PropertySide object
:return: A logical expression of the PropertySide object
"""
base_key = str(pside.property.id)
if pside.property.symmetric:
return self.term_to_symbol[base_key]
else:
if pside.side == 1:
return And(self.term_to_symbol[base_key+'l'], self.term_to_symbol[base_key+'r'])
elif pside.side == 2:
return self.term_to_symbol[base_key + 'l']
elif pside.side == 3:
return self.term_to_symbol[base_key + 'r']
elif pside.side == 4:
return Or(self.term_to_symbol[base_key+'l'], self.term_to_symbol[base_key+'r'])
else:
raise NotImplementedError
def test_coins():
C, D = Coin(), Coin()
H, T = sorted(Density(C).keys())
assert P(Eq(C, D)) == S.Half
assert Density(Tuple(C, D)) == {
(H, H): S.One / 4,
(H, T): S.One / 4,
(T, H): S.One / 4,
(T, T): S.One / 4
}
assert Density(C) == {H: S.Half, T: S.Half}
E = Coin(S.One / 10)
assert P(Eq(E, H)) == S(1) / 10
d = pspace(C).domain
assert d.as_boolean() == Or(Eq(C.symbol, H), Eq(C.symbol, T))
raises(ValueError, "P(C>D)") # Can't intelligently compare H to T
def test_coins():
C, D = Coin("C"), Coin("D")
H, T = symbols("H, T")
assert P(Eq(C, D)) == S.Half
assert density(Tuple(C, D)) == {
(H, H): Rational(1, 4),
(H, T): Rational(1, 4),
(T, H): Rational(1, 4),
(T, T): Rational(1, 4),
}
assert dict(density(C).items()) == {H: S.Half, T: S.Half}
F = Coin("F", Rational(1, 10))
assert P(Eq(F, H)) == Rational(1, 10)
d = pspace(C).domain
assert d.as_boolean() == Or(Eq(C.symbol, H), Eq(C.symbol, T))
raises(ValueError, lambda: P(C > D)) # Can't intelligently compare H to T
def test_pretty_Boolean():
expr = Not(x, evaluate=False)
assert pretty(expr) == "Not(x)"
assert upretty(expr) == u"¬ x"
expr = And(x, y)
assert pretty(expr) == "And(x, y)"
assert upretty(expr) == u"x ∧ y"
expr = Or(x, y)
assert pretty(expr) == "Or(x, y)"
assert upretty(expr) == u"x ∨ y"
expr = Xor(x, y, evaluate=False)
assert pretty(expr) == "Xor(x, y)"
assert upretty(expr) == u"x ⊻ y"
expr = Nand(x, y, evaluate=False)
assert pretty(expr) == "Nand(x, y)"
assert upretty(expr) == u"x ⊼ y"
expr = Nor(x, y, evaluate=False)
assert pretty(expr) == "Nor(x, y)"
assert upretty(expr) == u"x ⊽ y"
expr = Implies(x, y, evaluate=False)
assert pretty(expr) == "Implies(x, y)"
assert upretty(expr) == u"x → y"
expr = Equivalent(x, y, evaluate=False)
assert pretty(expr) == "Equivalent(x, y)"
assert upretty(expr) == u"x ≡ y"
def test_dice():
X, Y, Z = Die(6), Die(6), Die(6)
a, b = symbols('a b')
assert E(X) == 3 + S.Half
assert Var(X) == S(35) / 12
assert E(X + Y) == 7
assert E(X + X) == 7
assert E(a * X + b) == a * E(X) + b
assert Var(X + Y) == Var(X) + Var(Y)
assert Var(X + X) == 4 * Var(X)
assert Covar(X, Y) == S.Zero
assert Covar(X, X + Y) == Var(X)
assert Density(Eq(cos(X * S.Pi), 1))[True] == S.Half
assert P(X > 3) == S.Half
assert P(2 * X > 6) == S.Half
assert P(X > Y) == S(5) / 12
assert P(Eq(X, Y)) == P(Eq(X, 1))
assert E(X, X > 3) == 5
assert E(X, Y > 3) == E(X)
assert E(X + Y, Eq(X, Y)) == E(2 * X)
assert E(X + Y - Z, 2 * X > Y + 1) == S(49) / 12
assert P(X > 3, X > 3) == S.One
assert P(X > Y, Eq(Y, 6)) == S.Zero
assert P(Eq(X + Y, 12)) == S.One / 36
assert P(Eq(X + Y, 12), Eq(X, 6)) == S.One / 6
assert Density(X + Y) == Density(Y + Z) != Density(X + X)
d = Density(2 * X + Y**Z)
assert d[S(22)] == S.One / 108 and d[S(4100)] == S.One / 216 and S(
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)
def test_evaluate_false():
cases = {
'2 + 3':
Add(2, 3, evaluate=False),
'2**2 / 3':
Mul(Pow(2, 2, evaluate=False),
Pow(3, -1, evaluate=False),
evaluate=False),
'2 + 3 * 5':
Add(2, Mul(3, 5, evaluate=False), evaluate=False),
'2 - 3 * 5':
Add(2, -Mul(3, 5, evaluate=False), evaluate=False),
'1 / 3':
Mul(1, Pow(3, -1, evaluate=False), evaluate=False),
'True | False':
Or(True, False, evaluate=False),
'1 + 2 + 3 + 5*3 + integrate(x)':
Add(1, 2, 3, Mul(5, 3, evaluate=False), x**2 / 2, evaluate=False),
'2 * 4 * 6 + 8':
Add(Mul(2, 4, 6, evaluate=False), 8, evaluate=False),
}
for case, result in cases.items():
assert sympify(case, evaluate=False) == result
def test_evaluate_false():
cases = {
"2 + 3":
Add(2, 3, evaluate=False),
"2**2 / 3":
Mul(Pow(2, 2, evaluate=False),
Pow(3, -1, evaluate=False),
evaluate=False),
"2 + 3 * 5":
Add(2, Mul(3, 5, evaluate=False), evaluate=False),
"2 - 3 * 5":
Add(2,
Mul(-1, Mul(3, 5, evaluate=False), evaluate=False),
evaluate=False),
"1 / 3":
Mul(1, Pow(3, -1, evaluate=False), evaluate=False),
"True | False":
Or(True, False, evaluate=False),
"1 + 2 + 3 + 5*3 + integrate(x)":
Add(1, 2, 3, Mul(5, 3, evaluate=False), x**2 / 2, evaluate=False),
"2 * 4 * 6 + 8":
Add(Mul(2, 4, 6, evaluate=False), 8, evaluate=False),
"2 - 8 / 4":
Add(
2,
Mul(-1,
Mul(8, Pow(4, -1, evaluate=False), evaluate=False),
evaluate=False),
evaluate=False,
),
"2 - 2**2":
Add(2,
Mul(-1, Pow(2, 2, evaluate=False), evaluate=False),
evaluate=False),
}
for case, result in cases.items():
assert sympify(case, evaluate=False) == result
def complete(self) -> "SymbolicAutomaton":
"""Complete the automaton."""
states = set(self.states)
initial_state = self.initial_state
final_states = self.accepting_states
transitions = set()
sink_state = None
for source in states:
transitions_from_source = self._transition_function.get(source, {})
transitions.update(
set(
map(lambda x: (source, x[1], x[0]),
transitions_from_source.items())))
guards = transitions_from_source.values()
guards_negation = simplify(Not(Or(*guards)))
if satisfiable(guards_negation) is not False:
sink_state = len(states) if sink_state is None else sink_state
transitions.add((source, guards_negation, sink_state))
if sink_state is not None:
states.add(sink_state)
transitions.add((sink_state, BooleanTrue(), sink_state))
return SymbolicAutomaton._from_transitions(states, initial_state,
final_states, transitions)
def test_reduce_poly_inequalities_complex_relational():
assert reduce_rational_inequalities([[Eq(x**2, 0)]], x,
relational=True) == Eq(x, 0)
assert reduce_rational_inequalities([[Le(x**2, 0)]], x,
relational=True) == Eq(x, 0)
assert reduce_rational_inequalities([[Lt(x**2, 0)]], x,
relational=True) == False
assert reduce_rational_inequalities([[Ge(x**2, 0)]], x,
relational=True) == And(
Lt(-oo, x), Lt(x, oo))
assert reduce_rational_inequalities(
[[Gt(x**2, 0)]], x, relational=True) == \
And(Or(And(Lt(-oo, x), Lt(x, 0)), And(Lt(0, x), Lt(x, oo))))
assert reduce_rational_inequalities(
[[Ne(x**2, 0)]], x, relational=True) == \
And(Or(And(Lt(-oo, x), Lt(x, 0)), And(Lt(0, x), Lt(x, oo))))
for one in (S(1), S(1.0)):
inf = one * oo
assert reduce_rational_inequalities(
[[Eq(x**2, one)]], x, relational=True) == \
Or(Eq(x, -one), Eq(x, one))
assert reduce_rational_inequalities(
[[Le(x**2, one)]], x, relational=True) == \
And(And(Le(-one, x), Le(x, one)))
assert reduce_rational_inequalities(
[[Lt(x**2, one)]], x, relational=True) == \
And(And(Lt(-one, x), Lt(x, one)))
assert reduce_rational_inequalities(
[[Ge(x**2, one)]], x, relational=True) == \
And(Or(And(Le(one, x), Lt(x, inf)), And(Le(x, -one), Lt(-inf, x))))
assert reduce_rational_inequalities(
[[Gt(x**2, one)]], x, relational=True) == \
And(Or(And(Lt(-inf, x), Lt(x, -one)), And(Lt(one, x), Lt(x, inf))))
assert reduce_rational_inequalities(
[[Ne(x**2, one)]], x, relational=True) == \
Or(And(Lt(-inf, x), Lt(x, -one)),
And(Lt(-one, x), Lt(x, one)),
And(Lt(one, x), Lt(x, inf)))
def test_issue_2983():
assert Max(x, 1) * Max(x, 2) == Max(x, 1) * Max(x, 2)
assert Or(x, z) * Or(x, z) == Or(x, z) * Or(x, z)
def test_Union_as_relational():
x = Symbol('x')
assert (Interval(0, 1) + FiniteSet(2)).as_relational(x) == \
Or(And(Le(0, x), Le(x, 1)), Eq(x, 2))
assert (Interval(0, 1, True, True) + FiniteSet(1)).as_relational(x) == \
And(Lt(0, x), Le(x, 1))
def test_Finite_as_relational():
x = Symbol('x')
y = Symbol('y')
assert FiniteSet(1, 2).as_relational(x) == Or(Eq(x, 1), Eq(x, 2))
assert FiniteSet(y, -5).as_relational(x) == Or(Eq(x, y), Eq(x, -5))
def pmf(self):
k = Dummy("k")
return Lambda(
k, Piecewise((S.Half, Or(Eq(k, -1), Eq(k, 1))), (S.Zero, True)))
def as_boolean(self):
return Or(
*[And(*[Eq(sym, val) for sym, val in item]) for item in self])
def test_piecewise_fold_piecewise_in_cond_2():
p1 = Piecewise((cos(x), x < 0), (0, True))
p2 = Piecewise((0, Eq(p1, 0)), (1 / p1, True))
p3 = Piecewise((0, Or(And(Eq(cos(x), 0), x < 0), Not(x < 0))),
(1 / cos(x), True))
assert (piecewise_fold(p2) == p3)
def test_piecewise_integrate():
x, y = symbols('x y', real=True, finite=True)
# XXX Use '<=' here! '>=' is not yet implemented ..
f = Piecewise(((x - 2)**2, 0 <= x), (1, True))
assert integrate(f, (x, -2, 2)) == Rational(14, 3)
g = Piecewise(((x - 5)**5, 4 <= x), (f, True))
assert integrate(g, (x, -2, 2)) == Rational(14, 3)
assert integrate(g, (x, -2, 5)) == Rational(43, 6)
g = Piecewise(((x - 5)**5, 4 <= x), (f, x < 4))
assert integrate(g, (x, -2, 2)) == Rational(14, 3)
assert integrate(g, (x, -2, 5)) == Rational(43, 6)
g = Piecewise(((x - 5)**5, 2 <= x), (f, x < 2))
assert integrate(g, (x, -2, 2)) == Rational(14, 3)
assert integrate(g, (x, -2, 5)) == -Rational(701, 6)
g = Piecewise(((x - 5)**5, 2 <= x), (f, True))
assert integrate(g, (x, -2, 2)) == Rational(14, 3)
assert integrate(g, (x, -2, 5)) == -Rational(701, 6)
g = Piecewise(((x - 5)**5, 2 <= x), (2 * f, True))
assert integrate(g, (x, -2, 2)) == 2 * Rational(14, 3)
assert integrate(g, (x, -2, 5)) == -Rational(673, 6)
g = Piecewise((1, x > 0), (0, Eq(x, 0)), (-1, x < 0))
assert integrate(g, (x, -1, 1)) == 0
g = Piecewise((1, x - y < 0), (0, True))
assert integrate(g, (y, -oo, 0)) == -Min(0, x)
assert integrate(g, (y, 0, oo)) == oo - Max(0, x)
assert integrate(g, (y, -oo, oo)) == oo - x
g = Piecewise((0, x < 0), (x, x <= 1), (1, True))
assert integrate(g, (x, -5, 1)) == Rational(1, 2)
assert integrate(g, (x, -5, y)).subs(y, 1) == Rational(1, 2)
assert integrate(g, (x, y, 1)).subs(y, -5) == Rational(1, 2)
assert integrate(g, (x, 1, -5)) == -Rational(1, 2)
assert integrate(g, (x, 1, y)).subs(y, -5) == -Rational(1, 2)
assert integrate(g, (x, y, -5)).subs(y, 1) == -Rational(1, 2)
assert integrate(g, (x, -5, y)) == Piecewise(
(0, y < 0), (y**2 / 2, y <= 1), (y - 0.5, True))
assert integrate(g, (x, y, 1)) == Piecewise(
(0.5, y < 0), (0.5 - y**2 / 2, y <= 1), (1 - y, True))
g = Piecewise((1 - x, Interval(0, 1).contains(x)),
(1 + x, Interval(-1, 0).contains(x)), (0, True))
assert integrate(g, (x, -5, 1)) == 1
assert integrate(g, (x, -5, y)).subs(y, 1) == 1
assert integrate(g, (x, y, 1)).subs(y, -5) == 1
assert integrate(g, (x, 1, -5)) == -1
assert integrate(g, (x, 1, y)).subs(y, -5) == -1
assert integrate(g, (x, y, -5)).subs(y, 1) == -1
assert integrate(g, (x, -5, y)) == Piecewise(
(-y**2 / 2 + y + 0.5, Interval(0, 1).contains(y)),
(y**2 / 2 + y + 0.5, Interval(-1, 0).contains(y)), (0, y <= -1),
(1, True))
assert integrate(g, (x, y, 1)) == Piecewise(
(y**2 / 2 - y + 0.5, Interval(0, 1).contains(y)),
(-y**2 / 2 - y + 0.5, Interval(-1, 0).contains(y)), (1, y <= -1),
(0, True))
g = Piecewise((0, Or(x <= -1, x >= 1)), (1 - x, x > 0), (1 + x, True))
assert integrate(g, (x, -5, 1)) == 1
assert integrate(g, (x, -5, y)).subs(y, 1) == 1
assert integrate(g, (x, y, 1)).subs(y, -5) == 1
assert integrate(g, (x, 1, -5)) == -1
assert integrate(g, (x, 1, y)).subs(y, -5) == -1
assert integrate(g, (x, y, -5)).subs(y, 1) == -1
assert integrate(g, (x, -5, y)) == Piecewise((0, y <= -1), (1, y >= 1),
(-y**2 / 2 + y + 0.5, y > 0),
(y**2 / 2 + y + 0.5, True))
assert integrate(g, (x, y, 1)) == Piecewise((1, y <= -1), (0, y >= 1),
(y**2 / 2 - y + 0.5, y > 0),
(-y**2 / 2 - y + 0.5, True))
def test_piecewise():
# Test canonization
assert Piecewise((x, x < 1), (0, True)) == Piecewise((x, x < 1), (0, True))
assert Piecewise((x, x < 1), (0, True), (1, True)) == \
Piecewise((x, x < 1), (0, True))
assert Piecewise((x, x < 1), (0, False), (-1, 1 > 2)) == \
Piecewise((x, x < 1))
assert Piecewise((x, x < 1), (0, x < 1), (0, True)) == \
Piecewise((x, x < 1), (0, True))
assert Piecewise((x, x < 1), (0, x < 2), (0, True)) == \
Piecewise((x, x < 1), (0, True))
assert Piecewise((x, x < 1), (x, x < 2), (0, True)) == \
Piecewise((x, Or(x < 1, x < 2)), (0, True))
assert Piecewise((x, x < 1), (x, x < 2), (x, True)) == x
assert Piecewise((x, True)) == x
raises(TypeError, lambda: Piecewise(x))
raises(TypeError, lambda: Piecewise((x, x**2)))
# Test subs
p = Piecewise((-1, x < -1), (x**2, x < 0), (log(x), x >= 0))
p_x2 = Piecewise((-1, x**2 < -1), (x**4, x**2 < 0), (log(x**2), x**2 >= 0))
assert p.subs(x, x**2) == p_x2
assert p.subs(x, -5) == -1
assert p.subs(x, -1) == 1
assert p.subs(x, 1) == log(1)
# More subs tests
p2 = Piecewise((1, x < pi), (-1, x < 2 * pi), (0, x > 2 * pi))
p3 = Piecewise((1, Eq(x, 0)), (1 / x, True))
p4 = Piecewise((1, Eq(x, 0)), (2, 1 / x > 2))
assert p2.subs(x, 2) == 1
assert p2.subs(x, 4) == -1
assert p2.subs(x, 10) == 0
assert p3.subs(x, 0.0) == 1
assert p4.subs(x, 0.0) == 1
f, g, h = symbols('f,g,h', cls=Function)
pf = Piecewise((f(x), x < -1), (f(x) + h(x) + 2, x <= 1))
pg = Piecewise((g(x), x < -1), (g(x) + h(x) + 2, x <= 1))
assert pg.subs(g, f) == pf
assert Piecewise((1, Eq(x, 0)), (0, True)).subs(x, 0) == 1
assert Piecewise((1, Eq(x, 0)), (0, True)).subs(x, 1) == 0
assert Piecewise((1, Eq(x, y)), (0, True)).subs(x, y) == 1
assert Piecewise((1, Eq(x, z)), (0, True)).subs(x, z) == 1
assert Piecewise((1, Eq(exp(x), cos(z))), (0, True)).subs(x, z) == \
Piecewise((1, Eq(exp(z), cos(z))), (0, True))
assert Piecewise((1, Eq(x, y * (y + 1))), (0, True)).subs(x, y**2 + y) == 1
p5 = Piecewise((0, Eq(cos(x) + y, 0)), (1, True))
assert p5.subs(y, 0) == Piecewise((0, Eq(cos(x), 0)), (1, True))
# Test evalf
assert p.evalf() == p
assert p.evalf(subs={x: -2}) == -1
assert p.evalf(subs={x: -1}) == 1
assert p.evalf(subs={x: 1}) == log(1)
# Test doit
f_int = Piecewise((Integral(x, (x, 0, 1)), x < 1))
assert f_int.doit() == Piecewise((1.0 / 2.0, x < 1))
# Test differentiation
f = x
fp = x * p
dp = Piecewise((0, x < -1), (2 * x, x < 0), (1 / x, x >= 0))
fp_dx = x * dp + p
assert diff(p, x) == dp
assert diff(f * p, x) == fp_dx
# Test simple arithmetic
assert x * p == fp
assert x * p + p == p + x * p
assert p + f == f + p
assert p + dp == dp + p
assert p - dp == -(dp - p)
# Test power
dp2 = Piecewise((0, x < -1), (4 * x**2, x < 0), (1 / x**2, x >= 0))
assert dp**2 == dp2
# Test _eval_interval
f1 = x * y + 2
f2 = x * y**2 + 3
peval = Piecewise((f1, x < 0), (f2, x > 0))
peval_interval = f1.subs(x, 0) - f1.subs(x, -1) + f2.subs(x, 1) - f2.subs(
x, 0)
assert peval._eval_interval(x, 0, 0) == 0
assert peval._eval_interval(x, -1, 1) == peval_interval
peval2 = Piecewise((f1, x < 0), (f2, True))
assert peval2._eval_interval(x, 0, 0) == 0
assert peval2._eval_interval(x, 1, -1) == -peval_interval
assert peval2._eval_interval(x, -1, -2) == f1.subs(x, -2) - f1.subs(x, -1)
assert peval2._eval_interval(x, -1, 1) == peval_interval
assert peval2._eval_interval(x, None, 0) == peval2.subs(x, 0)
assert peval2._eval_interval(x, -1, None) == -peval2.subs(x, -1)
# Test integration
p_int = Piecewise((-x, x < -1), (x**3 / 3.0, x < 0),
(-x + x * log(x), x >= 0))
assert integrate(p, x) == p_int
p = Piecewise((x, x < 1), (x**2, -1 <= x), (x, 3 < x))
assert integrate(p, (x, -2, 2)) == 5.0 / 6.0
assert integrate(p, (x, 2, -2)) == -5.0 / 6.0
p = Piecewise((0, x < 0), (1, x < 1), (0, x < 2), (1, x < 3), (0, True))
assert integrate(p, (x, -oo, oo)) == 2
p = Piecewise((x, x < -10), (x**2, x <= -1), (x, 1 < x))
raises(ValueError, lambda: integrate(p, (x, -2, 2)))
# Test commutativity
assert p.is_commutative is True
