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_sifting(): # Figs. 6.24, 6.25 Baier 2008 g = BDD({'z1': 0, 'z2': 1, 'z3': 2, 'y1': 3, 'y2': 4, 'y3': 5}) u = g.add_expr('(z1 & y1) | (z2 & y2) | (z3 & y3)') g.incref(u) g.collect_garbage() n = len(g) assert n == 15, n _bdd.reorder(g) u_ = g.add_expr('(z1 & y1) | (z2 & y2) | (z3 & y3)') g.incref(u) g.collect_garbage() g.assert_consistent() assert u == u_, (u, u_)
def test_sifting(): # Figs. 6.24, 6.25 Baier 2008 g = BDD({'z1': 0, 'z2': 1, 'z3': 2, 'y1': 3, 'y2': 4, 'y3': 5}) u = g.add_expr('(z1 & y1) | (z2 & y2) | (z3 & y3)') g.incref(u) g.collect_garbage() n = len(g) assert n == 15, n _bdd.reorder(g) u_ = g.add_expr('(z1 & y1) | (z2 & y2) | (z3 & y3)') g.incref(u) g.collect_garbage() g.assert_consistent() assert u == u_, (u, u_)
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_reorder(): bdd = _bdd.BDD() bdd.declare('x', 'y', 'z') u = bdd.add_expr('(x /\ y) \/ z') bdd.reorder() assert u in bdd
def reorder(bdd, order=None): """Apply Rudell's sifting algorithm to `bdd`.""" _bdd.reorder(bdd._bdd, order=order)
def reorder(bdd, order=None): """Apply Rudell's sifting algorithm to `bdd`.""" _bdd.reorder(bdd._bdd, order=order)
def bdd_to_mdd(bdd, dvars): """Return MDD for given BDD. Caution: collects garbage. `dvars` must map each MDD variable to the corresponding bits in BDD. Also, it should give the order as "level" keys. """ # i = level in BDD # j = level in MDD # bit = BDD variable # var = MDD variable # # map from bits to integers bit_to_var = dict() for var, d in dvars.iteritems(): bits = d['bitnames'] b = {bit: var for bit in bits} bit_to_var.update(b) # find target bit ordering ordering = list() # target levels = {d['level']: var for var, d in dvars.iteritems()} m = len(levels) for j in xrange(m): var = levels[j] bits = dvars[var]['bitnames'] ordering.extend(bits) bit_to_sort = {bit: k for k, bit in enumerate(ordering)} # reorder bdd.collect_garbage() _bdd.reorder(bdd, order=bit_to_sort) # BDD -> MDD mdd = MDD(dvars) # zones of bits per integer var zones = dict() for var, d in dvars.iteritems(): bits = d['bitnames'] lsb = bits[0] msb = bits[-1] min_level = bit_to_sort[lsb] max_level = bit_to_sort[msb] zones[var] = (min_level, max_level) # reverse edges pred = {u: set() for u in bdd} for u, (_, v, w) in bdd._succ.iteritems(): assert u > 0, u # terminal ? if u == 1: continue # non-terminal pred[abs(v)].add(u) pred[abs(w)].add(u) # find BDD nodes mentioned from above rm = set() for u, p in pred.iteritems(): rc = bdd.ref(u) k = len(p) # number of predecessors # has external refs ? if rc > k: continue # has refs from outside zone ? i, _, _ = bdd._succ[u] bit = bdd.var_at_level(i) var = bit_to_var[bit] min_level, _ = zones[var] pred_levels = {bdd._succ[v][0] for v in p} min_pred_level = min(pred_levels) if min_pred_level < min_level: continue # referenced only from inside zone rm.add(u) pred = {u: p for u, p in pred.iteritems() if u not in rm} # build layer by layer # TODO: use bins, instad of iterating through all nodes bdd.assert_consistent() g = to_nx(bdd, roots=[u]) for u in pred: g.add_node(u, color='red') for u in g: if u == 1: continue i, _, _ = bdd._succ[u] var = bdd.var_at_level(i) label = '{var}-{u}'.format(var=var, u=u) g.add_node(u, label=label) pd = nx.to_pydot(g) pd.write_pdf('bdd_colored.pdf') bdd.dump('bdd.pdf') umap = dict() umap[1] = 1 for u, i, v, w in bdd.levels(skip_terminals=True): # ignore function ? if u not in pred: continue # keep `u` bit = bdd.var_at_level(i) var = bit_to_var[bit] bits = dvars[var]['bitnames'] bit_succ = list() for d in _enumerate_integer(bits): x = bdd.cofactor(u, d) bit_succ.append(x) # map edges int_succ = [umap[abs(z)] if z > 0 else -umap[abs(z)] for z in bit_succ] # add new MDD node at level j j = dvars[var]['level'] r = mdd.find_or_add(j, *int_succ) # cache # signed r, because low never inverted, # opposite to canonicity chosen for BDDs umap[u] = r return mdd, umap