BDD

java.lang.Object
- jdd.bdd.NodeTable
- - jdd.bdd.BDD

Direct Known Subclasses:

Adder, BDDQueens, BDDUniverse, DebugBDD, ProfiledBDD, ProfiledBDD2
```
public class BDD
extends NodeTable
```
BDD main class. All BDD code uses this .
This is not a "bdd tree" or "bdd node", but the Java objects that handles _ALL_ BDD operations for a given universe.
For power-users only:
1. meta-developers writing their own decision-diagrams should override NodeTabe instead.
2. you can tweak BDD internal heuristics by changing the values in Configuration.

See Also:

NodeTable, Configuration

Field Summary

Fields
Modifier and Type	Field and Description
`protected static int`	`CACHE_AND` for the OP cache
`protected static int`	`CACHE_BIIMP` for the OP cache
`protected static int`	`CACHE_EXISTS` for the quant cache
`protected static int`	`CACHE_FORALL` for the quant cache
`protected static int`	`CACHE_IMP`
`protected static int`	`CACHE_NAND`
`protected static int`	`CACHE_NOR`
`protected static int`	`CACHE_OR` for the OP cache
`protected static int`	`CACHE_RESTRICT`
`protected static int`	`CACHE_XOR` for the OP cache
`protected SimpleCache`	`ite_cache`
`protected int`	`last_sat_vars`
`protected NodeName`	`nodeNames`
`protected SimpleCache`	`not_cache`
`protected int`	`num_vars`
`protected int[]`	`oneSat_buffer`
`protected SimpleCache`	`op_cache`
`protected SimpleCache`	`quant_cache`
`protected boolean`	`quant_conj`
`protected int`	`quant_cube`
`protected int`	`quant_id`
`protected SimpleCache`	`relprod_cache`
`protected SimpleCache`	`replace_cache`
`protected int`	`restrict_careset`
`protected DoubleCache`	`sat_cache`
`protected boolean[]`	`sign_vec`
`protected int`	`varset_last`
`protected boolean[]`	`varset_vec`

Fields inherited from class jdd.bdd.NodeTable
dead_nodes, ht_chain, mark_stack, NODE_MARK, NODE_UNMARK, nodesminfree, stat_gc_count, stat_gc_freed, stat_gc_time, stat_grow_time, stat_lookup_count, stat_notify_time, stat_nt_grow, table_size, work_stack, work_stack_tos

Constructor Summary

