/**Function********************************************************************
Synopsis [Performs the reordering-sensitive step of Extra_bddReedMuller().]
Description [Generates in a bottom-up fashion an ADD for all spectral
coefficients of the functions represented by a BDD.]
SideEffects []
SeeAlso []
******************************************************************************/
DdNode* extraBddReedMuller(
DdManager * dd, /* the manager */
DdNode * bFunc, /* the function whose spectrum is being computed */
DdNode * bVars) /* the variables on which the function depends */
{
DdNode * aRes;
statLine(dd);
/* terminal cases */
if ( bVars == b1 )
{
assert( Cudd_IsConstant(bFunc) );
if ( bFunc == b0 )
return a0;
else
return a1;
}
/* check cache */
if ( ( aRes = cuddCacheLookup2(dd, extraBddReedMuller, bFunc, bVars) ) )
return aRes;
else
{
DdNode * bFunc0, * bFunc1; /* cofactors of the function */
DdNode * aRes0, * aRes1; /* partial results to be composed by ITE */
DdNode * bFuncR = Cudd_Regular(bFunc); /* the regular pointer to the function */
DdNode * aTemp;
/* bFunc cannot depend on a variable that is not in bVars */
assert( cuddI(dd,bFuncR->index) >= cuddI(dd,bVars->index) );
/* cofactor the BDD */
if ( bFuncR->index == bVars->index )
{
if ( bFuncR != bFunc ) /* bFunc is complemented */
{
bFunc0 = Cudd_Not( cuddE(bFuncR) );
bFunc1 = Cudd_Not( cuddT(bFuncR) );
}
else
{
bFunc0 = cuddE(bFuncR);
bFunc1 = cuddT(bFuncR);
}
}
else /* bVars is higher in the variable order */
bFunc0 = bFunc1 = bFunc;
/* solve subproblems */
aRes0 = extraBddReedMuller( dd, bFunc0, cuddT(bVars) );
if ( aRes0 == NULL )
return NULL;
cuddRef( aRes0 );
aRes1 = extraBddReedMuller( dd, bFunc1, cuddT(bVars) );
if ( aRes1 == NULL )
{
Cudd_RecursiveDeref( dd, aRes0 );
return NULL;
}
cuddRef( aRes1 );
/* compute aRes1 = aRes1 (+) aRes0 */
aRes1 = cuddAddApplyRecur( dd, Cudd_addXor, aTemp = aRes1, aRes0 );
if ( aRes1 == NULL )
{
Cudd_RecursiveDeref( dd, aRes0 );
Cudd_RecursiveDeref( dd, aTemp );
return NULL;
}
cuddRef( aRes1 );
Cudd_RecursiveDeref(dd, aTemp);
/* only aRes0 and aRes1 are referenced at this point */
/* consider the case when Res0 and Res1 are the same node */
aRes = (aRes1 == aRes0) ? aRes1 : cuddUniqueInter( dd, bVars->index, aRes1, aRes0 );
if (aRes == NULL)
{
Cudd_RecursiveDeref(dd, aRes1);
Cudd_RecursiveDeref(dd, aRes0);
return NULL;
}
cuddDeref(aRes1);
cuddDeref(aRes0);
/* insert the result into cache */
cuddCacheInsert2(dd, extraBddReedMuller, bFunc, bVars, aRes);
return aRes;
}
} /* end of extraBddReedMuller */
/**Function********************************************************************
Synopsis [Performs the recursive step for Cudd_BddTo01Add.]
Description [Performs the recursive step for Cudd_BddTo01Add. Returns a
pointer to the resulting ADD if successful; NULL otherwise.]
SideEffects [None]
SeeAlso []
******************************************************************************/
static DdNode *
ddBddTo01AddRecur(
DdManager * dd,
DdNode * B)
{
DdNode *res, *res1, *T, *E, *Bt, *Be;
int complement = 0;
statLine(dd);
if (B == DD_TRUE(dd)) {
return DD_ONE(dd);
} else if (B == Cudd_Not(DD_TRUE(dd))) {
return DD_ZERO(dd);
}
/* Check visited table */
res = cuddCacheLookup1(dd,ddBddTo01AddRecur,B);
if (res != NULL) return(res);
if (Cudd_IsComplement(B)) {
complement = 1;
Bt = cuddT(Cudd_Regular(B));
Be = cuddE(Cudd_Regular(B));
} else {
Bt = cuddT(B);
Be = cuddE(B);
}
T = ddBddTo01AddRecur(dd, Bt);
if (T == NULL) return(NULL);
cuddRef(T);
E = ddBddTo01AddRecur(dd, Be);
if (E == NULL) {
Cudd_RecursiveDeref(dd, T);
return(NULL);
}
cuddRef(E);
/* No need to check for T == E, because it is guaranteed not to happen. */
res = cuddUniqueInter(dd, (int) Cudd_Regular(B)->index, T, E);
if (res == NULL) {
Cudd_RecursiveDeref(dd ,T);
Cudd_RecursiveDeref(dd ,E);
return(NULL);
}
cuddDeref(T);
cuddDeref(E);
if (complement) {
cuddRef(res);
res1 = cuddAddCmpl01Recur(dd, res);
if (res1 == NULL) {
Cudd_RecursiveDeref(dd, res);
return(NULL);
}
cuddRef(res1);
Cudd_RecursiveDeref(dd, res);
res = res1;
cuddDeref(res);
}
/* Store result. */
cuddCacheInsert1(dd,ddBddTo01AddRecur,B,res);
return(res);
} /* end of ddBddTo01AddRecur */
/**Function********************************************************************
Synopsis [Performs the recursive step for Cudd_addBddPattern.]
Description [Performs the recursive step for Cudd_addBddPattern. Returns a
pointer to the resulting BDD if successful; NULL otherwise.]
SideEffects [None]
SeeAlso []
******************************************************************************/
DdNode *
cuddAddBddDoPattern(
DdManager * dd,
DdNode * f)
{
DdNode *res, *T, *E;
DdNode *fv, *fvn;
int v;
/* NuSMV: begin add */
abort(); /* NOT USED BY NUSMV */
/* NuSMV: begin end */
statLine(dd);
/* Check terminal case. */
if (cuddIsConstant(f)) {
return(Cudd_NotCond(DD_TRUE(dd),f == DD_FALSE(dd)));
}
/* Check cache. */
res = cuddCacheLookup1(dd,Cudd_addBddPattern,f);
if (res != NULL) return(res);
/* Recursive step. */
v = f->index;
fv = cuddT(f); fvn = cuddE(f);
T = cuddAddBddDoPattern(dd,fv);
if (T == NULL) return(NULL);
cuddRef(T);
E = cuddAddBddDoPattern(dd,fvn);
if (E == NULL) {
Cudd_RecursiveDeref(dd, T);
return(NULL);
}
cuddRef(E);
if (Cudd_IsComplement(T)) {
res = (T == E) ? Cudd_Not(T) : cuddUniqueInter(dd,v,Cudd_Not(T),Cudd_Not(E));
if (res == NULL) {
Cudd_RecursiveDeref(dd, T);
Cudd_RecursiveDeref(dd, E);
return(NULL);
}
res = Cudd_Not(res);
} else {
res = (T == E) ? T : cuddUniqueInter(dd,v,T,E);
if (res == NULL) {
Cudd_RecursiveDeref(dd, T);
Cudd_RecursiveDeref(dd, E);
return(NULL);
}
}
cuddDeref(T);
cuddDeref(E);
/* Store result. */
cuddCacheInsert1(dd,Cudd_addBddPattern,f,res);
return(res);
} /* end of cuddAddBddDoPattern */
/**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 [Performs the recursive step of Cudd_addCompose.]
Description [Performs the recursive step of Cudd_addCompose.
Returns the composed BDD if successful; NULL otherwise.]
SideEffects [None]
SeeAlso [Cudd_addCompose]
******************************************************************************/
DdNode *
cuddAddComposeRecur(
DdManager * dd,
DdNode * f,
DdNode * g,
DdNode * proj)
{
DdNode *f1, *f0, *g1, *g0, *r, *t, *e;
unsigned int v, topf, topg, topindex;
statLine(dd);
v = dd->perm[proj->index];
topf = cuddI(dd,f->index);
/* Terminal case. Subsumes the test for constant f. */
if (topf > v) return(f);
/* Check cache. */
r = cuddCacheLookup(dd,DD_ADD_COMPOSE_RECUR_TAG,f,g,proj);
if (r != NULL) {
return(r);
}
if (topf == v) {
/* Compose. */
f1 = cuddT(f);
f0 = cuddE(f);
r = cuddAddIteRecur(dd, g, f1, f0);
if (r == NULL) return(NULL);
} else {
/* Compute cofactors of f and g. Remember the index of the top
** variable.
*/
topg = cuddI(dd,g->index);
if (topf > topg) {
topindex = g->index;
f1 = f0 = f;
} else {
topindex = f->index;
f1 = cuddT(f);
f0 = cuddE(f);
}
if (topg > topf) {
g1 = g0 = g;
} else {
g1 = cuddT(g);
g0 = cuddE(g);
}
/* Recursive step. */
t = cuddAddComposeRecur(dd, f1, g1, proj);
if (t == NULL) return(NULL);
cuddRef(t);
e = cuddAddComposeRecur(dd, f0, g0, proj);
if (e == NULL) {
Cudd_RecursiveDeref(dd, t);
return(NULL);
}
cuddRef(e);
if (t == e) {
r = t;
} else {
r = cuddUniqueInter(dd, (int) topindex, t, e);
if (r == NULL) {
Cudd_RecursiveDeref(dd, t);
Cudd_RecursiveDeref(dd, e);
return(NULL);
}
}
cuddDeref(t);
cuddDeref(e);
}
cuddCacheInsert(dd,DD_ADD_COMPOSE_RECUR_TAG,f,g,proj,r);
return(r);
} /* end of cuddAddComposeRecur */
/**
@brief Takes the exclusive OR of two BDDs and simultaneously abstracts the
variables in cube.
@details The variables are existentially abstracted.
@return a pointer to the result is successful; NULL otherwise.
@sideeffect None
@see Cudd_bddAndAbstract
*/
DdNode *
cuddBddXorExistAbstractRecur(
DdManager * manager,
DdNode * f,
DdNode * g,
DdNode * cube)
{
DdNode *F, *fv, *fnv, *G, *gv, *gnv;
DdNode *one, *zero, *r, *t, *e, *Cube;
int topf, topg, topcube, top;
unsigned int index;
statLine(manager);
one = DD_ONE(manager);
zero = Cudd_Not(one);
/* Terminal cases. */
if (f == g) {
return(zero);
}
if (f == Cudd_Not(g)) {
return(one);
}
if (cube == one) {
return(cuddBddXorRecur(manager, f, g));
}
if (f == one) {
return(cuddBddExistAbstractRecur(manager, Cudd_Not(g), cube));
}
if (g == one) {
return(cuddBddExistAbstractRecur(manager, Cudd_Not(f), cube));
}
if (f == zero) {
return(cuddBddExistAbstractRecur(manager, g, cube));
}
if (g == zero) {
return(cuddBddExistAbstractRecur(manager, f, cube));
}
/* At this point f, g, and cube are not constant. */
if (f > g) { /* Try to increase cache efficiency. */
DdNode *tmp = f;
f = g;
g = tmp;
}
/* Check cache. */
r = cuddCacheLookup(manager, DD_BDD_XOR_EXIST_ABSTRACT_TAG, f, g, cube);
if (r != NULL) {
return(r);
}
checkWhetherToGiveUp(manager);
/* Here we can skip the use of cuddI, because the operands are known
** to be non-constant.
*/
F = Cudd_Regular(f);
topf = manager->perm[F->index];
G = Cudd_Regular(g);
topg = manager->perm[G->index];
top = ddMin(topf, topg);
topcube = manager->perm[cube->index];
if (topcube < top) {
return(cuddBddXorExistAbstractRecur(manager, f, g, cuddT(cube)));
}
/* Now, topcube >= top. */
if (topf == top) {
index = F->index;
fv = cuddT(F);
fnv = cuddE(F);
if (Cudd_IsComplement(f)) {
fv = Cudd_Not(fv);
fnv = Cudd_Not(fnv);
}
} else {
index = G->index;
fv = fnv = f;
}
if (topg == top) {
gv = cuddT(G);
gnv = cuddE(G);
if (Cudd_IsComplement(g)) {
gv = Cudd_Not(gv);
gnv = Cudd_Not(gnv);
}
} else {
gv = gnv = g;
}
if (topcube == top) {
Cube = cuddT(cube);
} else {
Cube = cube;
}
t = cuddBddXorExistAbstractRecur(manager, fv, gv, Cube);
if (t == NULL) return(NULL);
/* Special case: 1 OR anything = 1. Hence, no need to compute
** the else branch if t is 1.
*/
if (t == one && topcube == top) {
cuddCacheInsert(manager, DD_BDD_XOR_EXIST_ABSTRACT_TAG, f, g, cube, one);
return(one);
}
cuddRef(t);
e = cuddBddXorExistAbstractRecur(manager, fnv, gnv, Cube);
if (e == NULL) {
Cudd_IterDerefBdd(manager, t);
return(NULL);
}
cuddRef(e);
if (topcube == top) { /* abstract */
r = cuddBddAndRecur(manager, Cudd_Not(t), Cudd_Not(e));
if (r == NULL) {
Cudd_IterDerefBdd(manager, t);
Cudd_IterDerefBdd(manager, e);
return(NULL);
}
r = Cudd_Not(r);
cuddRef(r);
Cudd_IterDerefBdd(manager, t);
Cudd_IterDerefBdd(manager, e);
cuddDeref(r);
} else if (t == e) {
r = t;
cuddDeref(t);
cuddDeref(e);
} else {
if (Cudd_IsComplement(t)) {
r = cuddUniqueInter(manager,(int)index,Cudd_Not(t),Cudd_Not(e));
if (r == NULL) {
Cudd_IterDerefBdd(manager, t);
Cudd_IterDerefBdd(manager, e);
return(NULL);
}
r = Cudd_Not(r);
} else {
r = cuddUniqueInter(manager,(int)index,t,e);
if (r == NULL) {
Cudd_IterDerefBdd(manager, t);
Cudd_IterDerefBdd(manager, e);
return(NULL);
}
}
cuddDeref(e);
cuddDeref(t);
}
cuddCacheInsert(manager, DD_BDD_XOR_EXIST_ABSTRACT_TAG, f, g, cube, r);
return (r);
} /* end of cuddBddXorExistAbstractRecur */
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_addVectorCompose.]
Description []
SideEffects [None]
SeeAlso []
******************************************************************************/
static DdNode *
cuddAddVectorComposeRecur(
DdManager * dd /* DD manager */,
DdHashTable * table /* computed table */,
DdNode * f /* ADD in which to compose */,
DdNode ** vector /* functions to substitute */,
int deepest /* depth of deepest substitution */)
{
DdNode *T,*E;
DdNode *res;
statLine(dd);
/* 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
addVectorComposeHits++;
#endif
return(res);
}
/* Split and recur on children of this node. */
T = cuddAddVectorComposeRecur(dd,table,cuddT(f),vector,deepest);
if (T == NULL) return(NULL);
cuddRef(T);
E = cuddAddVectorComposeRecur(dd,table,cuddE(f),vector,deepest);
if (E == NULL) {
Cudd_RecursiveDeref(dd, T);
return(NULL);
}
cuddRef(E);
/* Retrieve the 0-1 ADD for the current top variable and call
** cuddAddIteRecur with the T and E we just created.
*/
res = cuddAddIteRecur(dd,vector[f->index],T,E);
if (res == NULL) {
Cudd_RecursiveDeref(dd, T);
Cudd_RecursiveDeref(dd, E);
return(NULL);
}
cuddRef(res);
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 cuddAddVectorComposeRecur */
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_zddDiff.]
Description []
SideEffects [None]
SeeAlso []
******************************************************************************/
DdNode *
cuddZddDiff(
DdManager * zdd,
DdNode * P,
DdNode * Q)
{
int p_top, q_top;
DdNode *empty = DD_FALSE(zdd), *t, *e, *res;
DdManager *table = zdd;
statLine(zdd);
if (P == empty)
return(empty);
if (Q == empty)
return(P);
if (P == Q)
return(empty);
/* Check cache. The cache is shared by Cudd_zddDiffConst(). */
res = cuddCacheLookup2Zdd(table, cuddZddDiff, P, Q);
if (res != NULL && res != DD_NON_CONSTANT)
return(res);
if (cuddIsConstant(P))
p_top = P->index;
else
p_top = zdd->permZ[P->index];
if (cuddIsConstant(Q))
q_top = Q->index;
else
q_top = zdd->permZ[Q->index];
if (p_top < q_top) {
e = cuddZddDiff(zdd, cuddE(P), Q);
if (e == NULL) return(NULL);
cuddRef(e);
res = cuddZddGetNode(zdd, P->index, cuddT(P), e);
if (res == NULL) {
Cudd_RecursiveDerefZdd(table, e);
return(NULL);
}
cuddDeref(e);
} else if (p_top > q_top) {
res = cuddZddDiff(zdd, P, cuddE(Q));
if (res == NULL) return(NULL);
} else {
t = cuddZddDiff(zdd, cuddT(P), cuddT(Q));
if (t == NULL) return(NULL);
cuddRef(t);
e = cuddZddDiff(zdd, cuddE(P), cuddE(Q));
if (e == NULL) {
Cudd_RecursiveDerefZdd(table, t);
return(NULL);
}
cuddRef(e);
res = cuddZddGetNode(zdd, P->index, t, e);
if (res == NULL) {
Cudd_RecursiveDerefZdd(table, t);
Cudd_RecursiveDerefZdd(table, e);
return(NULL);
}
cuddDeref(t);
cuddDeref(e);
}
cuddCacheInsert2(table, cuddZddDiff, P, Q, res);
return(res);
} /* end of cuddZddDiff */
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_addUnivAbstract.]
Description [Performs the recursive step of Cudd_addUnivAbstract.
Returns the ADD obtained by abstracting the variables of cube from f,
if successful; NULL otherwise.]
SideEffects [None]
SeeAlso []
******************************************************************************/
DdNode *
cuddAddUnivAbstractRecur(
DdManager * manager,
DdNode * f,
DdNode * cube)
{
DdNode *T, *E, *res, *res1, *res2, *one, *zero;
statLine(manager);
one = DD_ONE(manager);
zero = DD_ZERO(manager);
/* Cube is guaranteed to be a cube at this point.
** zero and one are the only constatnts c such that c*c=c.
*/
if (f == zero || f == one || cube == one) {
return(f);
}
/* Abstract a variable that does not appear in f. */
if (cuddI(manager,f->index) > cuddI(manager,cube->index)) {
res1 = cuddAddUnivAbstractRecur(manager, f, cuddT(cube));
if (res1 == NULL) return(NULL);
cuddRef(res1);
/* Use the "internal" procedure to be alerted in case of
** dynamic reordering. If dynamic reordering occurs, we
** have to abort the entire abstraction.
*/
res = cuddAddApplyRecur(manager, Cudd_addTimes, res1, res1);
if (res == NULL) {
Cudd_RecursiveDeref(manager,res1);
return(NULL);
}
cuddRef(res);
Cudd_RecursiveDeref(manager,res1);
cuddDeref(res);
return(res);
}
if ((res = cuddCacheLookup2(manager, Cudd_addUnivAbstract, f, cube)) != NULL) {
return(res);
}
T = cuddT(f);
E = cuddE(f);
/* If the two indices are the same, so are their levels. */
if (f->index == cube->index) {
res1 = cuddAddUnivAbstractRecur(manager, T, cuddT(cube));
if (res1 == NULL) return(NULL);
cuddRef(res1);
res2 = cuddAddUnivAbstractRecur(manager, E, cuddT(cube));
if (res2 == NULL) {
Cudd_RecursiveDeref(manager,res1);
return(NULL);
}
cuddRef(res2);
res = cuddAddApplyRecur(manager, Cudd_addTimes, res1, res2);
if (res == NULL) {
Cudd_RecursiveDeref(manager,res1);
Cudd_RecursiveDeref(manager,res2);
return(NULL);
}
cuddRef(res);
Cudd_RecursiveDeref(manager,res1);
Cudd_RecursiveDeref(manager,res2);
cuddCacheInsert2(manager, Cudd_addUnivAbstract, f, cube, res);
cuddDeref(res);
return(res);
} else { /* if (cuddI(manager,f->index) < cuddI(manager,cube->index)) */
res1 = cuddAddUnivAbstractRecur(manager, T, cube);
if (res1 == NULL) return(NULL);
cuddRef(res1);
res2 = cuddAddUnivAbstractRecur(manager, E, cube);
if (res2 == NULL) {
Cudd_RecursiveDeref(manager,res1);
return(NULL);
}
cuddRef(res2);
res = (res1 == res2) ? res1 :
cuddUniqueInter(manager, (int) f->index, res1, res2);
if (res == NULL) {
Cudd_RecursiveDeref(manager,res1);
Cudd_RecursiveDeref(manager,res2);
return(NULL);
}
cuddDeref(res1);
cuddDeref(res2);
cuddCacheInsert2(manager, Cudd_addUnivAbstract, f, cube, res);
return(res);
}
} /* end of cuddAddUnivAbstractRecur */
/**Function********************************************************************
Synopsis [Implements the recursive step of Cudd_addIteGeneral(f,g,h).]
Description [Implements the recursive step of Cudd_addIteGeneral(f,g,h),
meaning that g and h are not supposed to be 0-1 ADDs but may have more terminals.
Applying arithmetic addition in the terminal case. Returns a pointer to the
resulting ADD if successful; NULL otherwise.]
SideEffects [None]
SeeAlso [Cudd_addIte]
******************************************************************************/
DdNode * extraAddIteRecurGeneral( DdManager * dd, DdNode * bX, DdNode * aF, DdNode * aG )
{
DdNode * aRes;
statLine( dd );
assert( !Cudd_IsConstant(bX) );
assert( cuddE(bX) == b0 && cuddT(bX) == b1 ); /* the elementary variable */
/* check cache */
if ( aRes = cuddCacheLookup(dd, DD_ADD_ITE_GENERAL_TAG, bX, aF, aG) )
return aRes;
else
{
DdNode * aF0, * aF1, * aG0, * aG1;
int LevelF, LevelG, LevelX, LevelTop;
LevelF = cuddI(dd,aF->index);
LevelG = cuddI(dd,aG->index);
LevelX = dd->perm[bX->index];
LevelTop = ddMin(LevelF, LevelG);
LevelTop = ddMin(LevelX, LevelTop);
if ( LevelF == LevelTop )
{
aF0 = cuddE(aF);
aF1 = cuddT(aF);
}
else
aF0 = aF1 = aF;
if ( LevelG == LevelTop )
{
aG0 = cuddE(aG);
aG1 = cuddT(aG);
}
else
aG0 = aG1 = aG;
if ( LevelX == LevelTop )
{
assert( LevelX < LevelF );
assert( LevelX < LevelG );
/* consider the case when Res0 and Res1 are the same node */
aRes = (aF == aG) ? aF : cuddUniqueInter( dd, bX->index, aF, aG );
if (aRes == NULL)
return NULL;
}
else
{
DdNode * aRes0, * aRes1; /* partial results to be composed by ITE */
aRes0 = extraAddIteRecurGeneral( dd, bX, aF0, aG0 );
if ( aRes0 == NULL )
return NULL;
cuddRef( aRes0 );
aRes1 = extraAddIteRecurGeneral( dd, bX, aF1, aG1 );
if ( aRes1 == NULL )
{
Cudd_RecursiveDeref(dd, aRes0);
return NULL;
}
cuddRef( aRes1 );
/* only aRes0 and aRes1 are referenced at this point */
/* consider the case when Res0 and Res1 are the same node */
aRes = (aRes1 == aRes0) ? aRes1 : cuddUniqueInter( dd, dd->invperm[LevelTop], aRes1, aRes0 );
if (aRes == NULL)
{
Cudd_RecursiveDeref(dd, aRes1);
Cudd_RecursiveDeref(dd, aRes0);
return NULL;
}
cuddDeref(aRes1);
cuddDeref(aRes0);
}
cuddCacheInsert( dd, DD_ADD_ITE_GENERAL_TAG, bX, aF, aG, aRes );
return aRes;
}
} /* end of extraAddIteRecurGeneral */
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_zddIte.]
Description []
SideEffects [None]
SeeAlso []
******************************************************************************/
DdNode *
cuddZddIte(
DdManager * dd,
DdNode * f,
DdNode * g,
DdNode * h)
{
DdNode *tautology, *empty;
DdNode *r,*Gv,*Gvn,*Hv,*Hvn,*t,*e;
unsigned int topf,topg,toph,v,top;
int index;
statLine(dd);
/* Trivial cases. */
/* One variable cases. */
if (f == (empty = DD_FALSE(dd))) { /* ITE(0,G,H) = H */
return(h);
}
topf = cuddIZ(dd,f->index);
topg = cuddIZ(dd,g->index);
toph = cuddIZ(dd,h->index);
v = ddMin(topg,toph);
top = ddMin(topf,v);
tautology = (top == CUDD_MAXINDEX) ? DD_TRUE(dd) : dd->univ[top];
if (f == tautology) { /* ITE(1,G,H) = G */
return(g);
}
/* From now on, f is known to not be a constant. */
zddVarToConst(f,&g,&h,tautology,empty);
/* Check remaining one variable cases. */
if (g == h) { /* ITE(F,G,G) = G */
return(g);
}
if (g == tautology) { /* ITE(F,1,0) = F */
if (h == empty) return(f);
}
/* Check cache. */
r = cuddCacheLookupZdd(dd,DD_ZDD_ITE_TAG,f,g,h);
if (r != NULL) {
return(r);
}
/* Recompute these because they may have changed in zddVarToConst. */
topg = cuddIZ(dd,g->index);
toph = cuddIZ(dd,h->index);
v = ddMin(topg,toph);
if (topf < v) {
r = cuddZddIte(dd,cuddE(f),g,h);
if (r == NULL) return(NULL);
} else if (topf > v) {
if (topg > v) {
Gvn = g;
index = h->index;
} else {
Gvn = cuddE(g);
index = g->index;
}
if (toph > v) {
Hv = empty; Hvn = h;
} else {
Hv = cuddT(h); Hvn = cuddE(h);
}
e = cuddZddIte(dd,f,Gvn,Hvn);
if (e == NULL) return(NULL);
cuddRef(e);
r = cuddZddGetNode(dd,index,Hv,e);
if (r == NULL) {
Cudd_RecursiveDerefZdd(dd,e);
return(NULL);
}
cuddDeref(e);
} else {
index = f->index;
if (topg > v) {
Gv = empty; Gvn = g;
} else {
Gv = cuddT(g); Gvn = cuddE(g);
}
if (toph > v) {
Hv = empty; Hvn = h;
} else {
Hv = cuddT(h); Hvn = cuddE(h);
}
e = cuddZddIte(dd,cuddE(f),Gvn,Hvn);
if (e == NULL) return(NULL);
cuddRef(e);
t = cuddZddIte(dd,cuddT(f),Gv,Hv);
if (t == NULL) {
Cudd_RecursiveDerefZdd(dd,e);
return(NULL);
}
cuddRef(t);
r = cuddZddGetNode(dd,index,t,e);
if (r == NULL) {
Cudd_RecursiveDerefZdd(dd,e);
Cudd_RecursiveDerefZdd(dd,t);
return(NULL);
}
cuddDeref(t);
cuddDeref(e);
}
cuddCacheInsert(dd,DD_ZDD_ITE_TAG,f,g,h,r);
return(r);
} /* end of cuddZddIte */
/**Function********************************************************************
Synopsis [Replaces the negative variable assignment node in the ADD by the given value.]
Description []
SideEffects []
SeeAlso []
******************************************************************************/
DdNode * extraAddUpdateZeroCubeValue(
DdManager * dd,
DdNode * aFunc, /* the ADD to be updated */
DdNode * bVars,
DdNode * aNode ) /* the terminal node representing the required value */
{
DdNode * aRes;
statLine(dd);
/* terminal cases */
if ( bVars == b1 )
{
assert( Cudd_IsConstant(aFunc) );
return aNode;
}
/* check cache */
if ( aRes = cuddCacheLookup(dd, DD_ADD_UPDATE_ZERO_CUBE_TAG, aFunc, bVars, aNode) )
{
s_CacheHit++;
return aRes;
}
else
{
DdNode * aFunc0, * aFunc1; /* cofactors */
DdNode * aRes0, * aRes1; /* partial results to be composed by ITE */
s_CacheMiss++;
if ( aFunc->index == bVars->index )
{
aFunc0 = cuddE( aFunc );
aFunc1 = cuddT( aFunc );
}
else
aFunc0 = aFunc1 = aFunc;
aRes0 = extraAddUpdateZeroCubeValue( dd, aFunc0, cuddT(bVars), aNode );
if ( aRes0 == NULL )
return NULL;
cuddRef( aRes0 );
aRes1 = aFunc1;
// cuddRef( aRes1 );
/* only aRes0 and aRes1 are referenced at this point */
/* consider the case when Res0 and Res1 are the same node */
aRes = (aRes1 == aRes0) ? aRes1 : cuddUniqueInter( dd, bVars->index, aRes1, aRes0 );
if (aRes == NULL)
{
// Cudd_RecursiveDeref(dd, aRes1);
Cudd_RecursiveDeref(dd, aRes0);
return NULL;
}
// cuddDeref(aRes1);
cuddDeref(aRes0);
/* insert the result into cache */
cuddCacheInsert(dd, DD_ADD_UPDATE_ZERO_CUBE_TAG, aFunc, bVars, aNode, aRes);
return aRes;
}
} /* end of extraAddUpdateZeroCubeValue */
/**Function********************************************************************
Synopsis [Performs the reordering-sensitive step of Extra_bddHaarInverse().]
Description [Generates in a bottom-up fashion an ADD for the inverse Haar.]
SideEffects [The third cached argument (bSteps) is the BDD of the elementary variable
whose index equal to the number of lazy steps made thus far plus one. On the top-most
level it is 0, next it is 1, etc.]
SeeAlso []
******************************************************************************/
DdNode * extraBddHaarInverse(
DdManager * dd, /* the manager */
DdNode * aFunc, /* the function whose spectrum is being computed */
DdNode * aSteps, /* the index of this variable indicates the number of previous lazy recursive calls */
DdNode * bVars, /* the variables, on which the function depends */
DdNode * bVarsAll, /* the set of all variables, which will never change through the calls */
int nVarsAll, /* the number of vars in the set */
int * InverseMap ) /* the variable map mapping the var index into its inverse var index */
{
DdNode * aRes;
DdNode * bCacheCube;
statLine(dd);
/* terminal cases */
if ( bVars == b1 )
{ // return a terminal node with a value equal to cuddV(aFunc) * 2^(nSteps-1)
if ( cuddV(aSteps) == 0.0 )
return cuddUniqueConst( dd, cuddV(aFunc) );
else
return cuddUniqueConst( dd, cuddV(aFunc) * Extra_Power2( (int)(cuddV(aSteps)-1) ) );
}
/* check cache */
/* the last two arguments are derivitives, therefore there are useless for caching */
/* the other two arguments (bVars and bVarsAll) can be combined into one argument */
bCacheCube = extraCachingCube( dd, bVarsAll, bVars ); Cudd_Ref( bCacheCube );
if ( aRes = cuddCacheLookup(dd, DD_ADD_HAAR_INVERSE_TAG, aFunc, aSteps, bCacheCube) )
{
Cudd_RecursiveDeref( dd, bCacheCube );
return aRes;
}
else
{
DdNode * aFunc0, * aFunc1; /* cofactors of the function */
DdNode * aInvH0, * aInvH1; /* partial solutions of the problem */
DdNode * aRes0, * aRes1; /* partial results to be composed by ITE */
DdNode * aStepNext;
/* aFunc cannot depend on a variable that is not in bVars */
assert( cuddI(dd,aFunc->index) >= cuddI(dd,bVars->index) );
/* cofactor the ADD */
if ( aFunc->index == bVars->index )
{
aFunc0 = cuddE(aFunc);
aFunc1 = cuddT(aFunc);
}
else /* bVars is higher in the variable order */
aFunc0 = aFunc1 = aFunc;
if ( cuddV(aSteps) > 0.0 ) /* meaning that it is a lazy call */
{
/* solve subproblems */
aStepNext = cuddUniqueConst( dd, cuddV(aSteps)+1 );
if ( aStepNext == NULL )
return NULL;
cuddRef( aStepNext );
aInvH0 = extraBddHaarInverse( dd, aFunc0, aStepNext, cuddT(bVars), bVarsAll, nVarsAll, InverseMap );
if ( aInvH0 == NULL )
{
Cudd_RecursiveDeref( dd, aStepNext );
return NULL;
}
cuddRef( aInvH0 );
aInvH1 = extraBddHaarInverse( dd, aFunc1, aStepNext, cuddT(bVars), bVarsAll, nVarsAll, InverseMap );
if ( aInvH1 == NULL )
{
Cudd_RecursiveDeref( dd, aStepNext );
Cudd_RecursiveDeref( dd, aInvH0 );
return NULL;
}
cuddRef( aInvH1 );
Cudd_RecursiveDeref( dd, aStepNext );
aRes0 = aInvH0;
aRes1 = aInvH1;
}
else // if ( cuddV(aSteps) == 0.0 )
{
/* solve subproblems */
aInvH0 = extraBddHaarInverse( dd, aFunc0, aSteps, cuddT(bVars), bVarsAll, nVarsAll, InverseMap );
if ( aInvH0 == NULL )
return NULL;
cuddRef( aInvH0 );
aStepNext = cuddUniqueConst( dd, 1.0 );
if ( aStepNext == NULL )
{
Cudd_RecursiveDeref( dd, aInvH0 );
return NULL;
}
cuddRef( aStepNext );
aInvH1 = extraBddHaarInverse( dd, aFunc1, aStepNext, cuddT(bVars), bVarsAll, nVarsAll, InverseMap );
if ( aInvH1 == NULL )
{
Cudd_RecursiveDeref( dd, aStepNext );
Cudd_RecursiveDeref( dd, aInvH0 );
return NULL;
}
cuddRef( aInvH1 );
Cudd_RecursiveDeref( dd, aStepNext );
/* compute aRes0 = aWalsh0 + aWalsh1 */
aRes0 = cuddAddApplyRecur( dd, Cudd_addPlus, aInvH0, aInvH1 );
if ( aRes0 == NULL )
{
Cudd_RecursiveDeref( dd, aInvH0 );
Cudd_RecursiveDeref( dd, aInvH1 );
return NULL;
}
cuddRef( aRes0 );
/* compute aRes1 = aWalsh0 - aWalsh1 */
aRes1 = cuddAddApplyRecur( dd, Cudd_addMinus, aInvH0, aInvH1 );
if ( aRes1 == NULL )
{
Cudd_RecursiveDeref( dd, aInvH0 );
Cudd_RecursiveDeref( dd, aInvH1 );
Cudd_RecursiveDeref( dd, aRes0 );
return NULL;
}
cuddRef( aRes1 );
Cudd_RecursiveDeref(dd, aInvH0);
Cudd_RecursiveDeref(dd, aInvH1);
}
/* only aRes0 and aRes1 are referenced at this point */
/* consider the case when Res0 and Res1 are the same node */
aRes = extraAddIteRecurGeneral( dd, dd->vars[ InverseMap[bVars->index] ], aRes1, aRes0 );
if (aRes == NULL)
{
Cudd_RecursiveDeref(dd, aRes1);
Cudd_RecursiveDeref(dd, aRes0);
return NULL;
}
cuddRef( aRes );
Cudd_RecursiveDeref(dd, aRes1);
Cudd_RecursiveDeref(dd, aRes0);
cuddDeref( aRes );
/* insert the result into cache */
cuddCacheInsert(dd, DD_ADD_HAAR_INVERSE_TAG, aFunc, aSteps, bCacheCube, aRes);
Cudd_RecursiveDeref( dd, bCacheCube );
return aRes;
}
} /* end of extraBddHaarInverse */
/**Function********************************************************************
Synopsis [Performs the reordering-sensitive step of Extra_bddHaar().]
Description [Generates in a bottom-up fashion an ADD for all spectral
coefficients of the functions represented by a BDD.]
SideEffects []
SeeAlso []
******************************************************************************/
DdNode* extraBddHaar(
DdManager * dd, /* the manager */
DdNode * bFunc, /* the function whose spectrum is being computed */
DdNode * bVars) /* the variables on which the function depends */
{
DdNode * aRes;
statLine(dd);
/* terminal cases */
if ( bVars == b1 )
{
assert( Cudd_IsConstant(bFunc) );
if ( bFunc == b0 )
return a0;
else
return a1;
}
/* check cache */
// if ( bFunc->ref != 1 )
if ( aRes = cuddCacheLookup2(dd, extraBddHaar, bFunc, bVars) )
return aRes;
else
{
DdNode * bFunc0, * bFunc1; /* cofactors of the function */
DdNode * aHaar0, * aHaar1; /* partial solutions of the problem */
DdNode * aNode0, * aNode1; /* the special terminal nodes */
DdNode * aRes0, * aRes1; /* partial results to be composed by ITE */
DdNode * bFuncR = Cudd_Regular(bFunc); /* the regular pointer to the function */
DdNode * aTemp;
double dValue0, dValue1;
/* bFunc cannot depend on a variable that is not in bVars */
assert( cuddI(dd,bFuncR->index) >= cuddI(dd,bVars->index) );
/* cofactor the BDD */
if ( bFuncR->index == bVars->index )
{
if ( bFuncR != bFunc ) /* bFunc is complemented */
{
bFunc0 = Cudd_Not( cuddE(bFuncR) );
bFunc1 = Cudd_Not( cuddT(bFuncR) );
}
else
{
bFunc0 = cuddE(bFuncR);
bFunc1 = cuddT(bFuncR);
}
}
else /* bVars is higher in the variable order */
bFunc0 = bFunc1 = bFunc;
/* solve subproblems */
aHaar0 = extraBddHaar( dd, bFunc0, cuddT(bVars) );
if ( aHaar0 == NULL )
return NULL;
cuddRef( aHaar0 );
aHaar1 = extraBddHaar( dd, bFunc1, cuddT(bVars) );
if ( aHaar1 == NULL )
{
Cudd_RecursiveDeref( dd, aHaar0 );
return NULL;
}
cuddRef( aHaar1 );
/* retrieve the terminal values in aHaar0 and aHaar1 */
for ( aTemp = aHaar0; aTemp->index != CUDD_CONST_INDEX; aTemp = cuddE(aTemp) );
dValue0 = cuddV( aTemp );
for ( aTemp = aHaar1; aTemp->index != CUDD_CONST_INDEX; aTemp = cuddE(aTemp) );
dValue1 = cuddV( aTemp );
/* get the new terminal nodes */
aNode0 = cuddUniqueConst( dd, dValue0 + dValue1 );
if ( aNode0 == NULL )
{
Cudd_RecursiveDeref( dd, aHaar0 );
Cudd_RecursiveDeref( dd, aHaar1 );
return NULL;
}
cuddRef( aNode0 );
aNode1 = cuddUniqueConst( dd, dValue0 - dValue1 );
if ( aNode1 == NULL )
{
Cudd_RecursiveDeref( dd, aHaar0 );
Cudd_RecursiveDeref( dd, aHaar1 );
Cudd_RecursiveDeref( dd, aNode0 );
return NULL;
}
cuddRef( aNode1 );
/* replace the terminal nodes in the cofactor ADDs */
aRes0 = extraAddUpdateZeroCubeValue( dd, aHaar0, cuddT(bVars), aNode0 );
if ( aRes0 == NULL )
{
Cudd_RecursiveDeref( dd, aHaar0 );
Cudd_RecursiveDeref( dd, aHaar1 );
Cudd_RecursiveDeref( dd, aNode0 );
Cudd_RecursiveDeref( dd, aNode1 );
return NULL;
}
cuddRef( aRes0 );
aRes1 = extraAddUpdateZeroCubeValue( dd, aHaar1, cuddT(bVars), aNode1 );
if ( aRes1 == NULL )
{
Cudd_RecursiveDeref( dd, aHaar0 );
Cudd_RecursiveDeref( dd, aHaar1 );
Cudd_RecursiveDeref( dd, aNode0 );
Cudd_RecursiveDeref( dd, aNode1 );
Cudd_RecursiveDeref( dd, aRes0 );
return NULL;
}
cuddRef( aRes1 );
Cudd_RecursiveDeref(dd, aHaar0);
Cudd_RecursiveDeref(dd, aHaar1);
Cudd_RecursiveDeref(dd, aNode0);
Cudd_RecursiveDeref(dd, aNode1);
/* only aRes0 and aRes1 are referenced at this point */
/* consider the case when Res0 and Res1 are the same node */
aRes = (aRes1 == aRes0) ? aRes1 : cuddUniqueInter( dd, bVars->index, aRes1, aRes0 );
if (aRes == NULL)
{
Cudd_RecursiveDeref(dd, aRes1);
Cudd_RecursiveDeref(dd, aRes0);
return NULL;
}
cuddDeref(aRes1);
cuddDeref(aRes0);
/* insert the result into cache */
// if ( bFunc->ref != 1 )
cuddCacheInsert2(dd, extraBddHaar, bFunc, bVars, aRes);
return aRes;
}
} /* end of extraBddHaar */
/**Function********************************************************************
Synopsis [Implements the recursive step of Cudd_SplitSet.]
Description [Implements the recursive step of Cudd_SplitSet. The
procedure recursively traverses the BDD and checks to see if any
node satisfies the minterm requirements as specified by 'n'. At any
node X, n is compared to the number of minterms in the onset of X's
children. If either of the child nodes have exactly n minterms, then
that node is returned; else, if n is greater than the onset of one
of the child nodes, that node is retained and the difference in the
number of minterms is extracted from the other child. In case n
minterms can be extracted from constant 1, the algorithm returns the
result with at most log(n) nodes.]
SideEffects [The array 'varSeen' is updated at every recursive call
to set the variables traversed by the procedure.]
SeeAlso []
******************************************************************************/
DdNode*
cuddSplitSetRecur(
DdManager * manager,
st_table * mtable,
int * varSeen,
DdNode * p,
double n,
double max,
int index)
{
DdNode *one, *zero, *N, *Nv;
DdNode *Nnv, *q, *r, *v;
DdNode *result;
double *dummy, numT, numE;
int variable, positive;
statLine(manager);
one = DD_ONE(manager);
zero = Cudd_Not(one);
/* If p is constant, extract n minterms from constant 1. The procedure by
** construction guarantees that minterms will not be extracted from
** constant 0.
*/
if (Cudd_IsConstant(p)) {
q = selectMintermsFromUniverse(manager,varSeen,n);
return(q);
}
N = Cudd_Regular(p);
/* Set variable as seen. */
variable = N->index;
varSeen[manager->invperm[variable]] = -1;
Nv = cuddT(N);
Nnv = cuddE(N);
if (Cudd_IsComplement(p)) {
Nv = Cudd_Not(Nv);
Nnv = Cudd_Not(Nnv);
}
/* If both the children of 'p' are constants, extract n minterms from a
** constant node.
*/
if (Cudd_IsConstant(Nv) && Cudd_IsConstant(Nnv)) {
q = selectMintermsFromUniverse(manager,varSeen,n);
if (q == NULL) {
return(NULL);
}
cuddRef(q);
r = cuddBddAndRecur(manager,p,q);
if (r == NULL) {
Cudd_RecursiveDeref(manager,q);
return(NULL);
}
cuddRef(r);
Cudd_RecursiveDeref(manager,q);
cuddDeref(r);
return(r);
}
/* Lookup the # of minterms in the onset of the node from the table. */
if (!Cudd_IsConstant(Nv)) {
if (!st_lookup(mtable, (const char *)Nv, (char **)&dummy)) return(NULL);
numT = *dummy/(2*(1<<index));
} else if (Nv == one) {
numT = max/(2*(1<<index));
} else {
numT = 0;
}
if (!Cudd_IsConstant(Nnv)) {
if (!st_lookup(mtable, (const char *)Nnv, (char **)&dummy)) return(NULL);
numE = *dummy/(2*(1<<index));
} else if (Nnv == one) {
numE = max/(2*(1<<index));
} else {
numE = 0;
}
v = cuddUniqueInter(manager,variable,one,zero);
cuddRef(v);
/* If perfect match. */
if (numT == n) {
q = cuddBddAndRecur(manager,v,Nv);
if (q == NULL) {
Cudd_RecursiveDeref(manager,v);
return(NULL);
}
cuddRef(q);
Cudd_RecursiveDeref(manager,v);
cuddDeref(q);
return(q);
}
if (numE == n) {
q = cuddBddAndRecur(manager,Cudd_Not(v),Nnv);
if (q == NULL) {
Cudd_RecursiveDeref(manager,v);
return(NULL);
}
cuddRef(q);
Cudd_RecursiveDeref(manager,v);
cuddDeref(q);
return(q);
}
/* If n is greater than numT, extract the difference from the ELSE child
** and retain the function represented by the THEN branch.
*/
if (numT < n) {
q = cuddSplitSetRecur(manager,mtable,varSeen,
Nnv,(n-numT),max,index+1);
if (q == NULL) {
Cudd_RecursiveDeref(manager,v);
return(NULL);
}
cuddRef(q);
r = cuddBddIteRecur(manager,v,Nv,q);
if (r == NULL) {
Cudd_RecursiveDeref(manager,q);
Cudd_RecursiveDeref(manager,v);
return(NULL);
}
cuddRef(r);
Cudd_RecursiveDeref(manager,q);
Cudd_RecursiveDeref(manager,v);
cuddDeref(r);
return(r);
}
/* If n is greater than numE, extract the difference from the THEN child
** and retain the function represented by the ELSE branch.
*/
if (numE < n) {
q = cuddSplitSetRecur(manager,mtable,varSeen,
Nv, (n-numE),max,index+1);
if (q == NULL) {
Cudd_RecursiveDeref(manager,v);
return(NULL);
}
cuddRef(q);
r = cuddBddIteRecur(manager,v,q,Nnv);
if (r == NULL) {
Cudd_RecursiveDeref(manager,q);
Cudd_RecursiveDeref(manager,v);
return(NULL);
}
cuddRef(r);
Cudd_RecursiveDeref(manager,q);
Cudd_RecursiveDeref(manager,v);
cuddDeref(r);
return(r);
}
/* None of the above cases; (n < numT and n < numE) and either of
** the Nv, Nnv or both are not constants. If possible extract the
** required minterms the constant branch.
*/
if (Cudd_IsConstant(Nv) && !Cudd_IsConstant(Nnv)) {
q = selectMintermsFromUniverse(manager,varSeen,n);
if (q == NULL) {
Cudd_RecursiveDeref(manager,v);
return(NULL);
}
cuddRef(q);
result = cuddBddAndRecur(manager,v,q);
if (result == NULL) {
Cudd_RecursiveDeref(manager,q);
Cudd_RecursiveDeref(manager,v);
return(NULL);
}
cuddRef(result);
Cudd_RecursiveDeref(manager,q);
Cudd_RecursiveDeref(manager,v);
cuddDeref(result);
return(result);
} else if (!Cudd_IsConstant(Nv) && Cudd_IsConstant(Nnv)) {
q = selectMintermsFromUniverse(manager,varSeen,n);
if (q == NULL) {
Cudd_RecursiveDeref(manager,v);
return(NULL);
}
cuddRef(q);
result = cuddBddAndRecur(manager,Cudd_Not(v),q);
if (result == NULL) {
Cudd_RecursiveDeref(manager,q);
Cudd_RecursiveDeref(manager,v);
return(NULL);
}
cuddRef(result);
Cudd_RecursiveDeref(manager,q);
Cudd_RecursiveDeref(manager,v);
cuddDeref(result);
return(result);
}
/* Both Nv and Nnv are not constants. So choose the one which
** has fewer minterms in its onset.
*/
positive = 0;
if (numT < numE) {
q = cuddSplitSetRecur(manager,mtable,varSeen,
Nv,n,max,index+1);
positive = 1;
} else {
q = cuddSplitSetRecur(manager,mtable,varSeen,
Nnv,n,max,index+1);
}
if (q == NULL) {
Cudd_RecursiveDeref(manager,v);
return(NULL);
}
cuddRef(q);
if (positive) {
result = cuddBddAndRecur(manager,v,q);
} else {
result = cuddBddAndRecur(manager,Cudd_Not(v),q);
}
if (result == NULL) {
Cudd_RecursiveDeref(manager,q);
Cudd_RecursiveDeref(manager,v);
return(NULL);
}
cuddRef(result);
Cudd_RecursiveDeref(manager,q);
Cudd_RecursiveDeref(manager,v);
cuddDeref(result);
return(result);
} /* end of cuddSplitSetRecur */
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_addOrAbstract.]
Description [Performs the recursive step of Cudd_addOrAbstract.
Returns the ADD obtained by abstracting the variables of cube from f,
if successful; NULL otherwise.]
SideEffects [None]
SeeAlso []
******************************************************************************/
DdNode *
cuddAddOrAbstractRecur(
DdManager * manager,
DdNode * f,
DdNode * cube)
{
DdNode *T, *E, *res, *res1, *res2, *one;
statLine(manager);
one = DD_ONE(manager);
/* Cube is guaranteed to be a cube at this point. */
if (cuddIsConstant(f) || cube == one) {
return(f);
}
/* Abstract a variable that does not appear in f. */
if (cuddI(manager,f->index) > cuddI(manager,cube->index)) {
res = cuddAddOrAbstractRecur(manager, f, cuddT(cube));
return(res);
}
if ((res = cuddCacheLookup2(manager, Cudd_addOrAbstract, f, cube)) != NULL) {
return(res);
}
T = cuddT(f);
E = cuddE(f);
/* If the two indices are the same, so are their levels. */
if (f->index == cube->index) {
res1 = cuddAddOrAbstractRecur(manager, T, cuddT(cube));
if (res1 == NULL) return(NULL);
cuddRef(res1);
if (res1 != one) {
res2 = cuddAddOrAbstractRecur(manager, E, cuddT(cube));
if (res2 == NULL) {
Cudd_RecursiveDeref(manager,res1);
return(NULL);
}
cuddRef(res2);
res = cuddAddApplyRecur(manager, Cudd_addOr, res1, res2);
if (res == NULL) {
Cudd_RecursiveDeref(manager,res1);
Cudd_RecursiveDeref(manager,res2);
return(NULL);
}
cuddRef(res);
Cudd_RecursiveDeref(manager,res1);
Cudd_RecursiveDeref(manager,res2);
} else {
res = res1;
}
cuddCacheInsert2(manager, Cudd_addOrAbstract, f, cube, res);
cuddDeref(res);
return(res);
} else { /* if (cuddI(manager,f->index) < cuddI(manager,cube->index)) */
res1 = cuddAddOrAbstractRecur(manager, T, cube);
if (res1 == NULL) return(NULL);
cuddRef(res1);
res2 = cuddAddOrAbstractRecur(manager, E, cube);
if (res2 == NULL) {
Cudd_RecursiveDeref(manager,res1);
return(NULL);
}
cuddRef(res2);
res = (res1 == res2) ? res1 :
cuddUniqueInter(manager, (int) f->index, res1, res2);
if (res == NULL) {
Cudd_RecursiveDeref(manager,res1);
Cudd_RecursiveDeref(manager,res2);
return(NULL);
}
cuddDeref(res1);
cuddDeref(res2);
cuddCacheInsert2(manager, Cudd_addOrAbstract, f, cube, res);
return(res);
}
} /* end of cuddAddOrAbstractRecur */
/**
@brief Performs the recursive steps of Cudd_bddExistAbstract.
@details It is also used by Cudd_bddUnivAbstract.
@return the %BDD obtained by abstracting the variables of cube from f
if successful; NULL otherwise.
@sideeffect None
@see Cudd_bddExistAbstract Cudd_bddUnivAbstract
*/
DdNode *
cuddBddExistAbstractRecur(
DdManager * manager,
DdNode * f,
DdNode * cube)
{
DdNode *F, *T, *E, *res, *res1, *res2, *one;
statLine(manager);
one = DD_ONE(manager);
F = Cudd_Regular(f);
/* Cube is guaranteed to be a cube at this point. */
if (cube == one || F == one) {
return(f);
}
/* From now on, f and cube are non-constant. */
/* Abstract a variable that does not appear in f. */
while (manager->perm[F->index] > manager->perm[cube->index]) {
cube = cuddT(cube);
if (cube == one) return(f);
}
/* Check the cache. */
if (F->ref != 1 && (res = cuddCacheLookup2(manager, Cudd_bddExistAbstract, f, cube)) != NULL) {
return(res);
}
checkWhetherToGiveUp(manager);
/* Compute the cofactors of f. */
T = cuddT(F); E = cuddE(F);
if (f != F) {
T = Cudd_Not(T); E = Cudd_Not(E);
}
/* If the two indices are the same, so are their levels. */
if (F->index == cube->index) {
if (T == one || E == one || T == Cudd_Not(E)) {
return(one);
}
res1 = cuddBddExistAbstractRecur(manager, T, cuddT(cube));
if (res1 == NULL) return(NULL);
if (res1 == one) {
if (F->ref != 1)
cuddCacheInsert2(manager, Cudd_bddExistAbstract, f, cube, one);
return(one);
}
cuddRef(res1);
res2 = cuddBddExistAbstractRecur(manager, E, cuddT(cube));
if (res2 == NULL) {
Cudd_IterDerefBdd(manager,res1);
return(NULL);
}
cuddRef(res2);
res = cuddBddAndRecur(manager, Cudd_Not(res1), Cudd_Not(res2));
if (res == NULL) {
Cudd_IterDerefBdd(manager, res1);
Cudd_IterDerefBdd(manager, res2);
return(NULL);
}
res = Cudd_Not(res);
cuddRef(res);
Cudd_IterDerefBdd(manager, res1);
Cudd_IterDerefBdd(manager, res2);
if (F->ref != 1)
cuddCacheInsert2(manager, Cudd_bddExistAbstract, f, cube, res);
cuddDeref(res);
return(res);
} else { /* if (cuddI(manager,F->index) < cuddI(manager,cube->index)) */
res1 = cuddBddExistAbstractRecur(manager, T, cube);
if (res1 == NULL) return(NULL);
cuddRef(res1);
res2 = cuddBddExistAbstractRecur(manager, E, cube);
if (res2 == NULL) {
Cudd_IterDerefBdd(manager, res1);
return(NULL);
}
cuddRef(res2);
/* ITE takes care of possible complementation of res1 and of the
** case in which res1 == res2. */
res = cuddBddIteRecur(manager, manager->vars[F->index], res1, res2);
if (res == NULL) {
Cudd_IterDerefBdd(manager, res1);
Cudd_IterDerefBdd(manager, res2);
return(NULL);
}
cuddDeref(res1);
cuddDeref(res2);
if (F->ref != 1)
cuddCacheInsert2(manager, Cudd_bddExistAbstract, f, cube, res);
return(res);
}
} /* end of cuddBddExistAbstractRecur */
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_Cofactor.]
Description [Performs the recursive step of Cudd_Cofactor. Returns a
pointer to the cofactor if successful; NULL otherwise.]
SideEffects [None]
SeeAlso [Cudd_Cofactor]
******************************************************************************/
DdNode *
cuddCofactorRecur(
DdManager * dd,
DdNode * f,
DdNode * g)
{
DdNode *one,*zero,*F,*G,*g1,*g0,*f1,*f0,*t,*e,*r;
unsigned int topf,topg;
int comple;
statLine(dd);
F = Cudd_Regular(f);
if (cuddIsConstant(F)) return(f);
one = DD_ONE(dd);
/* The invariant g != 0 is true on entry to this procedure and is
** recursively maintained by it. Therefore it suffices to test g
** against one to make sure it is not constant.
*/
if (g == one) return(f);
/* From now on, f and g are known not to be constants. */
comple = f != F;
r = cuddCacheLookup2(dd,Cudd_Cofactor,F,g);
if (r != NULL) {
return(Cudd_NotCond(r,comple));
}
topf = dd->perm[F->index];
G = Cudd_Regular(g);
topg = dd->perm[G->index];
/* We take the cofactors of F because we are going to rely on
** the fact that the cofactors of the complement are the complements
** of the cofactors to better utilize the cache. Variable comple
** remembers whether we have to complement the result or not.
*/
if (topf <= topg) {
f1 = cuddT(F); f0 = cuddE(F);
} else {
f1 = f0 = F;
}
if (topg <= topf) {
g1 = cuddT(G); g0 = cuddE(G);
if (g != G) { g1 = Cudd_Not(g1); g0 = Cudd_Not(g0); }
} else {
g1 = g0 = g;
}
zero = Cudd_Not(one);
if (topf >= topg) {
if (g0 == zero || g0 == DD_ZERO(dd)) {
r = cuddCofactorRecur(dd, f1, g1);
} else if (g1 == zero || g1 == DD_ZERO(dd)) {
r = cuddCofactorRecur(dd, f0, g0);
} else {
(void) fprintf(dd->out,
"Cudd_Cofactor: Invalid restriction 2\n");
dd->errorCode = CUDD_INVALID_ARG;
return(NULL);
}
if (r == NULL) return(NULL);
} else /* if (topf < topg) */ {
t = cuddCofactorRecur(dd, f1, g);
if (t == NULL) return(NULL);
cuddRef(t);
e = cuddCofactorRecur(dd, f0, g);
if (e == NULL) {
Cudd_RecursiveDeref(dd, t);
return(NULL);
}
cuddRef(e);
if (t == e) {
r = t;
} else if (Cudd_IsComplement(t)) {
r = cuddUniqueInter(dd,(int)F->index,Cudd_Not(t),Cudd_Not(e));
if (r != NULL)
r = Cudd_Not(r);
} else {
r = cuddUniqueInter(dd,(int)F->index,t,e);
}
if (r == NULL) {
Cudd_RecursiveDeref(dd ,e);
Cudd_RecursiveDeref(dd ,t);
return(NULL);
}
cuddDeref(t);
cuddDeref(e);
}
cuddCacheInsert2(dd,Cudd_Cofactor,F,g,r);
return(Cudd_NotCond(r,comple));
} /* end of cuddCofactorRecur */
/**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 [Linearly combines two adjacent variables.]
Description [Linearly combines two adjacent variables. It assumes
that no dead nodes are present on entry to this procedure. The
procedure then guarantees that no dead nodes will be present when it
terminates. cuddZddLinearInPlace assumes that x < y. Returns the
number of keys in the table if successful; 0 otherwise.]
SideEffects [None]
SeeAlso [cuddZddSwapInPlace cuddLinearInPlace]
******************************************************************************/
int
cuddZddLinearInPlace(
DdManager * table,
int x,
int y)
{
DdNodePtr *xlist, *ylist;
int xindex, yindex;
int xslots, yslots;
int xshift, yshift;
int oldxkeys, oldykeys;
int newxkeys, newykeys;
int i;
int posn;
DdNode *f, *f1, *f0, *f11, *f10, *f01, *f00;
DdNode *newf1, *newf0, *g, *next, *previous;
DdNode *special;
#ifdef DD_DEBUG
assert(x < y);
assert(cuddZddNextHigh(table,x) == y);
assert(table->subtableZ[x].keys != 0);
assert(table->subtableZ[y].keys != 0);
assert(table->subtableZ[x].dead == 0);
assert(table->subtableZ[y].dead == 0);
#endif
zddTotalNumberLinearTr++;
/* Get parameters of x subtable. */
xindex = table->invpermZ[x];
xlist = table->subtableZ[x].nodelist;
oldxkeys = table->subtableZ[x].keys;
xslots = table->subtableZ[x].slots;
xshift = table->subtableZ[x].shift;
newxkeys = 0;
/* Get parameters of y subtable. */
yindex = table->invpermZ[y];
ylist = table->subtableZ[y].nodelist;
oldykeys = table->subtableZ[y].keys;
yslots = table->subtableZ[y].slots;
yshift = table->subtableZ[y].shift;
newykeys = oldykeys;
/* The nodes in the x layer are put in two chains. The chain
** pointed by g holds the normal nodes. When re-expressed they stay
** in the x list. The chain pointed by special holds the elements
** that will move to the y list.
*/
g = special = NULL;
for (i = 0; i < xslots; i++) {
f = xlist[i];
if (f == NULL) continue;
xlist[i] = NULL;
while (f != NULL) {
next = f->next;
f1 = cuddT(f);
/* if (f1->index == yindex) */ cuddSatDec(f1->ref);
f0 = cuddE(f);
/* if (f0->index == yindex) */ cuddSatDec(f0->ref);
if ((int) f1->index == yindex && cuddE(f1) == empty &&
(int) f0->index != yindex) {
f->next = special;
special = f;
} else {
f->next = g;
g = f;
}
f = next;
} /* while there are elements in the collision chain */
} /* for each slot of the x subtable */
/* Mark y nodes with pointers from above x. We mark them by
** changing their index to x.
*/
for (i = 0; i < yslots; i++) {
f = ylist[i];
while (f != NULL) {
if (f->ref != 0) {
f->index = xindex;
}
f = f->next;
} /* while there are elements in the collision chain */
} /* for each slot of the y subtable */
/* Move special nodes to the y list. */
f = special;
while (f != NULL) {
next = f->next;
f1 = cuddT(f);
f11 = cuddT(f1);
cuddT(f) = f11;
cuddSatInc(f11->ref);
f0 = cuddE(f);
cuddSatInc(f0->ref);
f->index = yindex;
/* Insert at the beginning of the list so that it will be
** found first if there is a duplicate. The duplicate will
** eventually be moved or garbage collected. No node
** re-expression will add a pointer to it.
*/
posn = ddHash(f11, f0, yshift);
f->next = ylist[posn];
ylist[posn] = f;
newykeys++;
f = next;
}
/* Take care of the remaining x nodes that must be re-expressed.
** They form a linked list pointed by g.
*/
f = g;
while (f != NULL) {
#ifdef DD_COUNT
table->swapSteps++;
#endif
next = f->next;
/* Find f1, f0, f11, f10, f01, f00. */
f1 = cuddT(f);
if ((int) f1->index == yindex || (int) f1->index == xindex) {
f11 = cuddT(f1); f10 = cuddE(f1);
} else {
f11 = empty; f10 = f1;
}
f0 = cuddE(f);
if ((int) f0->index == yindex || (int) f0->index == xindex) {
f01 = cuddT(f0); f00 = cuddE(f0);
} else {
f01 = empty; f00 = f0;
}
/* Create the new T child. */
if (f01 == empty) {
newf1 = f10;
cuddSatInc(newf1->ref);
} else {
/* Check ylist for triple (yindex, f01, f10). */
posn = ddHash(f01, f10, yshift);
/* For each element newf1 in collision list ylist[posn]. */
newf1 = ylist[posn];
/* Search the collision chain skipping the marked nodes. */
while (newf1 != NULL) {
if (cuddT(newf1) == f01 && cuddE(newf1) == f10 &&
(int) newf1->index == yindex) {
cuddSatInc(newf1->ref);
break; /* match */
}
newf1 = newf1->next;
} /* while newf1 */
if (newf1 == NULL) { /* no match */
newf1 = cuddDynamicAllocNode(table);
if (newf1 == NULL)
goto zddSwapOutOfMem;
newf1->index = yindex; newf1->ref = 1;
cuddT(newf1) = f01;
cuddE(newf1) = f10;
/* Insert newf1 in the collision list ylist[pos];
** increase the ref counts of f01 and f10
*/
newykeys++;
newf1->next = ylist[posn];
ylist[posn] = newf1;
cuddSatInc(f01->ref);
cuddSatInc(f10->ref);
}
}
cuddT(f) = newf1;
/* Do the same for f0. */
/* Create the new E child. */
if (f11 == empty) {
newf0 = f00;
cuddSatInc(newf0->ref);
} else {
/* Check ylist for triple (yindex, f11, f00). */
posn = ddHash(f11, f00, yshift);
/* For each element newf0 in collision list ylist[posn]. */
newf0 = ylist[posn];
while (newf0 != NULL) {
if (cuddT(newf0) == f11 && cuddE(newf0) == f00 &&
(int) newf0->index == yindex) {
cuddSatInc(newf0->ref);
break; /* match */
}
newf0 = newf0->next;
} /* while newf0 */
if (newf0 == NULL) { /* no match */
newf0 = cuddDynamicAllocNode(table);
if (newf0 == NULL)
goto zddSwapOutOfMem;
newf0->index = yindex; newf0->ref = 1;
cuddT(newf0) = f11; cuddE(newf0) = f00;
/* Insert newf0 in the collision list ylist[posn];
** increase the ref counts of f11 and f00.
*/
newykeys++;
newf0->next = ylist[posn];
ylist[posn] = newf0;
cuddSatInc(f11->ref);
cuddSatInc(f00->ref);
}
}
cuddE(f) = newf0;
/* Re-insert the modified f in xlist.
** The modified f does not already exists in xlist.
** (Because of the uniqueness of the cofactors.)
*/
posn = ddHash(newf1, newf0, xshift);
newxkeys++;
f->next = xlist[posn];
xlist[posn] = f;
f = next;
} /* while f != NULL */
/* GC the y layer and move the marked nodes to the x list. */
/* For each node f in ylist. */
for (i = 0; i < yslots; i++) {
previous = NULL;
f = ylist[i];
while (f != NULL) {
next = f->next;
if (f->ref == 0) {
cuddSatDec(cuddT(f)->ref);
cuddSatDec(cuddE(f)->ref);
cuddDeallocNode(table, f);
newykeys--;
if (previous == NULL)
ylist[i] = next;
else
previous->next = next;
} else if ((int) f->index == xindex) { /* move marked node */
if (previous == NULL)
ylist[i] = next;
else
previous->next = next;
f1 = cuddT(f);
cuddSatDec(f1->ref);
/* Check ylist for triple (yindex, f1, empty). */
posn = ddHash(f1, empty, yshift);
/* For each element newf1 in collision list ylist[posn]. */
newf1 = ylist[posn];
while (newf1 != NULL) {
if (cuddT(newf1) == f1 && cuddE(newf1) == empty &&
(int) newf1->index == yindex) {
cuddSatInc(newf1->ref);
break; /* match */
}
newf1 = newf1->next;
} /* while newf1 */
if (newf1 == NULL) { /* no match */
newf1 = cuddDynamicAllocNode(table);
if (newf1 == NULL)
goto zddSwapOutOfMem;
newf1->index = yindex; newf1->ref = 1;
cuddT(newf1) = f1; cuddE(newf1) = empty;
/* Insert newf1 in the collision list ylist[posn];
** increase the ref counts of f1 and empty.
*/
newykeys++;
newf1->next = ylist[posn];
ylist[posn] = newf1;
if (posn == i && previous == NULL)
previous = newf1;
cuddSatInc(f1->ref);
cuddSatInc(empty->ref);
}
cuddT(f) = newf1;
f0 = cuddE(f);
/* Insert f in x list. */
posn = ddHash(newf1, f0, xshift);
newxkeys++;
newykeys--;
f->next = xlist[posn];
xlist[posn] = f;
} else {
previous = f;
}
f = next;
} /* while f */
} /* for i */
/* Set the appropriate fields in table. */
table->subtableZ[x].keys = newxkeys;
table->subtableZ[y].keys = newykeys;
table->keysZ += newxkeys + newykeys - oldxkeys - oldykeys;
/* Update univ section; univ[x] remains the same. */
table->univ[y] = cuddT(table->univ[x]);
#if 0
(void) fprintf(table->out,"x = %d y = %d\n", x, y);
(void) Cudd_DebugCheck(table);
(void) Cudd_CheckKeys(table);
#endif
return (table->keysZ);
zddSwapOutOfMem:
(void) fprintf(table->err, "Error: cuddZddSwapInPlace out of memory\n");
return (0);
} /* end of cuddZddLinearInPlace */
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_addNonSimCompose.]
Description []
SideEffects [None]
SeeAlso []
******************************************************************************/
static DdNode *
cuddAddNonSimComposeRecur(
DdManager * dd,
DdNode * f,
DdNode ** vector,
DdNode * key,
DdNode * cube,
int lastsub)
{
DdNode *f1, *f0, *key1, *key0, *cube1, *var;
DdNode *T,*E;
DdNode *r;
unsigned int top, topf, topk, topc;
unsigned int index;
int i;
DdNode **vect1;
DdNode **vect0;
statLine(dd);
/* If we are past the deepest substitution, return f. */
if (cube == DD_ONE(dd) || cuddIsConstant(f)) {
return(f);
}
/* If problem already solved, look up answer and return. */
r = cuddCacheLookup(dd,DD_ADD_NON_SIM_COMPOSE_TAG,f,key,cube);
if (r != NULL) {
return(r);
}
/* Find top variable. we just need to look at f, key, and cube,
** because all the varibles in the gi are in key.
*/
topf = cuddI(dd,f->index);
topk = cuddI(dd,key->index);
top = ddMin(topf,topk);
topc = cuddI(dd,cube->index);
top = ddMin(top,topc);
index = dd->invperm[top];
/* Compute the cofactors. */
if (topf == top) {
f1 = cuddT(f);
f0 = cuddE(f);
} else {
f1 = f0 = f;
}
if (topc == top) {
cube1 = cuddT(cube);
/* We want to eliminate vector[index] from key. Otherwise
** cache performance is severely affected. Hence we
** existentially quantify the variable with index "index" from key.
*/
var = Cudd_addIthVar(dd, (int) index);
if (var == NULL) {
return(NULL);
}
cuddRef(var);
key1 = cuddAddExistAbstractRecur(dd, key, var);
if (key1 == NULL) {
Cudd_RecursiveDeref(dd,var);
return(NULL);
}
cuddRef(key1);
Cudd_RecursiveDeref(dd,var);
key0 = key1;
} else {
cube1 = cube;
if (topk == top) {
key1 = cuddT(key);
key0 = cuddE(key);
} else {
key1 = key0 = key;
}
cuddRef(key1);
}
/* Allocate two new vectors for the cofactors of vector. */
vect1 = ALLOC(DdNode *,lastsub);
if (vect1 == NULL) {
dd->errorCode = CUDD_MEMORY_OUT;
Cudd_RecursiveDeref(dd,key1);
return(NULL);
}
vect0 = ALLOC(DdNode *,lastsub);
if (vect0 == NULL) {
dd->errorCode = CUDD_MEMORY_OUT;
Cudd_RecursiveDeref(dd,key1);
FREE(vect1);
return(NULL);
}
/* Cofactor the gi. Eliminate vect1[index] and vect0[index], because
** we do not need them.
*/
for (i = 0; i < lastsub; i++) {
DdNode *gi = vector[i];
if (gi == NULL) {
vect1[i] = vect0[i] = NULL;
} else if (gi->index == index) {
vect1[i] = cuddT(gi);
vect0[i] = cuddE(gi);
} else {
vect1[i] = vect0[i] = gi;
}
}
vect1[index] = vect0[index] = NULL;
/* Recur on children. */
T = cuddAddNonSimComposeRecur(dd,f1,vect1,key1,cube1,lastsub);
FREE(vect1);
if (T == NULL) {
Cudd_RecursiveDeref(dd,key1);
FREE(vect0);
return(NULL);
}
cuddRef(T);
E = cuddAddNonSimComposeRecur(dd,f0,vect0,key0,cube1,lastsub);
FREE(vect0);
if (E == NULL) {
Cudd_RecursiveDeref(dd,key1);
Cudd_RecursiveDeref(dd,T);
return(NULL);
}
cuddRef(E);
Cudd_RecursiveDeref(dd,key1);
/* Retrieve the 0-1 ADD for the current top variable from vector,
** and call cuddAddIteRecur with the T and E we just created.
*/
r = cuddAddIteRecur(dd,vector[index],T,E);
if (r == NULL) {
Cudd_RecursiveDeref(dd,T);
Cudd_RecursiveDeref(dd,E);
return(NULL);
}
cuddRef(r);
Cudd_RecursiveDeref(dd,T);
Cudd_RecursiveDeref(dd,E);
cuddDeref(r);
/* Store answer to trim recursion. */
cuddCacheInsert(dd,DD_ADD_NON_SIM_COMPOSE_TAG,f,key,cube,r);
return(r);
} /* end of cuddAddNonSimComposeRecur */
/**Function********************************************************************
Synopsis [Decreases the reference count of BDD node n.]
Description [Enqueues node n for later dereferencing. If the queue
is full decreases the reference count of the oldest node N to make
room for n. If N dies, recursively decreases the reference counts of
its children. It is used to dispose of a BDD that is currently not
needed, but may be useful again in the near future. The dereferencing
proper is done as in Cudd_IterDerefBdd.]
SideEffects [None]
SeeAlso [Cudd_RecursiveDeref Cudd_IterDerefBdd]
******************************************************************************/
void
Cudd_DelayedDerefBdd(
DdManager * table,
DdNode * n)
{
DdNode *N;
int ord;
DdNodePtr *stack;
int SP;
unsigned int live = table->keys - table->dead;
if (live > table->peakLiveNodes) {
table->peakLiveNodes = live;
}
n = Cudd_Regular(n);
#ifdef DD_DEBUG
assert(n->ref != 0);
#endif
#ifdef DD_NO_DEATH_ROW
N = n;
#else
if (cuddIsConstant(n) || n->ref > 1) {
#ifdef DD_DEBUG
assert(n->ref != 1 && (!cuddIsConstant(n) || n == DD_ONE(table)));
#endif
cuddSatDec(n->ref);
return;
}
N = table->deathRow[table->nextDead];
if (N != NULL) {
#endif
#ifdef DD_DEBUG
assert(!Cudd_IsComplement(N));
#endif
stack = table->stack;
SP = 1;
do {
#ifdef DD_DEBUG
assert(N->ref != 0);
#endif
if (N->ref == 1) {
N->ref = 0;
table->dead++;
#ifdef DD_STATS
table->nodesDropped++;
#endif
ord = table->perm[N->index];
stack[SP++] = Cudd_Regular(cuddE(N));
table->subtables[ord].dead++;
N = cuddT(N);
} else {
cuddSatDec(N->ref);
N = stack[--SP];
}
} while (SP != 0);
#ifndef DD_NO_DEATH_ROW
}
table->deathRow[table->nextDead] = n;
/* Udate insertion point. */
table->nextDead++;
table->nextDead &= table->deadMask;
#if 0
if (table->nextDead == table->deathRowDepth) {
if (table->deathRowDepth < table->looseUpTo / 2) {
extern void (*MMoutOfMemory)(long);
void (*saveHandler)(long) = MMoutOfMemory;
DdNodePtr *newRow;
MMoutOfMemory = Cudd_OutOfMem;
newRow = REALLOC(DdNodePtr,table->deathRow,2*table->deathRowDepth);
MMoutOfMemory = saveHandler;
if (newRow == NULL) {
table->nextDead = 0;
} else {
int i;
table->memused += table->deathRowDepth;
i = table->deathRowDepth;
table->deathRowDepth <<= 1;
for (; i < table->deathRowDepth; i++) {
newRow[i] = NULL;
}
table->deadMask = table->deathRowDepth - 1;
table->deathRow = newRow;
}
} else {
table->nextDead = 0;
}
}
#endif
#endif
} /* end of Cudd_DelayedDerefBdd */
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_bddCompose.]
Description [Performs the recursive step of Cudd_bddCompose.
Exploits the fact that the composition of f' with g
produces the complement of the composition of f with g to better
utilize the cache. Returns the composed BDD if successful; NULL
otherwise.]
SideEffects [None]
SeeAlso [Cudd_bddCompose]
******************************************************************************/
DdNode *
cuddBddComposeRecur(
DdManager * dd,
DdNode * f,
DdNode * g,
DdNode * proj)
{
DdNode *F, *G, *f1, *f0, *g1, *g0, *r, *t, *e;
unsigned int v, topf, topg, topindex;
int comple;
statLine(dd);
v = dd->perm[proj->index];
F = Cudd_Regular(f);
topf = cuddI(dd,F->index);
/* Terminal case. Subsumes the test for constant f. */
if (topf > v) return(f);
/* We solve the problem for a regular pointer, and then complement
** the result if the pointer was originally complemented.
*/
comple = Cudd_IsComplement(f);
/* Check cache. */
r = cuddCacheLookup(dd,DD_BDD_COMPOSE_RECUR_TAG,F,g,proj);
if (r != NULL) {
return(Cudd_NotCond(r,comple));
}
if (topf == v) {
/* Compose. */
f1 = cuddT(F);
f0 = cuddE(F);
r = cuddBddIteRecur(dd, g, f1, f0);
if (r == NULL) return(NULL);
} else {
/* Compute cofactors of f and g. Remember the index of the top
** variable.
*/
G = Cudd_Regular(g);
topg = cuddI(dd,G->index);
if (topf > topg) {
topindex = G->index;
f1 = f0 = F;
} else {
topindex = F->index;
f1 = cuddT(F);
f0 = cuddE(F);
}
if (topg > topf) {
g1 = g0 = g;
} else {
g1 = cuddT(G);
g0 = cuddE(G);
if (g != G) {
g1 = Cudd_Not(g1);
g0 = Cudd_Not(g0);
}
}
/* Recursive step. */
t = cuddBddComposeRecur(dd, f1, g1, proj);
if (t == NULL) return(NULL);
cuddRef(t);
e = cuddBddComposeRecur(dd, f0, g0, proj);
if (e == NULL) {
Cudd_IterDerefBdd(dd, t);
return(NULL);
}
cuddRef(e);
r = cuddBddIteRecur(dd, dd->vars[topindex], t, e);
if (r == NULL) {
Cudd_IterDerefBdd(dd, t);
Cudd_IterDerefBdd(dd, e);
return(NULL);
}
cuddRef(r);
Cudd_IterDerefBdd(dd, t); /* t & e not necessarily part of r */
Cudd_IterDerefBdd(dd, e);
cuddDeref(r);
}
cuddCacheInsert(dd,DD_BDD_COMPOSE_RECUR_TAG,F,g,proj,r);
return(Cudd_NotCond(r,comple));
} /* end of cuddBddComposeRecur */
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_addApply.]
Description [Performs the recursive step of Cudd_addApply. Returns a
pointer to the result if successful; NULL otherwise.]
SideEffects [None]
SeeAlso [cuddAddMonadicApplyRecur]
******************************************************************************/
DdNode *
cuddAddApplyRecur(
DdManager * dd,
DD_AOP op,
DdNode * f,
DdNode * g)
{
DdNode *res,
*fv, *fvn, *gv, *gvn,
*T, *E;
unsigned int ford, gord;
unsigned int index;
DD_CTFP cacheOp;
/* Check terminal cases. Op may swap f and g to increase the
* cache hit rate.
*/
statLine(dd);
res = (*op)(dd,&f,&g);
if (res != NULL) return(res);
/* Check cache. */
cacheOp = (DD_CTFP) op;
res = cuddCacheLookup2(dd,cacheOp,f,g);
if (res != NULL) return(res);
/* Recursive step. */
ford = cuddI(dd,f->index);
gord = cuddI(dd,g->index);
if (ford <= gord) {
index = f->index;
fv = cuddT(f);
fvn = cuddE(f);
} else {
index = g->index;
fv = fvn = f;
}
if (gord <= ford) {
gv = cuddT(g);
gvn = cuddE(g);
} else {
gv = gvn = g;
}
T = cuddAddApplyRecur(dd,op,fv,gv);
if (T == NULL) return(NULL);
cuddRef(T);
E = cuddAddApplyRecur(dd,op,fvn,gvn);
if (E == NULL) {
Cudd_RecursiveDeref(dd,T);
return(NULL);
}
cuddRef(E);
res = (T == E) ? T : cuddUniqueInter(dd,(int)index,T,E);
if (res == NULL) {
Cudd_RecursiveDeref(dd, T);
Cudd_RecursiveDeref(dd, E);
return(NULL);
}
cuddDeref(T);
cuddDeref(E);
/* Store result. */
cuddCacheInsert2(dd,cacheOp,f,g,res);
return(res);
} /* end of cuddAddApplyRecur */
/**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 */
/**Function********************************************************************
Synopsis [Performs the recursive step of Dsd_CheckRootFunctionIdentity().]
Description []
SideEffects []
SeeAlso []
******************************************************************************/
int Dsd_CheckRootFunctionIdentity_rec( DdManager * dd, DdNode * bF1, DdNode * bF2, DdNode * bC1, DdNode * bC2 )
{
unsigned HKey;
// if either bC1 or bC2 is zero, the test is true
// if ( bC1 == b0 || bC2 == b0 ) return 1;
assert( bC1 != b0 );
assert( bC2 != b0 );
// if both bC1 and bC2 are one - perform comparison
if ( bC1 == b1 && bC2 == b1 ) return (int)( bF1 == bF2 );
if ( bF1 == b0 )
return Cudd_bddLeq( dd, bC2, Cudd_Not(bF2) );
if ( bF1 == b1 )
return Cudd_bddLeq( dd, bC2, bF2 );
if ( bF2 == b0 )
return Cudd_bddLeq( dd, bC1, Cudd_Not(bF1) );
if ( bF2 == b1 )
return Cudd_bddLeq( dd, bC1, bF1 );
// otherwise, keep expanding
// check cache
// HKey = _Hash( ((unsigned)bF1), ((unsigned)bF2), ((unsigned)bC1), ((unsigned)bC2) );
HKey = hashKey4( bF1, bF2, bC1, bC2, pCache->nTableSize );
if ( pCache->pTable[HKey].bX[0] == bF1 &&
pCache->pTable[HKey].bX[1] == bF2 &&
pCache->pTable[HKey].bX[2] == bC1 &&
pCache->pTable[HKey].bX[3] == bC2 )
{
pCache->nSuccess++;
return (int)(ABC_PTRUINT_T)pCache->pTable[HKey].bX[4]; // the last bit records the result (yes/no)
}
else
{
// determine the top variables
int RetValue;
DdNode * bA[4] = { bF1, bF2, bC1, bC2 }; // arguments
DdNode * bAR[4] = { Cudd_Regular(bF1), Cudd_Regular(bF2), Cudd_Regular(bC1), Cudd_Regular(bC2) }; // regular arguments
int CurLevel[4] = { cuddI(dd,bAR[0]->index), cuddI(dd,bAR[1]->index), cuddI(dd,bAR[2]->index), cuddI(dd,bAR[3]->index) };
int TopLevel = CUDD_CONST_INDEX;
int i;
DdNode * bE[4], * bT[4];
DdNode * bF1next, * bF2next, * bC1next, * bC2next;
pCache->nFailure++;
// determine the top level
for ( i = 0; i < 4; i++ )
if ( TopLevel > CurLevel[i] )
TopLevel = CurLevel[i];
// compute the cofactors
for ( i = 0; i < 4; i++ )
if ( TopLevel == CurLevel[i] )
{
if ( bA[i] != bAR[i] ) // complemented
{
bE[i] = Cudd_Not(cuddE(bAR[i]));
bT[i] = Cudd_Not(cuddT(bAR[i]));
}
else
{
bE[i] = cuddE(bAR[i]);
bT[i] = cuddT(bAR[i]);
}
}
else
bE[i] = bT[i] = bA[i];
// solve subproblems
// three cases are possible
// (1) the top var belongs to both C1 and C2
// in this case, any cofactor of F1 and F2 will do,
// as long as the corresponding cofactor of C1 and C2 is not equal to 0
if ( TopLevel == CurLevel[2] && TopLevel == CurLevel[3] )
{
if ( bE[2] != b0 ) // C1
{
bF1next = bE[0];
bC1next = bE[2];
}
else
{
bF1next = bT[0];
bC1next = bT[2];
}
if ( bE[3] != b0 ) // C2
{
bF2next = bE[1];
bC2next = bE[3];
}
else
{
bF2next = bT[1];
bC2next = bT[3];
}
RetValue = Dsd_CheckRootFunctionIdentity_rec( dd, bF1next, bF2next, bC1next, bC2next );
}
// (2) the top var belongs to either C1 or C2
// in this case normal splitting of cofactors
else if ( TopLevel == CurLevel[2] && TopLevel != CurLevel[3] )
{
if ( bE[2] != b0 ) // C1
{
bF1next = bE[0];
bC1next = bE[2];
}
else
{
bF1next = bT[0];
bC1next = bT[2];
}
// split around this variable
RetValue = Dsd_CheckRootFunctionIdentity_rec( dd, bF1next, bE[1], bC1next, bE[3] );
if ( RetValue == 1 ) // test another branch; otherwise, there is no need to test
RetValue = Dsd_CheckRootFunctionIdentity_rec( dd, bF1next, bT[1], bC1next, bT[3] );
}
else if ( TopLevel != CurLevel[2] && TopLevel == CurLevel[3] )
{
if ( bE[3] != b0 ) // C2
{
bF2next = bE[1];
bC2next = bE[3];
}
else
{
bF2next = bT[1];
bC2next = bT[3];
}
// split around this variable
RetValue = Dsd_CheckRootFunctionIdentity_rec( dd, bE[0], bF2next, bE[2], bC2next );
if ( RetValue == 1 ) // test another branch; otherwise, there is no need to test
RetValue = Dsd_CheckRootFunctionIdentity_rec( dd, bT[0], bF2next, bT[2], bC2next );
}
// (3) the top var does not belong to C1 and C2
// in this case normal splitting of cofactors
else // if ( TopLevel != CurLevel[2] && TopLevel != CurLevel[3] )
{
// split around this variable
RetValue = Dsd_CheckRootFunctionIdentity_rec( dd, bE[0], bE[1], bE[2], bE[3] );
if ( RetValue == 1 ) // test another branch; otherwise, there is no need to test
RetValue = Dsd_CheckRootFunctionIdentity_rec( dd, bT[0], bT[1], bT[2], bT[3] );
}
// set cache
for ( i = 0; i < 4; i++ )
pCache->pTable[HKey].bX[i] = bA[i];
pCache->pTable[HKey].bX[4] = (DdNode*)(ABC_PTRUINT_T)RetValue;
return RetValue;
}
}
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_bddTransfer.]
Description [Performs the recursive step of Cudd_bddTransfer.
Returns a pointer to the result if successful; NULL otherwise.]
SideEffects [None]
SeeAlso [cuddBddTransfer]
******************************************************************************/
static DdNode *
cuddBddTransferRecur(
DdManager * ddS,
DdManager * ddD,
DdNode * f,
st_table * table)
{
DdNode *ft, *fe, *t, *e, *var, *res;
DdNode *one, *zero;
int index;
int comple = 0;
statLine(ddD);
one = DD_TRUE(ddD);
comple = Cudd_IsComplement(f);
/* Trivial cases. */
if (Cudd_IsConstant(f)) return(Cudd_NotCond(one, comple));
/* Make canonical to increase the utilization of the cache. */
f = Cudd_NotCond(f,comple);
/* Now f is a regular pointer to a non-constant node. */
/* Check the cache. */
if(st_lookup(table, f, &res))
return(Cudd_NotCond(res,comple));
/* Recursive step. */
index = f->index;
ft = cuddT(f); fe = cuddE(f);
t = cuddBddTransferRecur(ddS, ddD, ft, table);
if (t == NULL) {
return(NULL);
}
cuddRef(t);
e = cuddBddTransferRecur(ddS, ddD, fe, table);
if (e == NULL) {
Cudd_RecursiveDeref(ddD, t);
return(NULL);
}
cuddRef(e);
zero = Cudd_Not(one);
var = cuddUniqueInter(ddD,index,one,zero);
if (var == NULL) {
Cudd_RecursiveDeref(ddD, t);
Cudd_RecursiveDeref(ddD, e);
return(NULL);
}
res = cuddBddIteRecur(ddD,var,t,e);
if (res == NULL) {
Cudd_RecursiveDeref(ddD, t);
Cudd_RecursiveDeref(ddD, e);
return(NULL);
}
cuddRef(res);
Cudd_RecursiveDeref(ddD, t);
Cudd_RecursiveDeref(ddD, e);
if (st_add_direct(table, (char *) f, (char *) res) == ST_OUT_OF_MEM) {
Cudd_RecursiveDeref(ddD, res);
return(NULL);
}
return(Cudd_NotCond(res,comple));
} /* end of cuddBddTransferRecur */
/**Function********************************************************************
Synopsis [Writes a blif file representing the argument BDDs.]
Description [Writes a blif file representing the argument BDDs as a
network of multiplexers. One multiplexer is written for each BDD
node. It returns 1 in case of success; 0 otherwise (e.g.,
out-of-memory, file system full, or an ADD with constants different
from 0 and 1). Cudd_DumpBlif does not close the file: This is the
caller responsibility. Cudd_DumpBlif uses a minimal unique subset of
the hexadecimal address of a node as name for it. If the argument
inames is non-null, it is assumed to hold the pointers to the names
of the inputs. Similarly for onames.]
SideEffects [None]
SeeAlso [Cudd_DumpBlifBody Cudd_DumpDot Cudd_PrintDebug Cudd_DumpDDcal
Cudd_DumpDaVinci Cudd_DumpFactoredForm]
******************************************************************************/
int
Cudd_DumpBlif(
DdManager * dd /* manager */,
int n /* number of output nodes to be dumped */,
DdNode ** f /* array of output nodes to be dumped */,
char ** inames /* array of input names (or NULL) */,
char ** onames /* array of output names (or NULL) */,
char * mname /* model name (or NULL) */,
FILE * fp /* pointer to the dump file */,
int mv /* 0: blif, 1: blif-MV */)
{
DdNode *support = NULL;
DdNode *scan;
int *sorted = NULL;
int nvars = dd->size;
int retval;
int i;
/* Build a bit array with the support of f. */
sorted = ALLOC(int,nvars);
if (sorted == NULL) {
dd->errorCode = CUDD_MEMORY_OUT;
goto failure;
}
for (i = 0; i < nvars; i++) sorted[i] = 0;
/* Take the union of the supports of each output function. */
support = Cudd_VectorSupport(dd,f,n);
if (support == NULL) goto failure;
cuddRef(support);
scan = support;
while (!cuddIsConstant(scan)) {
sorted[scan->index] = 1;
scan = cuddT(scan);
}
Cudd_RecursiveDeref(dd,support);
support = NULL; /* so that we do not try to free it in case of failure */
/* Write the header (.model .inputs .outputs). */
if (mname == NULL) {
retval = fprintf(fp,".model DD\n.inputs");
} else {
retval = fprintf(fp,".model %s\n.inputs",mname);
}
if (retval == EOF) {
FREE(sorted);
return(0);
}
/* Write the input list by scanning the support array. */
for (i = 0; i < nvars; i++) {
if (sorted[i]) {
if (inames == NULL) {
retval = fprintf(fp," %d", i);
} else {
retval = fprintf(fp," %s", inames[i]);
}
if (retval == EOF) goto failure;
}
}
FREE(sorted);
sorted = NULL;
/* Write the .output line. */
retval = fprintf(fp,"\n.outputs");
if (retval == EOF) goto failure;
for (i = 0; i < n; i++) {
if (onames == NULL) {
retval = fprintf(fp," f%d", i);
} else {
retval = fprintf(fp," %s", onames[i]);
}
if (retval == EOF) goto failure;
}
retval = fprintf(fp,"\n");
if (retval == EOF) goto failure;
retval = Cudd_DumpBlifBody(dd, n, f, inames, onames, fp, mv);
if (retval == 0) goto failure;
/* Write trailer and return. */
retval = fprintf(fp,".end\n");
if (retval == EOF) goto failure;
return(1);
failure:
if (sorted != NULL) FREE(sorted);
if (support != NULL) Cudd_RecursiveDeref(dd,support);
return(0);
} /* end of Cudd_DumpBlif */
/**Function********************************************************************
Synopsis [Performs the recursive step for Cudd_addBddBooleanMap.]
Description [Performs the recursive step for Cudd_addBddBooleanMap.
Returns a pointer to the BDD if successful; NULL otherwise.]
SideEffects [None]
SeeAlso [addBddDoStrictThreshold]
******************************************************************************/
static DdNode *
addBddBooleanMap(
DdManager * dd,
DdNode * f)
{
DdNode *res, *T, *E;
DdNode *fv, *fvn;
int v;
statLine(dd);
/* Check terminal case. */
if (cuddIsConstant(f)) {
if ((f != DD_TRUE(dd)) && (f != DD_FALSE(dd))) {
(void)fprintf(dd->err, "Error: Can only convert Add with FALSE or TRUE leaves to Bdd.");
return(NULL);
}
return(Cudd_NotCond(DD_TRUE(dd), f == DD_FALSE(dd)));
}
/* Check cache. */
res = cuddCacheLookup1(dd,addBddBooleanMap,f);
if (res != NULL) return(res);
/* Recursive step. */
v = f->index;
fv = cuddT(f); fvn = cuddE(f);
T = addBddBooleanMap(dd,fv);
if (T == NULL) return(NULL);
cuddRef(T);
E = addBddBooleanMap(dd,fvn);
if (E == NULL) {
Cudd_RecursiveDeref(dd, T);
return(NULL);
}
cuddRef(E);
if (Cudd_IsComplement(T)) {
res = (T == E) ? Cudd_Not(T) : cuddUniqueInter(dd,v,Cudd_Not(T),Cudd_Not(E));
if (res == NULL) {
Cudd_RecursiveDeref(dd, T);
Cudd_RecursiveDeref(dd, E);
return(NULL);
}
res = Cudd_Not(res);
} else {
res = (T == E) ? T : cuddUniqueInter(dd,v,T,E);
if (res == NULL) {
Cudd_RecursiveDeref(dd, T);
Cudd_RecursiveDeref(dd, E);
return(NULL);
}
}
cuddDeref(T);
cuddDeref(E);
/* Store result. */
cuddCacheInsert1(dd,addBddBooleanMap,f,res);
return(res);
} /* end of addBddBooleanMap */
/**Function********************************************************************
Synopsis [Performs the reordering-sensitive step of Extra_bddWalsh().]
Description [Generates in a bottom-up fashion an ADD for all spectral
coefficients of the functions represented by a BDD.]
SideEffects []
SeeAlso []
******************************************************************************/
DdNode* extraBddWalsh(
DdManager * dd, /* the manager */
DdNode * bFunc, /* the function whose spectrum is being computed */
DdNode * bVars) /* the variables on which the function depends */
{
DdNode * aRes;
statLine(dd);
if ( clock() > s_TimeLimit )
return NULL;
/* terminal cases */
if ( bVars == b1 )
{
assert( Cudd_IsConstant(bFunc) );
if ( bFunc == b0 )
return a1;
else
return Cudd_addConst(dd,-1.0);
}
/* check cache */
// if ( bFunc->ref != 1 )
if ( ( aRes = cuddCacheLookup2(dd, extraBddWalsh, bFunc, bVars) ) )
{
s_CacheHit++;
return aRes;
}
else
{
DdNode * bFunc0, * bFunc1; /* cofactors of the function */
DdNode * aWalsh0, * aWalsh1; /* partial solutions of the problem */
DdNode * aRes0, * aRes1; /* partial results to be composed by ITE */
DdNode * bFuncR = Cudd_Regular(bFunc); /* the regular pointer to the function */
s_CacheMiss++;
/* bFunc cannot depend on a variable that is not in bVars */
assert( cuddI(dd,bFuncR->index) >= cuddI(dd,bVars->index) );
/* cofactor the BDD */
if ( bFuncR->index == bVars->index )
{
if ( bFuncR != bFunc ) /* bFunc is complemented */
{
bFunc0 = Cudd_Not( cuddE(bFuncR) );
bFunc1 = Cudd_Not( cuddT(bFuncR) );
}
else
{
bFunc0 = cuddE(bFuncR);
bFunc1 = cuddT(bFuncR);
}
}
else /* bVars is higher in the variable order */
bFunc0 = bFunc1 = bFunc;
/* solve subproblems */
aWalsh0 = extraBddWalsh( dd, bFunc0, cuddT(bVars) );
if ( aWalsh0 == NULL )
return NULL;
cuddRef( aWalsh0 );
aWalsh1 = extraBddWalsh( dd, bFunc1, cuddT(bVars) );
if ( aWalsh1 == NULL )
{
Cudd_RecursiveDeref( dd, aWalsh0 );
return NULL;
}
cuddRef( aWalsh1 );
/* compute aRes0 = aWalsh0 + aWalsh1 */
aRes0 = cuddAddApplyRecur( dd, Cudd_addPlus, aWalsh0, aWalsh1 );
if ( aRes0 == NULL )
{
Cudd_RecursiveDeref( dd, aWalsh0 );
Cudd_RecursiveDeref( dd, aWalsh1 );
return NULL;
}
cuddRef( aRes0 );
/* compute aRes1 = aWalsh0 - aWalsh1 */
aRes1 = cuddAddApplyRecur( dd, Cudd_addMinus, aWalsh0, aWalsh1 );
if ( aRes1 == NULL )
{
Cudd_RecursiveDeref( dd, aWalsh0 );
Cudd_RecursiveDeref( dd, aWalsh1 );
Cudd_RecursiveDeref( dd, aRes0 );
return NULL;
}
cuddRef( aRes1 );
Cudd_RecursiveDeref(dd, aWalsh0);
Cudd_RecursiveDeref(dd, aWalsh1);
/* only aRes0 and aRes1 are referenced at this point */
/* consider the case when Res0 and Res1 are the same node */
aRes = (aRes1 == aRes0) ? aRes1 : cuddUniqueInter( dd, bVars->index, aRes1, aRes0 );
if (aRes == NULL)
{
Cudd_RecursiveDeref(dd, aRes1);
Cudd_RecursiveDeref(dd, aRes0);
return NULL;
}
cuddDeref(aRes1);
cuddDeref(aRes0);
/* insert the result into cache */
// if ( bFunc->ref != 1 )
cuddCacheInsert2(dd, extraBddWalsh, bFunc, bVars, aRes);
return aRes;
}
} /* end of extraBddWalsh */
