/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_MinHammingDist.]
Description [Performs the recursive step of Cudd_MinHammingDist.
It is based on the following identity. Let H(f) be the
minimum Hamming distance of the minterms of f from the reference
minterm. Then:
<xmp>
H(f) = min(H(f0)+h0,H(f1)+h1)
</xmp>
where f0 and f1 are the two cofactors of f with respect to its top
variable; h0 is 1 if the minterm assigns 1 to the top variable of f;
h1 is 1 if the minterm assigns 0 to the top variable of f.
The upper bound on the distance is used to bound the depth of the
recursion.
Returns the minimum distance unless it exceeds the upper bound or
computation fails.]
SideEffects [None]
SeeAlso [Cudd_MinHammingDist]
******************************************************************************/
static int
cuddMinHammingDistRecur(
DdNode * f,
int *minterm,
DdHashTable * table,
int upperBound)
{
DdNode *F, *Ft, *Fe;
double h, hT, hE;
DdNode *zero, *res;
DdManager *dd = table->manager;
statLine(dd);
if (upperBound == 0) return(0);
F = Cudd_Regular(f);
if (cuddIsConstant(F)) {
zero = Cudd_Not(DD_ONE(dd));
if (f == dd->background || f == zero) {
return(upperBound);
} else {
return(0);
}
}
if ((res = cuddHashTableLookup1(table,f)) != NULL) {
//Rob Apr 6 2001: might need to change this, not sure what it does.....
h = (*cuddV(res)).get_val();
if (res->ref == 0) {
dd->dead++;
dd->constants.dead++;
}
return((int) h);
}
Ft = cuddT(F); Fe = cuddE(F);
if (Cudd_IsComplement(f)) {
Ft = Cudd_Not(Ft); Fe = Cudd_Not(Fe);
}
if (minterm[F->index] == 0) {
DdNode *temp = Ft;
Ft = Fe; Fe = temp;
}
hT = cuddMinHammingDistRecur(Ft,minterm,table,upperBound);
if (hT == CUDD_OUT_OF_MEM) return(CUDD_OUT_OF_MEM);
if (hT == 0) {
hE = upperBound;
} else {
hE = cuddMinHammingDistRecur(Fe,minterm,table,upperBound - 1);
if (hE == CUDD_OUT_OF_MEM) return(CUDD_OUT_OF_MEM);
}
h = ddMin(hT, hE + 1);
if (F->ref != 1) {
ptrint fanout = (ptrint) F->ref;
cuddSatDec(fanout);
Terminal hTerminal;
hTerminal.set((double) h);
res = cuddUniqueConst(dd,&hTerminal);
//res = cuddUniqueConst(dd, (CUDD_VALUE_TYPE) h);
if (!cuddHashTableInsert1(table,f,res,fanout)) {
cuddRef(res); Cudd_RecursiveDeref(dd, res);
return(CUDD_OUT_OF_MEM);
}
}
return((int) h);
} /* end of cuddMinHammingDistRecur */
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_bddVectorCompose.]
Description []
SideEffects [None]
SeeAlso []
******************************************************************************/
static DdNode *
cuddBddVectorComposeRecur(
DdManager * dd /* DD manager */,
DdHashTable * table /* computed table */,
DdNode * f /* BDD in which to compose */,
DdNode ** vector /* functions to be composed */,
int deepest /* depth of the deepest substitution */)
{
DdNode *F,*T,*E;
DdNode *res;
statLine(dd);
F = Cudd_Regular(f);
/* If we are past the deepest substitution, return f. */
if (cuddI(dd,F->index) > deepest) {
return(f);
}
/* If problem already solved, look up answer and return. */
if ((res = cuddHashTableLookup1(table,F)) != NULL) {
#ifdef DD_DEBUG
bddVectorComposeHits++;
#endif
return(Cudd_NotCond(res,F != f));
}
/* Split and recur on children of this node. */
T = cuddBddVectorComposeRecur(dd,table,cuddT(F),vector, deepest);
if (T == NULL) return(NULL);
cuddRef(T);
E = cuddBddVectorComposeRecur(dd,table,cuddE(F),vector, deepest);
if (E == NULL) {
Cudd_IterDerefBdd(dd, T);
return(NULL);
}
cuddRef(E);
/* Call cuddBddIteRecur with the BDD that replaces the current top
** variable and the T and E we just created.
*/
res = cuddBddIteRecur(dd,vector[F->index],T,E);
if (res == NULL) {
Cudd_IterDerefBdd(dd, T);
Cudd_IterDerefBdd(dd, E);
return(NULL);
}
cuddRef(res);
Cudd_IterDerefBdd(dd, T);
Cudd_IterDerefBdd(dd, E);
/* Do not keep the result if the reference count is only 1, since
** it will not be visited again.
*/
if (F->ref != 1) {
ptrint fanout = (ptrint) F->ref;
cuddSatDec(fanout);
if (!cuddHashTableInsert1(table,F,res,fanout)) {
Cudd_IterDerefBdd(dd, res);
return(NULL);
}
}
cuddDeref(res);
return(Cudd_NotCond(res,F != f));
} /* end of cuddBddVectorComposeRecur */
/**Function********************************************************************
Synopsis [Implements the recursive step of Cudd_bddPermute.]
Description [ Recursively puts the BDD in the order given in the array permut.
Checks for trivial cases to terminate recursion, then splits on the
children of this node. Once the solutions for the children are
obtained, it puts into the current position the node from the rest of
the BDD that should be here. Then returns this BDD.
The key here is that the node being visited is NOT put in its proper
place by this instance, but rather is switched when its proper position
is reached in the recursion tree.<p>
The DdNode * that is returned is the same BDD as passed in as node,
but in the new order.]
SideEffects [None]
SeeAlso [Cudd_bddPermute cuddAddPermuteRecur]
******************************************************************************/
static DdNode *
cuddBddPermuteRecur(
DdManager * manager /* DD manager */,
DdHashTable * table /* computed table */,
DdNode * node /* BDD to be reordered */,
int * permut /* permutation array */)
{
DdNode *N,*T,*E;
DdNode *res;
int index;
statLine(manager);
N = Cudd_Regular(node);
/* Check for terminal case of constant node. */
if (cuddIsConstant(N)) {
return(node);
}
/* If problem already solved, look up answer and return. */
if (N->ref != 1 && (res = cuddHashTableLookup1(table,N)) != NULL) {
#ifdef DD_DEBUG
bddPermuteRecurHits++;
#endif
return(Cudd_NotCond(res,N != node));
}
/* Split and recur on children of this node. */
T = cuddBddPermuteRecur(manager,table,cuddT(N),permut);
if (T == NULL) return(NULL);
cuddRef(T);
E = cuddBddPermuteRecur(manager,table,cuddE(N),permut);
if (E == NULL) {
Cudd_IterDerefBdd(manager, T);
return(NULL);
}
cuddRef(E);
/* Move variable that should be in this position to this position
** by retrieving the single var BDD for that variable, and calling
** cuddBddIteRecur with the T and E we just created.
*/
index = permut[N->index];
res = cuddBddIteRecur(manager,manager->vars[index],T,E);
if (res == NULL) {
Cudd_IterDerefBdd(manager, T);
Cudd_IterDerefBdd(manager, E);
return(NULL);
}
cuddRef(res);
Cudd_IterDerefBdd(manager, T);
Cudd_IterDerefBdd(manager, E);
/* Do not keep the result if the reference count is only 1, since
** it will not be visited again.
*/
if (N->ref != 1) {
ptrint fanout = (ptrint) N->ref;
cuddSatDec(fanout);
if (!cuddHashTableInsert1(table,N,res,fanout)) {
Cudd_IterDerefBdd(manager, res);
return(NULL);
}
}
cuddDeref(res);
return(Cudd_NotCond(res,N != node));
} /* end of cuddBddPermuteRecur */
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_addGeneralVectorCompose.]
Description []
SideEffects [None]
SeeAlso []
******************************************************************************/
static DdNode *
cuddAddGeneralVectorComposeRecur(
DdManager * dd /* DD manager */,
DdHashTable * table /* computed table */,
DdNode * f /* ADD in which to compose */,
DdNode ** vectorOn /* functions to substitute for x_i */,
DdNode ** vectorOff /* functions to substitute for x_i' */,
int deepest /* depth of deepest substitution */)
{
DdNode *T,*E,*t,*e;
DdNode *res;
/* If we are past the deepest substitution, return f. */
if (cuddI(dd,f->index) > deepest) {
return(f);
}
if ((res = cuddHashTableLookup1(table,f)) != NULL) {
#ifdef DD_DEBUG
addGeneralVectorComposeHits++;
#endif
return(res);
}
/* Split and recur on children of this node. */
T = cuddAddGeneralVectorComposeRecur(dd,table,cuddT(f),
vectorOn,vectorOff,deepest);
if (T == NULL) return(NULL);
cuddRef(T);
E = cuddAddGeneralVectorComposeRecur(dd,table,cuddE(f),
vectorOn,vectorOff,deepest);
if (E == NULL) {
Cudd_RecursiveDeref(dd, T);
return(NULL);
}
cuddRef(E);
/* Retrieve the compose ADDs for the current top variable and call
** cuddAddApplyRecur with the T and E we just created.
*/
t = cuddAddApplyRecur(dd,Cudd_addTimes,vectorOn[f->index],T);
if (t == NULL) {
Cudd_RecursiveDeref(dd,T);
Cudd_RecursiveDeref(dd,E);
return(NULL);
}
cuddRef(t);
e = cuddAddApplyRecur(dd,Cudd_addTimes,vectorOff[f->index],E);
if (e == NULL) {
Cudd_RecursiveDeref(dd,T);
Cudd_RecursiveDeref(dd,E);
Cudd_RecursiveDeref(dd,t);
return(NULL);
}
cuddRef(e);
res = cuddAddApplyRecur(dd,Cudd_addPlus,t,e);
if (res == NULL) {
Cudd_RecursiveDeref(dd,T);
Cudd_RecursiveDeref(dd,E);
Cudd_RecursiveDeref(dd,t);
Cudd_RecursiveDeref(dd,e);
return(NULL);
}
cuddRef(res);
Cudd_RecursiveDeref(dd,T);
Cudd_RecursiveDeref(dd,E);
Cudd_RecursiveDeref(dd,t);
Cudd_RecursiveDeref(dd,e);
/* Do not keep the result if the reference count is only 1, since
** it will not be visited again
*/
if (f->ref != 1) {
ptrint fanout = (ptrint) f->ref;
cuddSatDec(fanout);
if (!cuddHashTableInsert1(table,f,res,fanout)) {
Cudd_RecursiveDeref(dd, res);
return(NULL);
}
}
cuddDeref(res);
return(res);
} /* end of cuddAddGeneralVectorComposeRecur */
/**Function********************************************************************
Synopsis [Implements the recursive step of Cudd_addPermute.]
Description [ Recursively puts the ADD in the order given in the
array permut. Checks for trivial cases to terminate recursion, then
splits on the children of this node. Once the solutions for the
children are obtained, it puts into the current position the node
from the rest of the ADD that should be here. Then returns this ADD.
The key here is that the node being visited is NOT put in its proper
place by this instance, but rather is switched when its proper
position is reached in the recursion tree.<p>
The DdNode * that is returned is the same ADD as passed in as node,
but in the new order.]
SideEffects [None]
SeeAlso [Cudd_addPermute cuddBddPermuteRecur]
******************************************************************************/
static DdNode *
cuddAddPermuteRecur(
DdManager * manager /* DD manager */,
DdHashTable * table /* computed table */,
DdNode * node /* ADD to be reordered */,
int * permut /* permutation array */)
{
DdNode *T,*E;
DdNode *res,*var;
int index;
statLine(manager);
/* Check for terminal case of constant node. */
if (cuddIsConstant(node)) {
return(node);
}
/* If problem already solved, look up answer and return. */
if (node->ref != 1 && (res = cuddHashTableLookup1(table,node)) != NULL) {
#ifdef DD_DEBUG
addPermuteRecurHits++;
#endif
return(res);
}
/* Split and recur on children of this node. */
T = cuddAddPermuteRecur(manager,table,cuddT(node),permut);
if (T == NULL) return(NULL);
cuddRef(T);
E = cuddAddPermuteRecur(manager,table,cuddE(node),permut);
if (E == NULL) {
Cudd_RecursiveDeref(manager, T);
return(NULL);
}
cuddRef(E);
/* Move variable that should be in this position to this position
** by creating a single var ADD for that variable, and calling
** cuddAddIteRecur with the T and E we just created.
*/
index = permut[node->index];
var = cuddUniqueInter(manager,index,DD_ONE(manager),DD_ZERO(manager));
if (var == NULL) return(NULL);
cuddRef(var);
res = cuddAddIteRecur(manager,var,T,E);
if (res == NULL) {
Cudd_RecursiveDeref(manager,var);
Cudd_RecursiveDeref(manager, T);
Cudd_RecursiveDeref(manager, E);
return(NULL);
}
cuddRef(res);
Cudd_RecursiveDeref(manager,var);
Cudd_RecursiveDeref(manager, T);
Cudd_RecursiveDeref(manager, E);
/* Do not keep the result if the reference count is only 1, since
** it will not be visited again.
*/
if (node->ref != 1) {
ptrint fanout = (ptrint) node->ref;
cuddSatDec(fanout);
if (!cuddHashTableInsert1(table,node,res,fanout)) {
Cudd_RecursiveDeref(manager, res);
return(NULL);
}
}
cuddDeref(res);
return(res);
} /* end of cuddAddPermuteRecur */