Constructors
Constructor and Description
`BDD(int nodesize)` create a BDD manager with initially `nodesize` nodes.
`BDD(int nodesize, int cache_size)` create a BDD manager with initially `nodesize` nodes and `cache_size` cache elements.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`and(int u1, int u2)` binary AND.
`int`	`andTo(int bdd1, int bdd2)` the operation bdd1 &= bdd2; is equal to bdd1 = andTo(bdd1, bdd2); this operation also handles the ref-counting
`int`	`biimp(int u1, int u2)` binary BI-IMPLICATION (double implication, equivalence, whatever...).
`void`	`cleanup()` this function is called at exit, cleans up and frees allocated memory
`Permutation`	`createPermutation(int[] cube_from, int[] cube_to)` create a Permutation vector for a given variable permutation. A permutation is used by `replace` to re-label nodes in a BDD. NOTE: the from and to-cubes must not overlap!
`int`	`createVar()` create a new BDD variable
`int`	`cube(boolean[] v)` create a bdd cube, which is simply a conjunction of a set of variables. given a list of variables v[], it vill return v[0] AND v[1] AND ....
`int`	`cube(String s)` developement code, do not use! a cube over a set of variables represented as a mintem.
`int`	`exists(int bdd, int cube)` binary EXISTS, existential quantification. Let exists(bdd, variable) to be bdd(variable) OR bdd(NOT variable).
`int`	`forall(int bdd, int cube)` binary FOR-ALL, universal quantification. Let forall(bdd, variable) to be bdd(variable) AND bdd(NOT variable).
`long`	`getMemoryUsage()`
`int`	`getOne()` the symbolic ONE
`int`	`getZero()` the symbolic ZERO
`int`	`imp(int u1, int u2)` binary implication.
`static void`	`internal_test()` testbench.
`boolean`	`isVariable(int bdd)` Is this BDD tree a BDD Variable?
`int`	`ite(int f, int then_, int else_)` this is the `If-Then-Else` BDD function. it can be used to (inefficiently) simulate and binary operation. (i think it is described in the "Long" paper).
`boolean`	`member(int bdd, boolean[] minterm)` returns true if the given minterm is a included in the bdd.
`int`	`minterm(boolean[] v)` returns an unary minterm based on a vector of boolean assignments. for example minterm([true, false]) will return NOT v1 and v2.
`int`	`minterm(String s)` developement code, do not use! returns a unary minterm based on a vector of boolean assignments. for example minterm([true, false]) will return NOT v1 and v2.
`int`	`mk(int i, int l, int h)` mk operator as defined in Andersens lecture notes
`int`	`nand(int u1, int u2)` binary NAND.
`int`	`nodeCount(int bdd)` compute the number of nodes in the tree (this function is currently somewhat slow)
`int`	`nor(int u1, int u2)` binary NOR.
`int`	`not(int u1)` binary NOT.
`int`	`numberOfVariables()` how many BDD variables do we have ??
`protected void`	`oneSat_rec(int bdd)`
`int`	`oneSat(int bdd)` return a satisfying assignment for this BDD as a unary cube.
`int[]`	`oneSat(int bdd, int[] buffer)` oneSat(bdd, buffer) returns an int vector x where x[i] is 0/1 or -1 for neg cofactor/pos cofactor and dont care if buffer is null, a new vector is created otherwise buffer is used an returned
`int`	`or(int u1, int u2)` binary OR.
`int`	`orTo(int bdd1, int bdd2)` the operation bdd1 \|= bdd2; is equal to bdd1 = orTo(bdd1, bdd2); this operation also handles the ref-counting
`protected void`	`post_removal_callbak()` this function is called after the garbage collector hash changed some internal data.
`void`	`print(int bdd)` printthis BDD to console (prints internal structure)
`void`	`printCubes(int bdd)` print the cubes (true assignment) for the minterms in this BDD
`void`	`printDot(String fil, int bdd)` creates a DOT file for this BDD and convert to an image using DOT
`void`	`printSet(int bdd)` possibly using dont-cares, print satisfying assignment od this BDD
`int`	`quasiReducedNodeCount(int bdd)` faster nodeCount, but doesn't take the shared child-trees into account
`int`	`relProd(int u1, int u2, int c)` This is the relational-product of Clarke et al.. It combines a conjunction and existential quantification that is often seen in image computation: EXISTS c.
`int`	`replace(int bdd, Permutation perm)` Given a permutation, this function will re-label (some) nodes in a BDD to associate with a new sets of variables.
`int`	`restrict(int u, int v)` The BDD restrict operation.
`protected double`	`satCount_rec(int bdd)`
`double`	`satCount(int bdd)` returns the number of satisfying assignments for this BDD.
`void`	`setNodeNames(NodeName nn)` Change the default node-naming procedure, for advanced users only!
`void`	`showStats()` show some statistics ...
`int`	`simplify(int d, int u)` The BDD simplification operation.
`int`	`support(int bdd)` returns the support set of a variable, that is a cube C where each of its variables are used somewhere in the ibpu bdd.
`int`	`xor(int u1, int u2)` binary XOR.

Methods inherited from class jdd.bdd.NodeTable
add, addDebugger, check_all_nodes, check_node, countRootNodes, deref, enableStackMarking, gc, getHigh, getLow, getRef, getVar, getVarUnmasked, grow, invalidate, isNodeMarked, isValid, mark_node, mark_tree, match_table, ref, saturate, setAll, setAll, show_table_all, show_table, show_tuple, signal_removed, tree_depth_changed, unmark_node, unmark_tree, update_grow_parameters

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - CACHE_AND
```
protected static final int CACHE_AND
```
    for the OP cache
    
    See Also:
    
    Constant Field Values
  - CACHE_OR
```
protected static final int CACHE_OR
```
    for the OP cache
    
    See Also:
    
    Constant Field Values
  - CACHE_XOR
```
protected static final int CACHE_XOR
```
    for the OP cache
    
    See Also:
    
    Constant Field Values
  - CACHE_BIIMP
