Exemple #1
0
def bdd2expr(bdd, conj=False):
    """Convert a binary decision diagram into an expression.

    This function will always return an expression in two-level form.
    If *conj* is ``False``, return a sum of products (SOP).
    Otherwise, return a product of sums (POS).

    For example::

       >>> a, b = map(bddvar, 'ab')
       >>> bdd2expr(~a | b)
       Or(~a, And(a, b))
    """
    if conj:
        outer, inner = (And, Or)
        paths = _iter_all_paths(bdd.node, BDDNODEZERO)
    else:
        outer, inner = (Or, And)
        paths = _iter_all_paths(bdd.node, BDDNODEONE)
    terms = list()
    for path in paths:
        expr_point = {
            exprvar(v.names, v.indices): val
            for v, val in _path2point(path).items()
        }
        terms.append(boolfunc.point2term(expr_point, conj))
    return outer(*[inner(*term) for term in terms])
Exemple #2
0
def bdd2expr(bdd, conj=False):
    """Convert a binary decision diagram into an expression.

    This function will always return an expression in two-level form.
    If *conj* is ``False``, return a sum of products (SOP).
    Otherwise, return a product of sums (POS).

    For example::

       >>> a, b = map(bddvar, 'ab')
       >>> bdd2expr(~a | b)
       Or(~a, And(a, b))
    """
    if conj:
        outer, inner = (And, Or)
        paths = _iter_all_paths(bdd.node, BDDNODEZERO)
    else:
        outer, inner = (Or, And)
        paths = _iter_all_paths(bdd.node, BDDNODEONE)
    terms = list()
    for path in paths:
        expr_point = {exprvar(v.names, v.indices): val
                      for v, val in _path2point(path).items()}
        terms.append(boolfunc.point2term(expr_point, conj))
    return outer(*[inner(*term) for term in terms])
Exemple #3
0
def bdd2expr(bdd, conj=False):
    """Convert a binary decision diagram into an expression."""
    if conj:
        outer, inner = (And, Or)
        paths = _iter_all_paths(bdd.node, BDDNODEZERO)
    else:
        outer, inner = (Or, And)
        paths = _iter_all_paths(bdd.node, BDDNODEONE)
    terms = list()
    for path in paths:
        expr_point = {exprvar(v.names, v.indices): val for v, val in path2point(path).items()}
        terms.append(boolfunc.point2term(expr_point, conj))
    return outer(*[inner(*term) for term in terms])
Exemple #4
0
 def expand(self, vs=None, conj=False):
     """Return the Shannon expansion with respect to a list of variables."""
     vs = self._expect_vars(vs)
     if vs:
         outer, inner = (And, Or) if conj else (Or, And)
         terms = [inner(self.restrict(p),
                        *boolfunc.point2term(p, conj))
                  for p in boolfunc.iter_points(vs)]
         if conj:
             terms = [term for term in terms if term is not One]
         else:
             terms = [term for term in terms if term is not Zero]
         return outer(*terms, simplify=False)
     else:
         return self
Exemple #5
0
 def expand(self, vs=None, conj=False):
     """Return the Shannon expansion with respect to a list of variables."""
     vs = self._expect_vars(vs)
     if vs:
         outer, inner = (And, Or) if conj else (Or, And)
         terms = [inner(self.restrict(p),
                        *boolfunc.point2term(p, conj))
                  for p in boolfunc.iter_points(vs)]
         if conj:
             terms = [term for term in terms if term is not One]
         else:
             terms = [term for term in terms if term is not Zero]
         return outer(*terms, simplify=False)
     else:
         return self
