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