```
protected static final int CACHE_BIIMP
```
    for the OP cache
    
    See Also:
    
    Constant Field Values
  - CACHE_IMP
```
protected static final int CACHE_IMP
```
    See Also:
    
    Constant Field Values
  - CACHE_NAND
```
protected static final int CACHE_NAND
```
    See Also:
    
    Constant Field Values
  - CACHE_NOR
```
protected static final int CACHE_NOR
```
    See Also:
    
    Constant Field Values
  - CACHE_RESTRICT
```
protected static final int CACHE_RESTRICT
```
    See Also:
    
    Constant Field Values
  - CACHE_EXISTS
```
protected static final int CACHE_EXISTS
```
    for the quant cache
    
    See Also:
    
    Constant Field Values
  - CACHE_FORALL
```
protected static final int CACHE_FORALL
```
    for the quant cache
    
    See Also:
    
    Constant Field Values
  - num_vars
```
protected int num_vars
```
  - last_sat_vars
```
protected int last_sat_vars
```
  - op_cache
```
protected SimpleCache op_cache
```
  - relprod_cache
```
protected SimpleCache relprod_cache
```
  - not_cache
```
protected SimpleCache not_cache
```
  - ite_cache
```
protected SimpleCache ite_cache
```
  - quant_cache
```
protected SimpleCache quant_cache
```
  - replace_cache
```
protected SimpleCache replace_cache
```
  - sat_cache
```
protected DoubleCache sat_cache
```
  - varset_vec
```
protected boolean[] varset_vec
```
  - sign_vec
```
protected boolean[] sign_vec
```
  - oneSat_buffer
```
protected int[] oneSat_buffer
```
  - varset_last
```
protected int varset_last
```
  - quant_id
```
protected int quant_id
```
  - quant_cube
```
protected int quant_cube
```
  - restrict_careset
```
protected int restrict_careset
```
  - quant_conj
```
protected boolean quant_conj
```
  - nodeNames
```
protected NodeName nodeNames
```
- Constructor Detail
  - BDD
```
public BDD(int nodesize)
```
    create a BDD manager with initially nodesize nodes.
  - BDD
```
public BDD(int nodesize,
           int cache_size)
```
    create a BDD manager with initially nodesize nodes and cache_size cache elements.
- Method Detail
  - cleanup
```
public void cleanup()
```
    this function is called at exit, cleans up and frees allocated memory
    
    Overrides:
    
    cleanup in class NodeTable
  - getOne
```
public final int getOne()
```
    the symbolic ONE
  - getZero
```
public final int getZero()
```
    the symbolic ZERO
  - numberOfVariables
```
public int numberOfVariables()
```
    how many BDD variables do we have ??
  - createVar
```
public int createVar()
```
    create a new BDD variable
  - post_removal_callbak
```
protected void post_removal_callbak()
```
    this function is called after the garbage collector hash changed some internal data. when we get here, data structures such as caches are instable, so we have to clean up after the garbage collector.
    
    Overrides:
    
    post_removal_callbak in class NodeTable
  - mk
```
public int mk(int i,
              int l,
              int h)
```
    mk operator as defined in Andersens lecture notes
  - cube
```
public final int cube(boolean[] v)
```
    create a bdd cube, which is simply a conjunction of a set of variables.
    
    given a list of variables v[], it vill return v[0] AND v[1] AND .... this cube is then used in operations such as exists and forall
    
    See Also:
    
    exists(int, int), forall(int, int)
  - cube
```
public final int cube(String s)
```
    developement code, do not use!
    a cube over a set of variables represented as a mintem. for example the string "11-1" over four variables will return the cube v1 AND v3 AND v4.
    
    See Also:
    
    cube(boolean[])
  - minterm
```
public final int minterm(boolean[] v)
```
    returns an unary minterm based on a vector of boolean assignments.
    for example minterm([true, false]) will return NOT v1 and v2.
    
    See Also:
    
    minterm(boolean[])
  - minterm
```
public final int minterm(String s)
```
    developement code, do not use!
    returns a unary minterm based on a vector of boolean assignments.
    for example minterm([true, false]) will return NOT v1 and v2.
    
    See Also:
    
    minterm(boolean[])
  - ite