Exemple #6
0
def test_point2term():
    assert sorted(point2term({a: 0, b: 0, c: 0, d: 0}, conj=False)) == [~a, ~b, ~c, ~d]
    assert sorted(point2term({a: 1, b: 0, c: 0, d: 0}, conj=False)) == [ a, ~b, ~c, ~d]
    assert sorted(point2term({a: 0, b: 1, c: 0, d: 0}, conj=False)) == [~a,  b, ~c, ~d]
    assert sorted(point2term({a: 1, b: 1, c: 0, d: 0}, conj=False)) == [ a,  b, ~c, ~d]
    assert sorted(point2term({a: 0, b: 0, c: 1, d: 0}, conj=False)) == [~a, ~b,  c, ~d]
    assert sorted(point2term({a: 1, b: 0, c: 1, d: 0}, conj=False)) == [ a, ~b,  c, ~d]
    assert sorted(point2term({a: 0, b: 1, c: 1, d: 0}, conj=False)) == [~a,  b,  c, ~d]
    assert sorted(point2term({a: 1, b: 1, c: 1, d: 0}, conj=False)) == [ a,  b,  c, ~d]
    assert sorted(point2term({a: 0, b: 0, c: 0, d: 1}, conj=False)) == [~a, ~b, ~c,  d]
    assert sorted(point2term({a: 1, b: 0, c: 0, d: 1}, conj=False)) == [ a, ~b, ~c,  d]
    assert sorted(point2term({a: 0, b: 1, c: 0, d: 1}, conj=False)) == [~a,  b, ~c,  d]
    assert sorted(point2term({a: 1, b: 1, c: 0, d: 1}, conj=False)) == [ a,  b, ~c,  d]
    assert sorted(point2term({a: 0, b: 0, c: 1, d: 1}, conj=False)) == [~a, ~b,  c,  d]
    assert sorted(point2term({a: 1, b: 0, c: 1, d: 1}, conj=False)) == [ a, ~b,  c,  d]
    assert sorted(point2term({a: 0, b: 1, c: 1, d: 1}, conj=False)) == [~a,  b,  c,  d]
    assert sorted(point2term({a: 1, b: 1, c: 1, d: 1}, conj=False)) == [ a,  b,  c,  d]

    assert sorted(point2term({a: 0, b: 0, c: 0, d: 0}, conj=True)) == [ a,  b,  c,  d]
    assert sorted(point2term({a: 1, b: 0, c: 0, d: 0}, conj=True)) == [~a,  b,  c,  d]
    assert sorted(point2term({a: 0, b: 1, c: 0, d: 0}, conj=True)) == [ a, ~b,  c,  d]
    assert sorted(point2term({a: 1, b: 1, c: 0, d: 0}, conj=True)) == [~a, ~b,  c,  d]
    assert sorted(point2term({a: 0, b: 0, c: 1, d: 0}, conj=True)) == [ a,  b, ~c,  d]
    assert sorted(point2term({a: 1, b: 0, c: 1, d: 0}, conj=True)) == [~a,  b, ~c,  d]
    assert sorted(point2term({a: 0, b: 1, c: 1, d: 0}, conj=True)) == [ a, ~b, ~c,  d]
    assert sorted(point2term({a: 1, b: 1, c: 1, d: 0}, conj=True)) == [~a, ~b, ~c,  d]
    assert sorted(point2term({a: 0, b: 0, c: 0, d: 1}, conj=True)) == [ a,  b,  c, ~d]
    assert sorted(point2term({a: 1, b: 0, c: 0, d: 1}, conj=True)) == [~a,  b,  c, ~d]
    assert sorted(point2term({a: 0, b: 1, c: 0, d: 1}, conj=True)) == [ a, ~b,  c, ~d]
    assert sorted(point2term({a: 1, b: 1, c: 0, d: 1}, conj=True)) == [~a, ~b,  c, ~d]
    assert sorted(point2term({a: 0, b: 0, c: 1, d: 1}, conj=True)) == [ a,  b, ~c, ~d]
    assert sorted(point2term({a: 1, b: 0, c: 1, d: 1}, conj=True)) == [~a,  b, ~c, ~d]
    assert sorted(point2term({a: 0, b: 1, c: 1, d: 1}, conj=True)) == [ a, ~b, ~c, ~d]
    assert sorted(point2term({a: 1, b: 1, c: 1, d: 1}, conj=True)) == [~a, ~b, ~c, ~d]
