def test_configure_dynamic_reordering(): bdd = _bdd.BDD() vrs = [ 'x', 'y', 'z', 'a', 'b', 'c', 'e', 'z1', 'z2', 'z3', 'y1', 'y2', 'y3' ] expr_1 = '(~ z \/ (c /\ b)) /\ e /\ (a /\ (~ x \/ y))' expr_2 = '(z1 /\ y1) \/ (z2 /\ y2) \/ (z3 /\ y3)' # w/o dynamic reordering bdd = _bdd.BDD() bdd.declare(*vrs) u = bdd.add_expr(expr_1) v = bdd.add_expr(expr_2) bdd.collect_garbage() n = len(bdd) assert n == 23, n # with dynamic reordering del u, v, bdd dd.bdd.REORDER_STARTS = 7 bdd = _bdd.BDD() bdd.declare(*vrs) bdd.configure(reordering=True) u = bdd.add_expr(expr_1) v = bdd.add_expr(expr_2) bdd.collect_garbage() n = len(bdd) assert n < 23, n
def test_function_properties(): bdd = _bdd.BDD() bdd.declare('x', 'y') order = dict(x=0, y=1) bdd.reorder(order) u = bdd.add_expr('x \/ y') y = bdd.add_expr('y') # Assigned first because in presence of a bug # different property calls could yield # different values. level = u.level assert level == 0, level var = u.var assert var == 'x', var low = u.low assert low == y, low high = u.high assert high == bdd.true, high ref = u.ref assert ref == 1, ref assert not u.negated support = u.support assert support == {'x', 'y'}, support # terminal u = bdd.false assert u.var is None, u.var assert u.low is None, u.low assert u.high is None, u.high
def test_func_len(): bdd = _bdd.BDD() bdd.declare('x', 'y') u = bdd.add_expr('x') n = len(u) assert n == 2, n u = bdd.add_expr('x /\ y') n = len(u) assert n == 3, n
def test_negated(): bdd = _bdd.BDD() bdd.declare('x') u = bdd.add_expr('x') neg_u = bdd.add_expr('~ x') a = u.negated b = neg_u.negated assert a or b, (a, b) assert not (a and b), (a, b)
def test_to_expr(): bdd = _bdd.BDD() bdd.declare('x', 'y') u = bdd.add_expr('x') s = bdd.to_expr(u) assert s == 'x', s u = bdd.add_expr('x /\ y') s = bdd.to_expr(u) assert s == 'ite(x, y, FALSE)', s
def test_preimage(): bdd = _bdd.BDD() bdd.declare('x', 'y', 'z') action = bdd.add_expr('x <=> y') target = bdd.add_expr('x') qvars = {'y'} rename = dict(x='y') u = _bdd.preimage(action, target, rename, qvars) u_ = bdd.add_expr('x') assert u == u_
def test_image(): bdd = _bdd.BDD() bdd.declare('x', 'y', 'z') action = bdd.add_expr('x => y') source = bdd.add_expr('x') qvars = {'x'} rename = dict(y='x') u = _bdd.image(action, source, rename, qvars) u_ = bdd.add_expr('x') assert u == u_
def test_count(): bdd = _bdd.BDD() bdd.declare('x', 'y') u = bdd.add_expr('x') n = bdd.count(u) assert n == 1, n u = bdd.add_expr('x /\ y') n = bdd.count(u) assert n == 1, n u = bdd.add_expr('x \/ y') n = bdd.count(u) assert n == 3, n
def test_comparators(): bdd = _bdd.BDD() # `None` assert not (bdd.false == None) assert not (bdd.true == None) assert bdd.false != None assert bdd.true != None # constant assert bdd.false < bdd.true assert bdd.false <= bdd.true assert bdd.false != bdd.true assert bdd.true >= bdd.false assert bdd.true > bdd.false assert bdd.true == bdd.true assert bdd.false == bdd.false # non-constant bdd.declare('x') u = bdd.add_expr('x') # compared to false assert u > bdd.false assert u >= bdd.false assert u != bdd.false assert bdd.false <= u assert bdd.false < u assert u == u # compared to true assert u < bdd.true assert u <= bdd.true assert u != bdd.true assert bdd.true >= u assert bdd.true > u
def test_node_hash(): bdd = _bdd.BDD() bdd.declare('z') u = bdd.add_expr('z') n = hash(u) m = hash(bdd.true) assert n != m, (n, m)
def test_iterative_bddizer(): add = bdd_trs.add_expr order = {'x': 0, 'y': 1, 'z': 2} # x & y bdd = dd.bdd.BDD(order) e = '& x y' u = add(e, bdd) v = bdd.add_expr('x & y') assert u == v, (u, v) # buffers # (x & y) | ! z bdd = dd.bdd.BDD(order) e = '$ 3 & x y ! z | ? 0 ? 1' u = add(e, bdd) v = bdd.add_expr('(x /\ y) \/ ~ z') assert u == v, (u, v)
def test_reorder_2(): bdd = _bdd.BDD() vrs = [ 'x', 'y', 'z', 'a', 'b', 'c', 'e', 'z1', 'z2', 'z3', 'y1', 'y2', 'y3' ] bdd = _bdd.BDD() bdd.declare(*vrs) expr_1 = '(~ z \/ (c /\ b)) /\ e /\ (a /\ (~ x \/ y))' # Figs. 6.24, 6.25 Baier 2008 expr_2 = '(z1 /\ y1) \/ (z2 /\ y2) \/ (z3 /\ y3)' u = bdd.add_expr(expr_1) v = bdd.add_expr(expr_2) bdd.collect_garbage() n = len(bdd) assert n == 23, n bdd.reorder() n_ = len(bdd) assert n > n_, (n, n_) bdd.assert_consistent()
def test_pick_iter(): bdd = _bdd.BDD() bdd.declare('x', 'y') # single var u = bdd.add_expr('x') models = list(bdd.pick_iter(u)) models_ = [dict(x=True)] assert models == models_, (models, models_) # two vars u = bdd.add_expr('x \/ y') models = list(bdd.pick_iter(u)) models_ = [ dict(x=True, y=True), dict(x=True, y=False), dict(x=False, y=True) ] for m in models: assert m in models_ for m in models_: assert m in models
def test_apply(): bdd = _bdd.BDD() for var in ['x', 'y', 'z']: bdd.add_var(var) x = bdd.var('x') y = bdd.var('y') z = bdd.var('z') # (x \/ ~ x) \equiv TRUE not_x = bdd.apply('not', x) true = bdd.apply('or', x, not_x) assert true == bdd.true, true # (x /\ ~ x) \equiv FALSE false = bdd.apply('and', x, not_x) assert false == bdd.false, false # (x /\ y) \equiv ~ (~ x \/ ~ y) u = bdd.apply('and', x, y) not_y = bdd.apply('not', y) v = bdd.apply('or', not_x, not_y) v = bdd.apply('not', v) assert u == v, (u, v) # xor u = bdd.apply('xor', x, y) r = bdd.let(dict(x=False, y=False), u) assert r == bdd.false, r r = bdd.let(dict(x=True, y=False), u) assert r == bdd.true, r r = bdd.let(dict(x=False, y=True), u) assert r == bdd.true, r r = bdd.let(dict(x=True, y=True), u) assert r == bdd.false, r # (z \/ ~ y) /\ x = (z /\ x) \/ (~ y /\ x) u = bdd.apply('or', z, not_y) u = bdd.apply('and', u, x) v = bdd.apply('and', z, x) w = bdd.apply('and', not_y, x) v = bdd.apply('or', v, w) assert u == v, (u, v) # symbols u = bdd.apply('and', x, y) v = bdd.apply('&', x, y) assert u == v, (u, v) u = bdd.apply('or', x, y) v = bdd.apply('|', x, y) assert u == v, (u, v) u = bdd.apply('not', x) v = bdd.apply('!', x) assert u == v, (u, v) u = bdd.apply('xor', x, y) v = bdd.apply('^', x, y) assert u == v, (u, v) # ternary u = bdd.apply('ite', x, y, ~z) u_ = bdd.add_expr('(x /\ y) \/ (~ x /\ ~ z)') assert u == u_, (u, u_)
def test_compose(): bdd = _bdd.BDD() for var in ['x', 'y', 'z']: bdd.add_var(var) u = bdd.add_expr('x /\ ~ y') # x |-> y sub = dict(x=bdd.var('y')) v = bdd.let(sub, u) v_ = bdd.false assert v == v_, v # x |-> z sub = dict(x=bdd.var('z')) v = bdd.let(sub, u) v_ = bdd.add_expr('z /\ ~ y') assert v == v_, v # x |-> (y \/ z) sub = dict(x=bdd.add_expr('y \/ z')) v = bdd.let(sub, u) v_ = bdd.add_expr('(y \/ z) /\ ~ y') assert v == v_, v
def test_copy(): bdd = _bdd.BDD() other = _bdd.BDD() bdd.declare('x') other.declare('x') u = bdd.add_expr('~ x') v = bdd.copy(u, other) v_ = other.add_expr('~ x') assert v == v_, (v, v_) # copy to same manager w = bdd.copy(u, bdd) assert u == w, (u, w)
def test_add_expr(): bdd = _bdd.BDD() for var in ['x', 'y']: bdd.add_var(var) # (FALSE \/ TRUE) /\ x = x s = '(TRUE \/ FALSE) /\ x' u = bdd.add_expr(s) x = bdd.var('x') assert u == x, (u, x) # ((x \/ ~ y) /\ x) \equiv x s = '(x \/ ~ y) /\ x' u = bdd.add_expr(s) assert u == x, (u, x) # x /\ y /\ z bdd.add_var('z') z = bdd.var('z') u = bdd.add_expr('x /\ y /\ z') u_ = bdd.cube(dict(x=True, y=True, z=True)) assert u == u_, (u, u_) # x /\ ~ y /\ z u = bdd.add_expr('x /\ ~ y /\ z') u_ = bdd.cube(dict(x=True, y=False, z=True)) assert u == u_, (u, u_) # (\E x: x /\ y) \equiv y y = bdd.var('y') u = bdd.add_expr('\E x: x /\ y') assert u == y, (str(u), str(y)) # (\A x: x \/ ~ x) \equiv TRUE u = bdd.add_expr('\A x: ~ x \/ x') assert u == bdd.true, u
def test_dump_load(): vrs = ['x', 'y', 'z'] s = 'x \/ y \/ ~ z' fname = 'foo.p' # dump bdd = _bdd.BDD() bdd.declare(*vrs) u = bdd.add_expr(s) bdd.dump(fname, roots=[u]) # load other = _bdd.BDD() umap = other.load(fname) assert len(umap) == 3, umap
def test_bddizer_propositional(): add = sym_bdd.add_expr order = {'x': 0, 'y': 1, 'z': 2} # x & y bdd = dd.bdd.BDD(order) e = '& x y' u = add(e, bdd) v = bdd.add_expr('x /\ y') assert u == v, (u, v) # buffers # (x & y) | ! z bdd = dd.bdd.BDD(order) e = '$ 3 & x y ! z | ? 0 ? 1' u = add(e, bdd) v = bdd.add_expr('(x & y) | ! z') assert u == v, (u, v) # e = '& $2 & 1 x ?0 $3 | !x y z & ?1 z' s = 'x /\ z' u = add(e, bdd) v = bdd.add_expr(s) assert u == v, (u, v)
def test_add_int(): bdd = _bdd.BDD() bdd.declare('x', 'y') u = bdd.add_expr('x \/ ~ y') node_id = int(u) u_ = bdd._add_int(node_id) assert u == u_, (u, u_) id2 = int(u_) assert node_id == id2, (node_id, id2) # test string form node_str = str(u) s = '@{nid}'.format(nid=node_id) assert node_str == s, (node_str, s)
def test_collect_garbage(): bdd = _bdd.BDD() n = len(bdd) assert n == 1, n bdd.declare('x', 'y') u = bdd.add_expr('x \/ y') bdd.collect_garbage() n = len(bdd) assert n > 1, n del u bdd.collect_garbage() n = len(bdd) assert n == 1, n
def test_bddizer_substitution(): add = sym_bdd.add_expr order = {'x': 0, 'y': 1, 'z': 2, 'w': 3} bdd = dd.bdd.BDD(order) e = '\S $2 x y y' u = add(e, bdd) u_ = bdd.var('x') assert u == u_, (u, u_) e = '\S $4 x y z w | y ! w' u = add(e, bdd) u_ = bdd.add_expr('x | ! z') assert u == u_, (u, u_) e = '$2 0 \S $2 x y y' u = add(e, bdd) u_ = bdd.var('x') assert u == u_, (u, u_)
def test_reorder(): bdd = _bdd.BDD() bdd.declare('x', 'y', 'z') u = bdd.add_expr('(x /\ y) \/ z') bdd.reorder() assert u in bdd