```
public int ite(int f,
               int then_,
               int else_)
```
    this is the If-Then-Else BDD function.
    
    it can be used to (inefficiently) simulate and binary operation.
    (i think it is described in the "Long" paper).
    
    Returns:
    
    (f AND then_) OR (NOT f AND else_)
  - and
```
public int and(int u1,
               int u2)
```
    binary AND.
    
    Returns:
    
    u1 AND u2
    
    See Also:
    
    or(int, int)
  - nand
```
public int nand(int u1,
                int u2)
```
    binary NAND.
    
    Returns:
    
    u1 NAND u2
    
    See Also:
    
    nor(int, int)
  - or
```
public int or(int u1,
              int u2)
```
    binary OR.
    
    Returns:
    
    u1 OR u2
    
    See Also:
    
    and(int, int)
  - nor
```
public int nor(int u1,
               int u2)
```
    binary NOR.
    
    Returns:
    
    u1 NOR u2
    
    See Also:
    
    nand(int, int)
  - xor
```
public int xor(int u1,
               int u2)
```
    binary XOR.
    
    Returns:
    
    u1 XOR u2
    
    See Also:
    
    biimp(int, int)
  - biimp
```
public int biimp(int u1,
                 int u2)
```
    binary BI-IMPLICATION (double implication, equivalence, whatever...).
    
    Returns:
    
    (u1 <--> u2)
    
    See Also:
    
    xor(int, int)
  - imp
```
public int imp(int u1,
               int u2)
```
    binary implication.
    
    Returns:
    
    u1 -> u2
  - not
```
public int not(int u1)
```
    binary NOT.
    
    Returns:
    
    NOT u1
  - exists
```
public int exists(int bdd,
                  int cube)
```
    binary EXISTS, existential quantification.
    Let exists(bdd, variable) to be bdd(variable) OR bdd(NOT variable). Then exists(bdd, cube) does this for every (combination of) variable in the cube.
    
    Note that all references of variable and the variables in cube will be removed from the resulting bdd.
    
    See Also:
    
    forall(int, int)
  - forall
```
public int forall(int bdd,
                  int cube)
```
    binary FOR-ALL, universal quantification.
    Let forall(bdd, variable) to be bdd(variable) AND bdd(NOT variable). Then foral(bdd, cube) does this for every (combination of) variable in the cube.
    
    Note that all references of variable and the variables in cube will be removed from the resulting bdd.
    
    See Also:
    
    exists(int, int)
  - relProd
```
public int relProd(int u1,
                   int u2,
                   int c)
```
    This is the relational-product of Clarke et al..
    It combines a conjunction and existential quantification that is often seen in image computation:
    EXISTS c. (u1 AND u2)
    
    Use this operation for better runtime performance!
  - createPermutation
```
public Permutation createPermutation(int[] cube_from,
                                     int[] cube_to)
```
    create a Permutation vector for a given variable permutation.
    A permutation is used by replace to re-label nodes in a BDD.
    
    NOTE: the from and to-cubes must not overlap!
    
    See Also:
    
    Permutation, replace(int, jdd.bdd.Permutation)
  - replace
```
public int replace(int bdd,
                   Permutation perm)
```
    Given a permutation, this function will re-label (some) nodes in a BDD to associate with a new sets of variables.
    
    See Also:
    
    Permutation, createPermutation(int[], int[])
  - restrict
```
public int restrict(int u,
                    int v)
```
    The BDD restrict operation. Tries to minimize the size of a BDD by using dont-cares. For more details, check out "A unified framework for the formal verification of circuits, by Coudert and Madre.
    
    See Also:
    
    simplify(int, int)
  - simplify
```
public int simplify(int d,
                    int u)
```
    The BDD simplification operation. Work like the restrict operation.
    
    . Check out Andersens BDD lecture notes for detailed information on this one. XXX: we have no cache for it yet!
    
    See Also:
    
    restrict(int, int)
  - isVariable
```
public boolean isVariable(int bdd)
```
    Is this BDD tree a BDD Variable?
    
    Returns:
    
    true if the BDD is representing a variable.
  - satCount