Exemple #7
0
def test_point2term():
    assert sorted(point2term({a: 0, b: 0, c: 0, d: 0}, conj=False)) == [~a, ~b, ~c, ~d]
    assert sorted(point2term({a: 1, b: 0, c: 0, d: 0}, conj=False)) == [ a, ~b, ~c, ~d]
    assert sorted(point2term({a: 0, b: 1, c: 0, d: 0}, conj=False)) == [~a,  b, ~c, ~d]
    assert sorted(point2term({a: 1, b: 1, c: 0, d: 0}, conj=False)) == [ a,  b, ~c, ~d]
    assert sorted(point2term({a: 0, b: 0, c: 1, d: 0}, conj=False)) == [~a, ~b,  c, ~d]
    assert sorted(point2term({a: 1, b: 0, c: 1, d: 0}, conj=False)) == [ a, ~b,  c, ~d]
    assert sorted(point2term({a: 0, b: 1, c: 1, d: 0}, conj=False)) == [~a,  b,  c, ~d]
    assert sorted(point2term({a: 1, b: 1, c: 1, d: 0}, conj=False)) == [ a,  b,  c, ~d]
    assert sorted(point2term({a: 0, b: 0, c: 0, d: 1}, conj=False)) == [~a, ~b, ~c,  d]
    assert sorted(point2term({a: 1, b: 0, c: 0, d: 1}, conj=False)) == [ a, ~b, ~c,  d]
    assert sorted(point2term({a: 0, b: 1, c: 0, d: 1}, conj=False)) == [~a,  b, ~c,  d]
    assert sorted(point2term({a: 1, b: 1, c: 0, d: 1}, conj=False)) == [ a,  b, ~c,  d]
    assert sorted(point2term({a: 0, b: 0, c: 1, d: 1}, conj=False)) == [~a, ~b,  c,  d]
    assert sorted(point2term({a: 1, b: 0, c: 1, d: 1}, conj=False)) == [ a, ~b,  c,  d]
    assert sorted(point2term({a: 0, b: 1, c: 1, d: 1}, conj=False)) == [~a,  b,  c,  d]
    assert sorted(point2term({a: 1, b: 1, c: 1, d: 1}, conj=False)) == [ a,  b,  c,  d]

    assert sorted(point2term({a: 0, b: 0, c: 0, d: 0}, conj=True)) == [ a,  b,  c,  d]
    assert sorted(point2term({a: 1, b: 0, c: 0, d: 0}, conj=True)) == [~a,  b,  c,  d]
    assert sorted(point2term({a: 0, b: 1, c: 0, d: 0}, conj=True)) == [ a, ~b,  c,  d]
    assert sorted(point2term({a: 1, b: 1, c: 0, d: 0}, conj=True)) == [~a, ~b,  c,  d]
    assert sorted(point2term({a: 0, b: 0, c: 1, d: 0}, conj=True)) == [ a,  b, ~c,  d]
    assert sorted(point2term({a: 1, b: 0, c: 1, d: 0}, conj=True)) == [~a,  b, ~c,  d]
    assert sorted(point2term({a: 0, b: 1, c: 1, d: 0}, conj=True)) == [ a, ~b, ~c,  d]
    assert sorted(point2term({a: 1, b: 1, c: 1, d: 0}, conj=True)) == [~a, ~b, ~c,  d]
    assert sorted(point2term({a: 0, b: 0, c: 0, d: 1}, conj=True)) == [ a,  b,  c, ~d]
    assert sorted(point2term({a: 1, b: 0, c: 0, d: 1}, conj=True)) == [~a,  b,  c, ~d]
    assert sorted(point2term({a: 0, b: 1, c: 0, d: 1}, conj=True)) == [ a, ~b,  c, ~d]
    assert sorted(point2term({a: 1, b: 1, c: 0, d: 1}, conj=True)) == [~a, ~b,  c, ~d]
    assert sorted(point2term({a: 0, b: 0, c: 1, d: 1}, conj=True)) == [ a,  b, ~c, ~d]
    assert sorted(point2term({a: 1, b: 0, c: 1, d: 1}, conj=True)) == [~a,  b, ~c, ~d]
    assert sorted(point2term({a: 0, b: 1, c: 1, d: 1}, conj=True)) == [ a, ~b, ~c, ~d]
    assert sorted(point2term({a: 1, b: 1, c: 1, d: 1}, conj=True)) == [~a, ~b, ~c, ~d]
