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_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_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_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_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_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_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_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_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_identity(self):
self.assertTrue(boolean.parse("a+b").identity is boolean.FALSE)
self.assertTrue(boolean.parse("a*b").identity 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_isliteral(self):
s = boolean.Symbol(1)
self.assertTrue(boolean.NOT(s).isliteral)
self.assertFalse(boolean.parse("~(a+b)").isliteral)
def test_isliteral(self):
s = boolean.Symbol(1)
self.assertTrue(boolean.NOT(s).isliteral)
self.assertFalse(boolean.parse("~(a+b)").isliteral)
