a modern C++ library for the manipulation of Boolean functions

algorithm and write that a node is created, we will leave the fact that we are calling
make_node (thus applying the third reduction rule) implicit.
3.1.4 Caches
CORAL keeps associative caches for most of its ROBDD operations. We will not give a
list here as their names are easily identifiable by the Cache suffix in the source code. For
simplicity we will not mention them in the pseudo-codes.
3.2 ROBDD algorithms
3.2.1 Memory management
CORAL’s class ROBDD does not distinguish a ROBDD from its root node and uses its own
customized mechanisms for the allocation of ROBDD nodes. ROBDD is derived from the
Reference_Counted_Object class in order for ROBDDs to be reference counted, which
means that each ROBDD is normally deallocated (by a garbage collection algorithm)
only after there are no more references to it. The end user, in fact, does not use ROBDD
directly: instead he utilizes the ROBDD_Ptr class, which is nothing more than a wrapper
for a ROBDD pointer that also automatically adjusts reference counters of ROBDDs
whenever the underlying pointer is changed.
All ROBDD nodes allocated by CORAL are kept inside an array with variable length,
which is formed by a certain number of memory chunks. CORAL counts the number
of allocated chunks and will throw an exception of type Too_Many_BDD_Nodes
if it exceeds MAX_CHUNKS_BEFORE_EXCEPTION and the public Boolean static member
ROBDD::dont_throw is set to false, which means that setting this latter value to false allows
the end user to be notified when the memory occupation of ROBDDs is becoming too
large. In this case, the normal behavior consists of calling ROBDD::emergency_cleanup()
after catching the expression in order to regain some memory.
3.2.2 Algorithms with upward approximation
Algorithms with upward approximation, characterized by the substring up in their names,
can be used on large ROBDDs in order to obtain more efficiency at the expense of
some precision in the result. Each Boolean function g such that f =⇒ g is an upward
approximation of function f. These algorithms return an upward approximation of the
result by trying to perform their corresponding non-approximated algorithm and checking
if it throws Too_Many_BDD_Nodes: if the exception is not thrown then the exact result is
returned, otherwise we return an upward approximation for it. For example the and_up
operator, which is the upward approximation version of the conjunction operator and_ite,
approximates f ∧ g with f when Too_Many_BDD_Nodes is thrown; its implementation is
shown in Listing 3.1.
3.2 ROBDD algorithms 12