Exemple #8
0
def test_point2term():
    assert set(point2term({a: 0, b: 0, c: 0, d: 0}, conj=False)) == {~a, ~b, ~c, ~d}
    assert set(point2term({a: 1, b: 0, c: 0, d: 0}, conj=False)) == { a, ~b, ~c, ~d}
    assert set(point2term({a: 0, b: 1, c: 0, d: 0}, conj=False)) == {~a,  b, ~c, ~d}
    assert set(point2term({a: 1, b: 1, c: 0, d: 0}, conj=False)) == { a,  b, ~c, ~d}
    assert set(point2term({a: 0, b: 0, c: 1, d: 0}, conj=False)) == {~a, ~b,  c, ~d}
    assert set(point2term({a: 1, b: 0, c: 1, d: 0}, conj=False)) == { a, ~b,  c, ~d}
    assert set(point2term({a: 0, b: 1, c: 1, d: 0}, conj=False)) == {~a,  b,  c, ~d}
    assert set(point2term({a: 1, b: 1, c: 1, d: 0}, conj=False)) == { a,  b,  c, ~d}
    assert set(point2term({a: 0, b: 0, c: 0, d: 1}, conj=False)) == {~a, ~b, ~c,  d}
    assert set(point2term({a: 1, b: 0, c: 0, d: 1}, conj=False)) == { a, ~b, ~c,  d}
    assert set(point2term({a: 0, b: 1, c: 0, d: 1}, conj=False)) == {~a,  b, ~c,  d}
    assert set(point2term({a: 1, b: 1, c: 0, d: 1}, conj=False)) == { a,  b, ~c,  d}
    assert set(point2term({a: 0, b: 0, c: 1, d: 1}, conj=False)) == {~a, ~b,  c,  d}
    assert set(point2term({a: 1, b: 0, c: 1, d: 1}, conj=False)) == { a, ~b,  c,  d}
    assert set(point2term({a: 0, b: 1, c: 1, d: 1}, conj=False)) == {~a,  b,  c,  d}
    assert set(point2term({a: 1, b: 1, c: 1, d: 1}, conj=False)) == { a,  b,  c,  d}

    assert set(point2term({a: 0, b: 0, c: 0, d: 0}, conj=True)) == { a,  b,  c,  d}
    assert set(point2term({a: 1, b: 0, c: 0, d: 0}, conj=True)) == {~a,  b,  c,  d}
    assert set(point2term({a: 0, b: 1, c: 0, d: 0}, conj=True)) == { a, ~b,  c,  d}
    assert set(point2term({a: 1, b: 1, c: 0, d: 0}, conj=True)) == {~a, ~b,  c,  d}
    assert set(point2term({a: 0, b: 0, c: 1, d: 0}, conj=True)) == { a,  b, ~c,  d}
    assert set(point2term({a: 1, b: 0, c: 1, d: 0}, conj=True)) == {~a,  b, ~c,  d}
    assert set(point2term({a: 0, b: 1, c: 1, d: 0}, conj=True)) == { a, ~b, ~c,  d}
    assert set(point2term({a: 1, b: 1, c: 1, d: 0}, conj=True)) == {~a, ~b, ~c,  d}
    assert set(point2term({a: 0, b: 0, c: 0, d: 1}, conj=True)) == { a,  b,  c, ~d}
    assert set(point2term({a: 1, b: 0, c: 0, d: 1}, conj=True)) == {~a,  b,  c, ~d}
    assert set(point2term({a: 0, b: 1, c: 0, d: 1}, conj=True)) == { a, ~b,  c, ~d}
    assert set(point2term({a: 1, b: 1, c: 0, d: 1}, conj=True)) == {~a, ~b,  c, ~d}
    assert set(point2term({a: 0, b: 0, c: 1, d: 1}, conj=True)) == { a,  b, ~c, ~d}
    assert set(point2term({a: 1, b: 0, c: 1, d: 1}, conj=True)) == {~a,  b, ~c, ~d}
    assert set(point2term({a: 0, b: 1, c: 1, d: 1}, conj=True)) == { a, ~b, ~c, ~d}
    assert set(point2term({a: 1, b: 1, c: 1, d: 1}, conj=True)) == {~a, ~b, ~c, ~d}
