def test_eval(self): a = self.a b = self.b c = self.c _0 = boolean.FALSE _1 = boolean.TRUE # Idempotence self.assertTrue(a == a*a) # Idempotence + Associativity self.assertTrue(a+b == a+(a+b)) # Annihilation self.assertTrue(_0 == (a * _0)) self.assertTrue(_1 == (a + _1)) # Identity self.assertTrue(a == (a * _1)) self.assertTrue(a == (a + _0)) # Complementation self.assertTrue(_0 == a * ~a) self.assertTrue(_1 == a + ~a) # Absorption self.assertTrue(a == a * (a+b)) self.assertTrue(a == a + (a*b)) self.assertTrue(b*a == (b*a) + (b*a*c)) # Elimination self.assertTrue(a == (a*~b)+(a*b)) expr = boolean.parse("(~a*b*c) + (a*~b*c) + (a*b*~c) + (a*b*c)") result = boolean.parse("(a*b)+(b*c)+(a*c)") self.assertTrue(expr == result) expr = boolean.parse("(~a*b*~c*~d) + (a*~b*~c*~d) + (a*~b*c*~d) +"\ "(a*~b*c*d) + (a*b*~c*~d) + (a*b*c*d)") result = boolean.parse("(~b*~d*a) + (~c*~d*b) + (a*c*d)") self.assertTrue(expr == result) expr = boolean.parse("(~a*~b*~c*~d) + (~a*~b*~c*d) + (~a*b*~c*~d) +"\ "(~a*b*c*d) + (~a*b*~c*d) + (~a*b*c*~d) +"\ "(a*~b*~c*d) + (~a*b*c*d) + (a*~b*c*d) + (a*b*c*d)")
def test_eval(self): a = self.a b = self.b c = self.c _0 = boolean.FALSE _1 = boolean.TRUE # Idempotence self.assertTrue(a == a * a) # Idempotence + Associativity self.assertTrue(a + b == a + (a + b)) # Annihilation self.assertTrue(_0 == (a * _0)) self.assertTrue(_1 == (a + _1)) # Identity self.assertTrue(a == (a * _1)) self.assertTrue(a == (a + _0)) # Complementation self.assertTrue(_0 == a * ~a) self.assertTrue(_1 == a + ~a) # Absorption self.assertTrue(a == a * (a + b)) self.assertTrue(a == a + (a * b)) self.assertTrue(b * a == (b * a) + (b * a * c)) # Elimination self.assertTrue(a == (a * ~b) + (a * b)) expr = boolean.parse("(~a*b*c) + (a*~b*c) + (a*b*~c) + (a*b*c)") result = boolean.parse("(a*b)+(b*c)+(a*c)") self.assertTrue(expr == result) expr = boolean.parse("(~a*b*~c*~d) + (a*~b*~c*~d) + (a*~b*c*~d) +"\ "(a*~b*c*d) + (a*b*~c*~d) + (a*b*c*d)") result = boolean.parse("(~b*~d*a) + (~c*~d*b) + (a*c*d)") self.assertTrue(expr == result) expr = boolean.parse("(~a*~b*~c*~d) + (~a*~b*~c*d) + (~a*b*~c*~d) +"\ "(~a*b*c*d) + (~a*b*~c*d) + (~a*b*c*~d) +"\ "(a*~b*~c*d) + (~a*b*c*d) + (a*~b*c*d) + (a*b*c*d)")
def test_class_order(self): order = ((boolean.TRUE, boolean.FALSE), (boolean.Symbol(), boolean.Symbol("x")), (boolean.parse("x*y"),), (boolean.parse("x+y"),), ) for i, tests in enumerate(order): for case1 in tests: for j in range(i+1, len(order)): for case2 in order[j]: self.assertTrue(case1 < case2) self.assertTrue(case2 > case1)
def test_class_order(self): order = ( (boolean.TRUE, boolean.FALSE), (boolean.Symbol(), boolean.Symbol("x")), (boolean.parse("x*y"), ), (boolean.parse("x+y"), ), ) for i, tests in enumerate(order): for case1 in tests: for j in range(i + 1, len(order)): for case2 in order[j]: self.assertTrue(case1 < case2) self.assertTrue(case2 > case1)
def test_cancel(self): a = boolean.Symbol("a") parse = lambda x: boolean.parse(x, eval=False) self.assertTrue(~a == (~a).cancel()) self.assertTrue(a == parse("~~a").cancel()) self.assertTrue(~a == parse("~~~a").cancel()) self.assertTrue(a == parse("~~~~a").cancel())
def test_demorgan(self): a, b, c = boolean.symbols("a", "b", "c") parse = lambda x: boolean.parse(x, eval=False) self.assertTrue(parse("~(a*b)").demorgan() == ~a + ~b) self.assertTrue(parse("~(a+b+c)").demorgan()\ == parse("~a*~b*~c")) self.assertTrue(parse("~(~a*b)").demorgan() == a + ~b)
def test_printing(self): a = boolean.Symbol("a") self.assertTrue(str(~a) == "~a") self.assertTrue(repr(~a) == "NOT(Symbol('a'))") expr = boolean.parse("~(a*a)", eval=False) self.assertTrue(str(expr) == "~(a*a)") self.assertTrue(repr(expr) == "NOT(AND(Symbol('a'), Symbol('a')))")
def test_demorgan(self): a, b, c = boolean.symbols("a", "b", "c") parse = lambda x: boolean.parse(x, eval=False) self.assertTrue(parse("~(a*b)").demorgan() == ~a+~b) self.assertTrue(parse("~(a+b+c)").demorgan()\ == parse("~a*~b*~c")) self.assertTrue(parse("~(~a*b)").demorgan() == a+~b)
def test_subs(self): a, b, c = boolean.symbols("a", "b", "c") expr = a * b + c self.assertEqual(expr.subs({a: b}), b + c) self.assertEqual(expr.subs({a: a}), expr) self.assertEqual(expr.subs({a: b + c}), boolean.parse("(b+c)*b+c")) self.assertEqual(expr.subs({a * b: a}), a + c) self.assertEqual(expr.subs({c: boolean.TRUE}), boolean.TRUE)
def test_subs(self): a, b, c = boolean.symbols("a", "b", "c") expr = a*b+c self.assertEqual(expr.subs({a:b}), b+c) self.assertEqual(expr.subs({a:a}), expr) self.assertEqual(expr.subs({a:b+c}), boolean.parse("(b+c)*b+c")) self.assertEqual(expr.subs({a*b:a}), a+c) self.assertEqual(expr.subs({c: boolean.TRUE}), boolean.TRUE)
def test_eval(self): a = boolean.Symbol("a") self.assertTrue(~a == ~a) self.assertFalse(a == boolean.parse("~~a", eval=False)) self.assertTrue(a == ~~a) self.assertTrue(~a, ~~~a) self.assertTrue(a, ~~~~a) self.assertTrue(~(a * a * a) == ~(a * a * a))
def test_eval(self): a = boolean.Symbol("a") self.assertTrue(~a == ~a) self.assertFalse(a == boolean.parse("~~a", eval=False)) self.assertTrue(a == ~~a) self.assertTrue(~a, ~~~a) self.assertTrue(a, ~~~~a) self.assertTrue(~(a*a*a) == ~(a*a*a))
def test_literals(self): a = boolean.Symbol("a") l = ~a self.assertTrue(l.isliteral) self.assertTrue(l in l.literals) self.assertTrue(len(l.literals) == 1) l = boolean.parse("~(a*a)", eval=False) self.assertFalse(l.isliteral) self.assertTrue(a in l.literals) self.assertTrue(len(l.literals) == 1)
def test_creation(self): E = boolean.Expression expr_str = "(a+b+c)*d*(~e+(f*g))" expr = boolean.parse(expr_str) self.assertTrue(E(expr) is expr) self.assertTrue(E(expr_str) == expr) self.assertTrue(E(1) is boolean.TRUE) self.assertTrue(E(True) is boolean.TRUE) self.assertTrue(E(0) is boolean.FALSE) self.assertTrue(E(False) is boolean.FALSE)
def test_printing(self): parse = lambda x: boolean.parse(x, eval=False) a = self.a b = self.b c = self.c self.assertTrue(str(parse("a*a")) == "a*a") self.assertTrue(repr(parse("a*a")) == "AND(Symbol('a'), Symbol('a'))") self.assertTrue(str(parse("a+a")) == "a+a") self.assertTrue(repr(parse("a+a")) == "OR(Symbol('a'), Symbol('a'))") self.assertTrue(str(parse("(a+b)*c")) == "(a+b)*c") self.assertTrue(repr(parse("(a+b)*c")) ==\ "AND(OR(Symbol('a'), Symbol('b')), Symbol('c'))")
def test_flatten(self): p = lambda x: boolean.parse(x, eval=False) a = self.a b = self.b c = self.c t1 = p("a * (b*c)") t2 = p("a*b*c") self.assertFalse(t1 == t2) self.assertTrue(t1.flatten() == t2) t1 = p("a + ((b*c) + (a*c)) + b") t2 = p("a + (b*c) + (a*c) + b") self.assertFalse(t1 == t2) self.assertTrue(t1.flatten() == t2)
def test_annihilator(self): a = boolean.Symbol("a") p = lambda x: boolean.parse(x, eval=False) self.assertTrue(p("a*a").annihilator is boolean.FALSE) self.assertTrue(p("a+a").annihilator is boolean.TRUE)
def test_dual(self): self.assertTrue(boolean.AND.getdual() is boolean.OR) self.assertTrue(boolean.OR.getdual() is boolean.AND) self.assertTrue(boolean.parse("a+b").dual is boolean.AND) self.assertTrue(boolean.parse("a*b").dual is boolean.OR)
def test_identity(self): self.assertTrue(boolean.parse("a+b").identity is boolean.FALSE) self.assertTrue(boolean.parse("a*b").identity is boolean.TRUE)
def test_isliteral(self): s = boolean.Symbol(1) self.assertTrue(boolean.NOT(s).isliteral) self.assertFalse(boolean.parse("~(a+b)").isliteral)