```
public double satCount(int bdd)
```
    returns the number of satisfying assignments for this BDD. beware of possible floating-point overflow here!
    Important note: this works becuase getVar() returns "numbers of variables plus one" for the terminal nodes!
  - satCount_rec
```
protected double satCount_rec(int bdd)
```
  - nodeCount
```
public int nodeCount(int bdd)
```
    compute the number of nodes in the tree (this function is currently somewhat slow)
  - quasiReducedNodeCount
```
public final int quasiReducedNodeCount(int bdd)
```
    faster nodeCount, but doesn't take the shared child-trees into account
  - oneSat
```
public int oneSat(int bdd)
```
    return a satisfying assignment for this BDD as a unary cube. bdd may not be the constant ONE or ZERO.
  - oneSat
```
public int[] oneSat(int bdd,
                    int[] buffer)
```
```
 oneSat(bdd, buffer) returns an int vector
 x where x[i] is 0/1 or -1 for neg cofactor/pos cofactor and dont care
 if buffer is null, a new vector is created otherwise  buffer is used an returned 
```
  - oneSat_rec
```
protected void oneSat_rec(int bdd)
```
  - support
```
public int support(int bdd)
```
```
 returns the support set of a variable, that is a cube C where each of its variables
 are used somewhere in the ibpu bdd.
```
  - member
```
public boolean member(int bdd,
                      boolean[] minterm)
```
    returns true if the given minterm is a included in the bdd. Note: This method is far far more efficient than computing the "minterm" as BDD, then OR it to "bdd" and see if the result is not equal to "bdd"!
  - orTo
```
public int orTo(int bdd1,
                int bdd2)
```
    the operation bdd1 |= bdd2; is equal to bdd1 = orTo(bdd1, bdd2);
    this operation also handles the ref-counting
  - andTo
```
public int andTo(int bdd1,
                 int bdd2)
```
    the operation bdd1 &= bdd2; is equal to bdd1 = andTo(bdd1, bdd2);
    this operation also handles the ref-counting
  - showStats
```
public void showStats()
```
    Description copied from class: NodeTable
    
    show some statistics ...
    
    Overrides:
    
    showStats in class NodeTable
  - getMemoryUsage
```
public long getMemoryUsage()
```
    Overrides:
    
    getMemoryUsage in class NodeTable
  - print
```
public void print(int bdd)
```
    printthis BDD to console (prints internal structure)
  - printDot
```
public void printDot(String fil,
                     int bdd)
```
    creates a DOT file for this BDD and convert to an image using DOT
  - printSet
```
public void printSet(int bdd)
```
    possibly using dont-cares, print satisfying assignment od this BDD
  - printCubes
```
public void printCubes(int bdd)
```
    print the cubes (true assignment) for the minterms in this BDD
  - setNodeNames
```
public void setNodeNames(NodeName nn)
```
    Change the default node-naming procedure, for advanced users only!
    
    See Also:
    
    NodeName
  - internal_test
```
public static void internal_test()
```
    testbench. do not call

Class BDD

Field Summary

Fields inherited from class jdd.bdd.NodeTable

Constructor Summary

Method Summary

Methods inherited from class jdd.bdd.NodeTable

Methods inherited from class java.lang.Object

Field Detail

CACHE_AND

CACHE_OR

CACHE_XOR

CACHE_BIIMP

CACHE_IMP

CACHE_NAND

CACHE_NOR

CACHE_RESTRICT

CACHE_EXISTS

CACHE_FORALL

num_vars

last_sat_vars

op_cache

relprod_cache

not_cache

ite_cache

quant_cache

replace_cache

sat_cache

varset_vec

sign_vec

oneSat_buffer

varset_last

quant_id

quant_cube

restrict_careset

quant_conj

nodeNames

Constructor Detail

BDD

BDD

Method Detail

cleanup

getOne

getZero

numberOfVariables

createVar

post_removal_callbak

mk

cube

cube

minterm

minterm

ite

and

nand

or

nor

xor

biimp

imp

not

exists

forall

relProd

createPermutation

replace

restrict

simplify

isVariable

satCount

satCount_rec

nodeCount

quasiReducedNodeCount

oneSat

oneSat

oneSat_rec

support

member

orTo

andTo

showStats