Exemple #9
0
def test_point2term():
    assert sorted(point2term({a: 0, b: 0, c: 0, d: 0}, conj=False)) == [-a, -b, -c, -d]
    assert sorted(point2term({a: 1, b: 0, c: 0, d: 0}, conj=False)) == [ a, -b, -c, -d]
    assert sorted(point2term({a: 0, b: 1, c: 0, d: 0}, conj=False)) == [-a,  b, -c, -d]
    assert sorted(point2term({a: 1, b: 1, c: 0, d: 0}, conj=False)) == [ a,  b, -c, -d]
    assert sorted(point2term({a: 0, b: 0, c: 1, d: 0}, conj=False)) == [-a, -b,  c, -d]
    assert sorted(point2term({a: 1, b: 0, c: 1, d: 0}, conj=False)) == [ a, -b,  c, -d]
    assert sorted(point2term({a: 0, b: 1, c: 1, d: 0}, conj=False)) == [-a,  b,  c, -d]
    assert sorted(point2term({a: 1, b: 1, c: 1, d: 0}, conj=False)) == [ a,  b,  c, -d]
    assert sorted(point2term({a: 0, b: 0, c: 0, d: 1}, conj=False)) == [-a, -b, -c,  d]
    assert sorted(point2term({a: 1, b: 0, c: 0, d: 1}, conj=False)) == [ a, -b, -c,  d]
    assert sorted(point2term({a: 0, b: 1, c: 0, d: 1}, conj=False)) == [-a,  b, -c,  d]
    assert sorted(point2term({a: 1, b: 1, c: 0, d: 1}, conj=False)) == [ a,  b, -c,  d]
    assert sorted(point2term({a: 0, b: 0, c: 1, d: 1}, conj=False)) == [-a, -b,  c,  d]
    assert sorted(point2term({a: 1, b: 0, c: 1, d: 1}, conj=False)) == [ a, -b,  c,  d]
    assert sorted(point2term({a: 0, b: 1, c: 1, d: 1}, conj=False)) == [-a,  b,  c,  d]
    assert sorted(point2term({a: 1, b: 1, c: 1, d: 1}, conj=False)) == [ a,  b,  c,  d]

    assert sorted(point2term({a: 0, b: 0, c: 0, d: 0}, conj=True)) == [ a,  b,  c,  d]
    assert sorted(point2term({a: 1, b: 0, c: 0, d: 0}, conj=True)) == [-a,  b,  c,  d]
    assert sorted(point2term({a: 0, b: 1, c: 0, d: 0}, conj=True)) == [ a, -b,  c,  d]
    assert sorted(point2term({a: 1, b: 1, c: 0, d: 0}, conj=True)) == [-a, -b,  c,  d]
    assert sorted(point2term({a: 0, b: 0, c: 1, d: 0}, conj=True)) == [ a,  b, -c,  d]
    assert sorted(point2term({a: 1, b: 0, c: 1, d: 0}, conj=True)) == [-a,  b, -c,  d]
    assert sorted(point2term({a: 0, b: 1, c: 1, d: 0}, conj=True)) == [ a, -b, -c,  d]
    assert sorted(point2term({a: 1, b: 1, c: 1, d: 0}, conj=True)) == [-a, -b, -c,  d]
    assert sorted(point2term({a: 0, b: 0, c: 0, d: 1}, conj=True)) == [ a,  b,  c, -d]
    assert sorted(point2term({a: 1, b: 0, c: 0, d: 1}, conj=True)) == [-a,  b,  c, -d]
    assert sorted(point2term({a: 0, b: 1, c: 0, d: 1}, conj=True)) == [ a, -b,  c, -d]
    assert sorted(point2term({a: 1, b: 1, c: 0, d: 1}, conj=True)) == [-a, -b,  c, -d]
    assert sorted(point2term({a: 0, b: 0, c: 1, d: 1}, conj=True)) == [ a,  b, -c, -d]
    assert sorted(point2term({a: 1, b: 0, c: 1, d: 1}, conj=True)) == [-a,  b, -c, -d]
    assert sorted(point2term({a: 0, b: 1, c: 1, d: 1}, conj=True)) == [ a, -b, -c, -d]
    assert sorted(point2term({a: 1, b: 1, c: 1, d: 1}, conj=True)) == [-a, -b, -c, -d]