def test_reduce_poly_inequalities_real_relational(): x = Symbol('x', real=True) y = Symbol('y', real=True) 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) == 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) == Or( And(Lt(-oo, x), Lt(x, 0)), And(Lt(0, x), Lt(x, oo))) 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( And(Le(1, x), Lt(x, oo)), And(Le(x, -1), Lt(-oo, x))) assert reduce_rational_inequalities([[Gt(x**2, 1)]], x, relational=True) == Or( And(Lt(1, x), Lt(x, oo)), And(Lt(x, -1), Lt(-oo, x))) assert reduce_rational_inequalities([[Ne(x**2, 1)]], x, relational=True) == Or( And(Lt(-oo, x), Lt(x, -1)), And(Lt(-1, x), Lt(x, 1)), And(Lt(1, x), Lt(x, oo))) 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( And(Lt(Float('-inf'), x), Le(x, -1.0)), And(Le(1.0, x), Lt(x, Float('+inf')))) assert reduce_rational_inequalities([[Gt(x**2, 1.0)]], x, relational=True) == Or( And(Lt(Float('-inf'), x), Lt(x, -1.0)), And(Lt(1.0, x), Lt(x, Float('+inf')))) assert reduce_rational_inequalities([[Ne(x**2, 1.0)]], x, relational=True) == \ Or(And(Lt(-1.0, x), Lt(x, 1.0)), And(Lt(Float('-inf'), x), Lt(x, -1.0)), And(Lt(1.0, x), Lt(x, Float('+inf'))))
def test_issue_11045(): assert integrate(1 / (x * sqrt(x**2 - 1)), (x, 1, 2)) == pi / 3 # handle And with Or arguments assert Piecewise((1, And(Or(x < 1, x > 3), x < 2)), (0, True)).integrate( (x, 0, 3)) == 1 # hidden false assert Piecewise((1, x > 1), (2, x > x + 1), (3, True)).integrate( (x, 0, 3)) == 5 # targetcond is Eq assert Piecewise((1, x > 1), (2, Eq(1, x)), (3, True)).integrate( (x, 0, 4)) == 6 # And has Relational needing to be solved assert Piecewise((1, And(2 * x > x + 1, x < 2)), (0, True)).integrate( (x, 0, 3)) == 1 # Or has Relational needing to be solved assert Piecewise((1, Or(2 * x > x + 2, x < 1)), (0, True)).integrate( (x, 0, 3)) == 2 # ignore hidden false (handled in canonicalization) assert Piecewise((1, x > 1), (2, x > x + 1), (3, True)).integrate( (x, 0, 3)) == 5 # watch for hidden True Piecewise assert Piecewise((2, Eq(1 - x, x * (1 / x - 1))), (0, True)).integrate( (x, 0, 3)) == 6 # overlapping conditions of targetcond are recognized and ignored; # the condition x > 3 will be pre-empted by the first condition assert Piecewise((1, Or(x < 1, x > 2)), (2, x > 3), (3, True)).integrate( (x, 0, 4)) == 6 # convert Ne to Or assert Piecewise((1, Ne(x, 0)), (2, True)).integrate((x, -1, 1)) == 2 # no default but well defined assert Piecewise((x, (x > 1) & (x < 3)), (1, (x < 4))).integrate( (x, 1, 4)) == 5 p = Piecewise((x, (x > 1) & (x < 3)), (1, (x < 4))) nan = Undefined i = p.integrate((x, 1, y)) assert i == Piecewise( (y - 1, y < 1), (Min(3, y)**2 / 2 - Min(3, y) + Min(4, y) - 1 / 2, y <= Min(4, y)), (nan, True)) assert p.integrate((x, 1, -1)) == i.subs(y, -1) assert p.integrate((x, 1, 4)) == 5 assert p.integrate((x, 1, 5)) == nan # handle Not p = Piecewise((1, x > 1), (2, Not(And(x > 1, x < 3))), (3, True)) assert p.integrate((x, 0, 3)) == 4 # handle updating of int_expr when there is overlap p = Piecewise((1, And(5 > x, x > 1)), (2, Or(x < 3, x > 7)), (4, x < 8)) assert p.integrate((x, 0, 10)) == 20 # And with Eq arg handling assert Piecewise((1, x < 1), (2, And(Eq(x, 3), x > 1))).integrate( (x, 0, 3)) == S.NaN assert Piecewise((1, x < 1), (2, And(Eq(x, 3), x > 1)), (3, True)).integrate((x, 0, 3)) == 7 assert Piecewise((1, x < 0), (2, And(Eq(x, 3), x < 1)), (3, True)).integrate((x, -1, 1)) == 4 # middle condition doesn't matter: it's a zero width interval assert Piecewise((1, x < 1), (2, Eq(x, 3) & (y < x)), (3, True)).integrate( (x, 0, 3)) == 7
def test_reduce_inequalities_multivariate(): assert reduce_inequalities([Ge(x**2, 1), Ge(y**2, 1)]) == And( Or(And(Le(S.One, x), Lt(x, oo)), And(Le(x, -1), Lt(-oo, x))), Or(And(Le(S.One, y), Lt(y, oo)), And(Le(y, -1), Lt(-oo, y))))
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
def test_Or(): N = Normal('N', 0, 1) assert simplify(P(Or(N > 2, N < 1))) == \ -erf(sqrt(2))/2 - erfc(sqrt(2)/2)/2 + S(3)/2 assert P(Or(N < 0, N < 1)) == P(N < 1) assert P(Or(N > 0, N < 0)) == 1
def test_count_ops_visual(): ADD, MUL, POW, SIN, COS, EXP, AND, D, G = symbols( 'Add Mul Pow sin cos exp And Derivative Integral'.upper()) DIV, SUB, NEG = symbols('DIV SUB NEG') NOT, OR, AND, XOR, IMPLIES, EQUIVALENT, ITE, BASIC, TUPLE = symbols( 'Not Or And Xor Implies Equivalent ITE Basic Tuple'.upper()) def count(val): return count_ops(val, visual=True) assert count(7) is S.Zero assert count(S(7)) is S.Zero assert count(-1) == NEG assert count(-2) == NEG assert count(S(2) / 3) == DIV assert count(pi / 3) == DIV assert count(-pi / 3) == DIV + NEG assert count(I - 1) == SUB assert count(1 - I) == SUB assert count(1 - 2 * I) == SUB + MUL assert count(x) is S.Zero assert count(-x) == NEG assert count(-2 * x / 3) == NEG + DIV + MUL assert count(1 / x) == DIV assert count(1 / (x * y)) == DIV + MUL assert count(-1 / x) == NEG + DIV assert count(-2 / x) == NEG + DIV assert count(x / y) == DIV assert count(-x / y) == NEG + DIV assert count(x**2) == POW assert count(-x**2) == POW + NEG assert count(-2 * x**2) == POW + MUL + NEG assert count(x + pi / 3) == ADD + DIV assert count(x + S(1) / 3) == ADD + DIV assert count(x + y) == ADD assert count(x - y) == SUB assert count(y - x) == SUB assert count(-1 / (x - y)) == DIV + NEG + SUB assert count(-1 / (y - x)) == DIV + NEG + SUB assert count(1 + x**y) == ADD + POW assert count(1 + x + y) == 2 * ADD assert count(1 + x + y + z) == 3 * ADD assert count(1 + x**y + 2 * x * y + y**2) == 3 * ADD + 2 * POW + 2 * MUL assert count(2 * z + y + x + 1) == 3 * ADD + MUL assert count(2 * z + y**17 + x + 1) == 3 * ADD + MUL + POW assert count(2 * z + y**17 + x + sin(x)) == 3 * ADD + POW + MUL + SIN assert count(2 * z + y**17 + x + sin(x**2)) == 3 * ADD + MUL + 2 * POW + SIN assert count(2 * z + y**17 + x + sin(x**2) + exp(cos(x))) == 4 * ADD + MUL + 2 * POW + EXP + COS + SIN assert count(Derivative(x, x)) == D assert count(Integral(x, x) + 2 * x / (1 + x)) == G + DIV + MUL + 2 * ADD assert count(Basic()) is S.Zero assert count({x + 1: sin(x)}) == ADD + SIN assert count([x + 1, sin(x) + y, None]) == ADD + SIN + ADD assert count({x + 1: sin(x), y: cos(x) + 1}) == SIN + COS + 2 * ADD assert count({}) is S.Zero assert count([x + 1, sin(x) * y, None]) == SIN + ADD + MUL assert count([]) is S.Zero assert count(Basic()) == 0 assert count(Basic(Basic(), Basic(x, x + y))) == ADD + 2 * BASIC assert count(Basic(x, x + y)) == ADD + BASIC assert count(Or(x, y)) == OR assert count(And(x, y)) == AND assert count(And(x**y, z)) == AND + POW assert count(Or(x, Or(y, And(z, a)))) == AND + OR assert count(Nor(x, y)) == NOT + OR assert count(Nand(x, y)) == NOT + AND assert count(Xor(x, y)) == XOR assert count(Implies(x, y)) == IMPLIES assert count(Equivalent(x, y)) == EQUIVALENT assert count(ITE(x, y, z)) == ITE assert count([Or(x, y), And(x, y), Basic(x + y)]) == ADD + AND + BASIC + OR assert count(Basic(Tuple(x))) == BASIC + TUPLE #It checks that TUPLE is counted as an operation. assert count(Eq(x + y, S(2))) == ADD
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_distribute(): A, B, C = map(Boolean, symbols('A,B,C')) assert distribute_and_over_or(Or(And(A, B), C)) == And(Or(A, C), Or(B, C))
def test_Or(): A, B, C = map(Boolean, symbols('A,B,C')) assert Or() == False assert Or(A) == A assert Or(True) == True assert Or(False) == False assert Or(True, True) == True assert Or(True, False) == True assert Or(False, False) == False assert Or(True, A) == True assert Or(False, A) == A assert Or(True, False, False) == True assert Or(True, False, A) == True assert Or(False, False, A) == A
def simplify_guard(guards): """Make a big OR among guards and simplify them.""" final = Or() for g in guards: final = Or(final, g) return simplify(final)
def test_eliminate_implications(): A, B, C = map(Boolean, symbols('A,B,C')) assert eliminate_implications(Implies(A, B, evaluate=False)) == (~A) | B assert eliminate_implications(A >> (C >> Not(B))) == Or( Or(Not(B), Not(C)), Not(A))
def gen_state(self): self.out("cdef dict vnum = %r" % {n: i for i, n in enumerate(self.variables)}) self.out() with self.out("cdef class state :"): for i in range(self.word): self.out("cdef unsigned char W%s" % i) with self.out("def __init__ (self, on=[]) :"): self.out("cdef str v") self.out("cdef unsigned int n") self.out("cdef list init") with self.out("if not on :"): self.out("init = []") with self.out("elif isinstance(on, str) :"): self.out("init = on.split('|')") with self.out("else :"): self.out("init = list(on)") with self.out("for v in init :"): self.out("n = vnum[v]") for i, n in enumerate(self.variables): if i == 0: self.out("if n == %s : self.%s" % (i, self.set_1(n))) else: self.out("elif n == %s : self.%s" % (i, self.set_1(n))) with self.out("def __getitem__ (self, key) :"): self.out("cdef unsigned int n = vnum[key]") for i, n in enumerate(self.variables): if i == 0: self.out("if n == %s : return bool(self.%s)" % (i, self.is_set(n))) else: self.out("elif n == %s : return bool(self.%s)" % (i, self.is_set(n))) with self.out("def __setitem__ (self, key, val) :"): self.out("cdef unsigned int n = vnum[key]") for i, n in enumerate(self.variables): if i == 0: self.out("if n == %s :" % i) else: self.out("elif n == %s :" % i) with self.out: self.out("if val : self.%s" % self.set_1(n)) self.out("else : self.%s" % self.set_0(n)) with self.out("def __iter__ (self) :"): for n in self.variables: self.out("if self.%s : yield %r" % (self.is_set(n), n)) with self.out("def __str__ (state self) :"): self.out("cdef list l = []") for n in self.variables: self.out("if self.%s : l.append(%r)" % (self.is_set(n), n)) self.out("return '|'.join(l)") with self.out("def __repr__ (state self) :"): self.out("cdef list l = []") for n in self.variables: self.out("if self.%s : l.append(%r)" % (self.is_set(n), repr(n))) self.out("return 'state([%s])' % ', '.join(l)") with self.out("def __eq__ (state self, state other) :"): self.out("try: return " + " and ".join("(self.W%s == other.W%s)" % (i, i) for i in range(self.word))) self.out("except : return False") with self.out("def __ne__ (state self, state other) :"): self.out("try : return " + " or ".join("(self.W%s != other.W%s)" % (i, i) for i in range(self.word))) self.out("except : return False") with self.out("def __hash__ (state self) :"): self.out("return " + " + ".join("(self.W%s << %s)" % (i, (i % WIDTH) * 8 + i // WIDTH) for i in range(self.word))) with self.out("def __invert__ (self) : "): self.out("cdef state s = state.__new__(state)") for i in range(self.word - 1): self.out("s.W%s = ~self.W%s" % (i, i)) last = (len(self.variables) % 8) or 0 mask = "0" * last + "1" * (8 - last) self.out("s.W%s = 0b%s & ~self.W%s" % (self.word - 1, mask, self.word - 1)) self.out("return s") with self.out("def __or__ (state self, object other) :"): self.out("cdef state s = state.__new__(state)") self.out("cdef unsigned int n") with self.out("if isinstance(other, str) :"): self.out("n = vnum[other]") for i in range(self.word): self.out("s.W%s = self.W%s" % (i, i)) for i, n in enumerate(self.variables): if i == 0: self.out("if n == %s : s.%s" % (i, self.set_1(n))) else: self.out("elif n == %s : s.%s" % (i, self.set_1(n))) with self.out("elif isinstance(other, state) :"): for i in range(self.word): self.out("s.W%s = self.W%s | <state>other.W%s" % (i, i, i)) with self.out("else :"): self.out("raise TypeError(\"expected 'str' or 'state'" " but had '%s'\" % other.__class__.__name__)") self.out("return s") with self.out("def __and__ (state self, object other) :"): self.out("cdef state s") self.out("cdef unsigned int n") with self.out("if isinstance(other, str) :"): self.out("s = state.__new__(state)") self.out("n = vnum[other]") for i, n in enumerate(self.variables): if i == 0: with self.out("if n == %s :" % i): self.out("if self.%s : s.%s" % (self.is_set(n), self.set_1(n))) else: with self.out("elif n == %s :" % i): self.out("if self.%s : s.%s" % (self.is_set(n), self.set_1(n))) with self.out("elif isinstance(other, state) :"): self.out("s = state.__new__(state)") for i in range(self.word): self.out("s.W%s = self.W%s & <state>other.W%s" % (i, i, i)) with self.out("else :"): self.out("raise TypeError(\"expected 'str' or 'state'" " but had '%s'\" % other.__class__.__name__)") self.out("return s") with self.out("def __contains__ (self, str var) :"): self.out("cdef unsigned int n = vnum[var]") for i, n in enumerate(self.variables): if i == 0: self.out("if n == %s : return self.%s" % (i, self.is_set(n))) else: self.out("elif n == %s : return self.%s" % (i, self.is_set(n))) for rule in chain(self.spec.constraints, self.spec.rules): self.gen_succ(rule) with self.out("cpdef bint transient (state self) :"): if self.spec.constraints: cond = Or(*(self.gen_cond(c) for c in self.spec.constraints)) self.out("return %s" % pycode(cond)) else: self.out("return False") with self.out("cdef void _succ (state self, set acc) :"): if self.spec.constraints: self.out("cdef bint transient = 0") self.out("cdef state s") for rule in self.spec.constraints: self.out("if self.%s(acc) : transient = 1" % rule.name()) if self.spec.constraints: self.out("if transient : return") for rule in self.spec.rules: self.out("self.%s(acc)" % rule.name()) with self.out("cpdef set succ (state self, bint compact=False) :"): self.out("cdef set succ, todo, done, skip") self.out("cdef state s, q") self.out("cdef str r, c") self.out("todo = set()") self.out("self._succ(todo)") with self.out("if compact :"): self.out("done = set()") self.out("skip = set()") with self.out("while todo :"): self.out("r, s = todo.pop()") with self.out("if s.transient() :"): self.out("skip.add((r, s))") self.out("succ = set() ") self.out("s._succ(succ)") self.out("succ.difference_update(skip)") self.out("succ.difference_update(done)") with self.out("for c, q in succ :"): self.out("todo.add((r, q))") with self.out("else :"): self.out("done.add((r, s))") self.out("return done") with self.out("else :"): self.out("return todo") self.out("@classmethod") with self.out("def init (cls) :"): self.out("cdef state s = cls.__new__(cls)") init = bitarray("0" * self.width) for s in sorted(self.spec.meta): if s.state.sign: pos, val = self.vmap[s.state.name] self.out("# %s = W%s & %s" % (s.state.name, pos, bin8(2**val))) init |= self.const[s.state.name] for i, v in enumerate(reversed(init.tobytes())): self.out("s.W%s = %s" % (i, bin8(v))) self.out("return s") self.out("@classmethod") with self.out("def none (cls) :"): self.out("return state.__new__(state)") self.out("@classmethod") with self.out("def all (cls) :"): self.out("cdef state s = cls.__new__(cls)") for i in range(self.word - 1): self.out("s.W%s = 0b11111111" % i) last = (len(self.variables) % 8) or 8 mask = "0" * (8 - last) + "1" * last self.out("s.W%s = 0b%s" % (self.word - 1, mask)) self.out("return s") self.out("@classmethod") with self.out("def vars (cls) :"): self.out("return %r" % (self.variables, )) self.out()
def test_issue_8373(): x = Symbol('x', real=True) assert simplify(Or(x < 1, x >= 1)) == S.true
def simplify_guard(guards): """Make a big OR among guards and simplify them.""" return simplify(Or(*guards))
def test_reduce_inequalities_multivariate(): assert reduce_inequalities([Ge(x**2, 1), Ge(y**2, 1)]) == \ And(And(Or(Le(re(x), -1), Le(1, re(x))), Eq(im(x), 0)), And(Or(Le(re(y), -1), Le(1, re(y))), Eq(im(y), 0)))
def has_compound_trivial_condition(condition_list): compound_condition = false for c in condition_list: compound_condition = Or(compound_condition, c) return is_trivial_condition(simplify_logic(compound_condition))
def as_boolean(self): return Or(*[And(*[Eq(sym, val) for sym, val in item]) for item in self])
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_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 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) is False assert reduce_rational_inequalities( [[Ge(x**2, 0)]], x, relational=True) is 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 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 delta(self, l, X): v = False for i in self.formulas: v = Or(v, i.delta(l, X)) return v
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 delta(self, l, X): first, second = self.formulas[0:2] return Or(Not(first.delta(l, X)), second.delta(l, X))
def test_piecewise(): # Test canonicalization 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 # False condition is never retained assert Piecewise((x, False)) == Piecewise( (x, False), evaluate=False) == Piecewise() raises(TypeError, lambda: Piecewise(x)) assert Piecewise((x, 1)) == x # 1 and 0 are accepted as True/False raises(TypeError, lambda: Piecewise((x, 2))) raises(TypeError, lambda: Piecewise((x, x**2))) raises(TypeError, lambda: Piecewise(([1], True))) assert Piecewise(((1, 2), True)) == Tuple(1, 2) cond = (Piecewise((1, x < 0), (2, True)) < y) assert Piecewise((1, cond)) == Piecewise((1, ITE(x < 0, y > 1, y > 2))) assert Piecewise((1, x > 0), (2, And(x <= 0, x > -1))) == Piecewise( (1, x > 0), (2, x > -1)) # 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)) p5 = Piecewise((0, Eq(cos(x) + y, 0)), (1, True)) assert p5.subs(y, 0) == Piecewise((0, Eq(cos(x), 0)), (1, True)) assert Piecewise((-1, y < 1), (0, x < 0), (1, Eq(x, 0)), (2, True)).subs(x, 1) == Piecewise((-1, y < 1), (2, True)) assert Piecewise((1, Eq(x**2, -1)), (2, x < 0)).subs(x, I) == 1 # 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 / 2, 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 assert p.integrate() == Piecewise((-x, x < -1), (x**3 / 3 + 4 / 3, x < 0), (x * log(x) - x + 4 / 3, True)) p = Piecewise((x, x < 1), (x**2, -1 <= x), (x, 3 < x)) assert integrate(p, (x, -2, 2)) == 5 / 6.0 assert integrate(p, (x, 2, -2)) == -5 / 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)) assert integrate(p, (x, -2, 2)) == Undefined # Test commutativity assert isinstance(p, Piecewise) and p.is_commutative is True
def delta(self, l, X): f, g = self.formulas[0:2] f, g = f.delta(l, X), g.delta(l, X) return Or(And(f, g), And(Not(f), Not(g)))
def test_issue_10122(): assert solve(abs(x) + abs(x - 1) - 1 > 0, x) == Or(And(-oo < x, x < 0), And(S.One < x, x < oo))
def test_dice(): # TODO: Make iid method! X, Y, Z = Die('X', 6), Die('Y', 6), Die('Z', 6) a, b, t, p = symbols('a b t p') assert E(X) == 3 + S.Half 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) is 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 + Y, 4) == kurtosis(X + Y) assert smoment(X, 0) == 1 assert P(X > 3) == S.Half assert P(2 * X > 6) == S.Half 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 quantile(X)(p) == Piecewise((nan, (p > 1) | (p < 0)),\ (S.One, p <= Rational(1, 6)), (S(2), p <= Rational(1, 3)), (S(3), p <= S.Half),\ (S(4), p <= Rational(2, 3)), (S(5), p <= Rational(5, 6)), (S(6), p <= 1)) assert P(X > 3, X > 3) is S.One assert P(X > Y, Eq(Y, 6)) is S.Zero 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[S(22)] == Rational(1, 108) and d[S(4100)] == Rational( 1, 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) assert characteristic_function(X)(t) == exp(6 * I * t) / 6 + exp( 5 * I * t) / 6 + exp(4 * I * t) / 6 + exp(3 * I * t) / 6 + exp( 2 * I * t) / 6 + exp(I * t) / 6 assert moment_generating_function(X)( t) == exp(6 * t) / 6 + exp(5 * t) / 6 + exp(4 * t) / 6 + exp( 3 * t) / 6 + exp(2 * t) / 6 + exp(t) / 6 assert median(X) == FiniteSet(3, 4) D = Die('D', 7) assert median(D) == FiniteSet(4) # Bayes test for die BayesTest(X > 3, X + Y < 5) BayesTest(Eq(X - Y, Z), Z > Y) BayesTest(X > 3, X > 2) # arg test for die raises(ValueError, lambda: Die('X', -1)) # issue 8105: negative sides. raises(ValueError, lambda: Die('X', 0)) raises(ValueError, lambda: Die('X', 1.5)) # issue 8103: non integer sides. # symbolic test for die n, k = symbols('n, k', positive=True) D = Die('D', n) dens = density(D).dict assert dens == Density(DieDistribution(n)) assert set(dens.subs(n, 4).doit().keys()) == set([1, 2, 3, 4]) assert set(dens.subs(n, 4).doit().values()) == set([Rational(1, 4)]) k = Dummy('k', integer=True) assert E(D).dummy_eq(Sum(Piecewise((k / n, k <= n), (0, True)), (k, 1, n))) assert variance(D).subs(n, 6).doit() == Rational(35, 12) ki = Dummy('ki') cumuf = cdf(D)(k) assert cumuf.dummy_eq( Sum(Piecewise((1 / n, (ki >= 1) & (ki <= n)), (0, True)), (ki, 1, k))) assert cumuf.subs({n: 6, k: 2}).doit() == Rational(1, 3) t = Dummy('t') cf = characteristic_function(D)(t) assert cf.dummy_eq( Sum(Piecewise((exp(ki * I * t) / n, (ki >= 1) & (ki <= n)), (0, True)), (ki, 1, n))) assert cf.subs( n, 3).doit() == exp(3 * I * t) / 3 + exp(2 * I * t) / 3 + exp(I * t) / 3 mgf = moment_generating_function(D)(t) assert mgf.dummy_eq( Sum(Piecewise((exp(ki * t) / n, (ki >= 1) & (ki <= n)), (0, True)), (ki, 1, n))) assert mgf.subs(n, 3).doit() == exp(3 * t) / 3 + exp(2 * t) / 3 + exp(t) / 3
def test_slow_general_univariate(): r = rootof(x**5 - x**2 + 1, 0) assert solve(sqrt(x) + 1/root(x, 3) > 1) == \ Or(And(0 < x, x < r**6), And(r**6 < x, x < oo))
def test_piecewise_integrate4_symbolic_conditions(): a = Symbol('a', real=True, finite=True) b = Symbol('b', real=True, finite=True) x = Symbol('x', real=True, finite=True) y = Symbol('y', real=True, finite=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)) # check values of a=1, b=3 (and reversed) with values # of y of 0, 1, 2, 3, 4 lim = Tuple(x, -oo, y) for p in (p0, p1, p2, p3, p4, p5): ans = p.integrate(lim) for i in range(5): reps = {a:1, b:3, y:i} assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps)) reps = {a: 3, b:1, y:i} assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps)) lim = Tuple(x, y, oo) for p in (p0, p1, p2, p3, p4, p5): ans = p.integrate(lim) for i in range(5): reps = {a:1, b:3, y:i} assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps)) reps = {a:3, b:1, y:i} assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps)) ans = Piecewise( (0, x <= Min(a, b)), (x - Min(a, b), x <= b), (b - Min(a, b), True)) for i in (p0, p1, p2, p4): assert i.integrate(x) == ans assert p3.integrate(x) == Piecewise( (0, x < a), (-a + x, x <= Max(a, b)), (-a + Max(a, b), True)) assert p5.integrate(x) == Piecewise( (0, x <= a), (-a + x, x <= Max(a, b)), (-a + Max(a, b), 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)) # check values of a=1, b=3 (and reversed) with values # of y of 0, 1, 2, 3, 4 lim = Tuple(x, -oo, y) for p in (p1, p2, p3, p4, p5): ans = p.integrate(lim) for i in range(5): reps = {a:1, b:3, y:i} assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps)) reps = {a: 3, b:1, y:i} assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps))