/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_zddChange.]
Description []
SideEffects [None]
SeeAlso []
******************************************************************************/
DdNode *
cuddZddChangeAux(
DdManager * zdd,
DdNode * P,
DdNode * zvar)
{
int top_var, level;
DdNode *res, *t, *e;
DdNode *base = DD_ONE(zdd);
DdNode *empty = DD_ZERO(zdd);
statLine(zdd);
if (P == empty)
return(empty);
if (P == base)
return(zvar);
/* Check cache. */
res = cuddCacheLookup2Zdd(zdd, cuddZddChangeAux, P, zvar);
if (res != NULL)
return(res);
top_var = zdd->permZ[P->index];
level = zdd->permZ[zvar->index];
if (top_var > level) {
res = cuddZddGetNode(zdd, zvar->index, P, DD_ZERO(zdd));
if (res == NULL) return(NULL);
} else if (top_var == level) {
res = cuddZddGetNode(zdd, zvar->index, cuddE(P), cuddT(P));
if (res == NULL) return(NULL);
} else {
t = cuddZddChangeAux(zdd, cuddT(P), zvar);
if (t == NULL) return(NULL);
cuddRef(t);
e = cuddZddChangeAux(zdd, cuddE(P), zvar);
if (e == NULL) {
Cudd_RecursiveDerefZdd(zdd, t);
return(NULL);
}
cuddRef(e);
res = cuddZddGetNode(zdd, P->index, t, e);
if (res == NULL) {
Cudd_RecursiveDerefZdd(zdd, t);
Cudd_RecursiveDerefZdd(zdd, e);
return(NULL);
}
cuddDeref(t);
cuddDeref(e);
}
cuddCacheInsert2(zdd, cuddZddChangeAux, P, zvar, res);
return(res);
} /* end of cuddZddChangeAux */
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_zddSubset1.]
Description []
SideEffects [None]
SeeAlso []
******************************************************************************/
static DdNode *
zdd_subset1_aux(
DdManager * zdd,
DdNode * P,
DdNode * zvar)
{
int top_var, level;
DdNode *res, *t, *e;
DdNode *empty;
statLine(zdd);
empty = DD_ZERO(zdd);
/* Check cache. */
res = cuddCacheLookup2Zdd(zdd, zdd_subset1_aux, P, zvar);
if (res != NULL)
return(res);
if (cuddIsConstant(P)) {
res = empty;
cuddCacheInsert2(zdd, zdd_subset1_aux, P, zvar, res);
return(res);
}
top_var = zdd->permZ[P->index];
level = zdd->permZ[zvar->index];
if (top_var > level) {
res = empty;
} else if (top_var == level) {
res = cuddT(P);
} else {
t = zdd_subset1_aux(zdd, cuddT(P), zvar);
if (t == NULL) return(NULL);
cuddRef(t);
e = zdd_subset1_aux(zdd, cuddE(P), zvar);
if (e == NULL) {
Cudd_RecursiveDerefZdd(zdd, t);
return(NULL);
}
cuddRef(e);
res = cuddZddGetNode(zdd, P->index, t, e);
if (res == NULL) {
Cudd_RecursiveDerefZdd(zdd, t);
Cudd_RecursiveDerefZdd(zdd, e);
return(NULL);
}
cuddDeref(t);
cuddDeref(e);
}
cuddCacheInsert2(zdd, zdd_subset1_aux, P, zvar, res);
return(res);
} /* end of zdd_subset1_aux */
/**Function********************************************************************
Synopsis [Classifies the variables in the support of two DDs.]
Description [Classifies the variables in the support of two DDs
<code>f</code> and <code>g</code>, depending on whther they appear
in both DDs, only in <code>f</code>, or only in <code>g</code>.
Returns 1 if successful; 0 otherwise.]
SideEffects [The cubes of the three classes of variables are
returned as side effects.]
SeeAlso []
******************************************************************************/
int
Cuddaux_ClassifySupport(
DdManager * dd /* manager */,
DdNode * f /* first DD */,
DdNode * g /* second DD */,
DdNode ** common /* cube of shared variables */,
DdNode ** onlyF /* cube of variables only in f */,
DdNode ** onlyG /* cube of variables only in g */)
{
DdNode *suppF, *suppG;
suppF = suppG = *common = *onlyF = *onlyG = NULL;
suppF = Cuddaux_Support(dd,f);
if (suppF == NULL) goto Cuddaux_ClassifySupport_error;
cuddRef(suppF);
suppG = Cuddaux_Support(dd,g);
if (suppG == NULL) goto Cuddaux_ClassifySupport_error;
cuddRef(suppG);
*common = Cudd_bddLiteralSetIntersection(dd,suppF,suppG);
if (*common == NULL) goto Cuddaux_ClassifySupport_error;
cuddRef(*common);
*onlyF = Cudd_Cofactor(dd,suppF,*common);
if (*onlyF == NULL) goto Cuddaux_ClassifySupport_error;
cuddRef(*onlyF);
*onlyG = Cudd_Cofactor(dd,suppG,*common);
if (*onlyG == NULL) goto Cuddaux_ClassifySupport_error;
cuddRef(*onlyG);
Cudd_IterDerefBdd(dd,suppF);
Cudd_IterDerefBdd(dd,suppG);
cuddDeref(*common);
cuddDeref(*onlyF);
cuddDeref(*onlyG);
return 1;
Cuddaux_ClassifySupport_error:
if (suppF) Cudd_IterDerefBdd(dd,suppF);
if (suppG) Cudd_IterDerefBdd(dd,suppG);
if (*common){
Cudd_IterDerefBdd(dd,*common);
*common = NULL;
}
if (*onlyF){
Cudd_IterDerefBdd(dd,*onlyF);
*onlyF = NULL;
}
if (*onlyG){
Cudd_IterDerefBdd(dd,*onlyG);
*onlyG = NULL;
}
dd->errorCode = CUDD_MEMORY_OUT;
return(0);
} /* end of Cuddaux_ClassifySupport */
/**Function********************************************************************
Synopsis [Performs the recursive steps of Cudd_bddBoleanDiff.]
Description [Performs the recursive steps of Cudd_bddBoleanDiff.
Returns the BDD obtained by XORing the cofactors of f with respect to
var if successful; NULL otherwise. Exploits the fact that dF/dx =
dF'/dx.]
SideEffects [None]
SeeAlso []
******************************************************************************/
DdNode *
cuddBddBooleanDiffRecur(
DdManager * manager,
DdNode * f,
DdNode * var)
{
DdNode *T, *E, *res, *res1, *res2;
statLine(manager);
if (cuddI(manager,f->index) > manager->perm[var->index]) {
/* f does not depend on var. */
return(Cudd_Not(DD_ONE(manager)));
}
/* From now on, f is non-constant. */
/* If the two indices are the same, so are their levels. */
if (f->index == var->index) {
res = cuddBddXorRecur(manager, cuddT(f), cuddE(f));
return(res);
}
/* From now on, cuddI(manager,f->index) < cuddI(manager,cube->index). */
/* Check the cache. */
res = cuddCacheLookup2(manager, cuddBddBooleanDiffRecur, f, var);
if (res != NULL) {
return(res);
}
/* Compute the cofactors of f. */
T = cuddT(f); E = cuddE(f);
res1 = cuddBddBooleanDiffRecur(manager, T, var);
if (res1 == NULL) return(NULL);
cuddRef(res1);
res2 = cuddBddBooleanDiffRecur(manager, Cudd_Regular(E), var);
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);
cuddCacheInsert2(manager, cuddBddBooleanDiffRecur, f, var, res);
return(res);
} /* end of cuddBddBooleanDiffRecur */
/**Function********************************************************************
Synopsis [Performs the recursive step for Cudd_addIthBit.]
Description [Performs the recursive step for Cudd_addIthBit.
Returns a pointer to the BDD if successful; NULL otherwise.]
SideEffects [None]
SeeAlso []
******************************************************************************/
static DdNode *
addDoIthBit(
DdManager * dd,
DdNode * f,
DdNode * index)
{
DdNode *res, *T, *E;
DdNode *fv, *fvn;
int mask, value;
int v;
statLine(dd);
/* Check terminal case. */
if (cuddIsConstant(f)) {
mask = 1 << ((int) cuddV(index));
value = (int) cuddV(f);
return((value & mask) == 0 ? DD_ZERO(dd) : DD_ONE(dd));
}
/* Check cache. */
res = cuddCacheLookup2(dd,addDoIthBit,f,index);
if (res != NULL) return(res);
/* Recursive step. */
v = f->index;
fv = cuddT(f); fvn = cuddE(f);
T = addDoIthBit(dd,fv,index);
if (T == NULL) return(NULL);
cuddRef(T);
E = addDoIthBit(dd,fvn,index);
if (E == NULL) {
Cudd_RecursiveDeref(dd, T);
return(NULL);
}
cuddRef(E);
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. */
cuddCacheInsert2(dd,addDoIthBit,f,index,res);
return(res);
} /* end of addDoIthBit */
/**Function********************************************************************
Synopsis [This function prepares an array of variables which have not been
encountered so far when traversing the procedure cuddSplitSetRecur.]
Description [This function prepares an array of variables which have not been
encountered so far when traversing the procedure cuddSplitSetRecur. This
array is then used to extract the required number of minterms from a constant
1. The algorithm guarantees that the size of BDD will be utmost \log(n).]
SideEffects [None]
******************************************************************************/
static DdNode *
selectMintermsFromUniverse(
DdManager * manager,
int * varSeen,
double n)
{
int numVars;
int i, size, j;
DdNode *one, *zero, *result;
DdNode **vars;
numVars = 0;
size = manager->size;
one = DD_ONE(manager);
zero = Cudd_Not(one);
/* Count the number of variables not encountered so far in procedure
** cuddSplitSetRecur.
*/
for (i = size-1; i >= 0; i--) {
if(varSeen[i] == 0)
numVars++;
}
vars = ALLOC(DdNode *, numVars);
if (!vars) {
manager->errorCode = CUDD_MEMORY_OUT;
return(NULL);
}
j = 0;
for (i = size-1; i >= 0; i--) {
if(varSeen[i] == 0) {
vars[j] = cuddUniqueInter(manager,manager->perm[i],one,zero);
cuddRef(vars[j]);
j++;
}
}
/* Compute a function which has n minterms and depends on at most
** numVars variables.
*/
result = mintermsFromUniverse(manager,vars,numVars,n, 0);
if (result)
cuddRef(result);
for (i = 0; i < numVars; i++)
Cudd_RecursiveDeref(manager,vars[i]);
FREE(vars);
return(result);
} /* end of selectMintermsFromUniverse */
/**
@brief Implements the recursive step of Cudd_addRoundOff.
@return a pointer to the result.
@sideeffect None
*/
DdNode *
cuddAddRoundOffRecur(
DdManager * dd,
DdNode * f,
double trunc)
{
DdNode *res, *fv, *fvn, *T, *E;
double n;
DD_CTFP1 cacheOp;
statLine(dd);
if (cuddIsConstant(f)) {
n = ceil(cuddV(f)*trunc)/trunc;
res = cuddUniqueConst(dd,n);
return(res);
}
cacheOp = (DD_CTFP1) Cudd_addRoundOff;
res = cuddCacheLookup1(dd,cacheOp,f);
if (res != NULL) {
return(res);
}
checkWhetherToGiveUp(dd);
/* Recursive Step */
fv = cuddT(f);
fvn = cuddE(f);
T = cuddAddRoundOffRecur(dd,fv,trunc);
if (T == NULL) {
return(NULL);
}
cuddRef(T);
E = cuddAddRoundOffRecur(dd,fvn,trunc);
if (E == NULL) {
Cudd_RecursiveDeref(dd,T);
return(NULL);
}
cuddRef(E);
res = (T == E) ? T : cuddUniqueInter(dd,(int)f->index,T,E);
if (res == NULL) {
Cudd_RecursiveDeref(dd,T);
Cudd_RecursiveDeref(dd,E);
return(NULL);
}
cuddDeref(T);
cuddDeref(E);
/* Store result. */
cuddCacheInsert1(dd,cacheOp,f,res);
return(res);
} /* end of cuddAddRoundOffRecur */
DdNode *
cuddAddMonadicApplyWithDataRecur(
DdManager * dd,
DD_MAOPD op,
DdNode * f,
void * data)
{
DdNode *res, *ft, *fe, *T, *E;
unsigned int index;
/* Check terminal cases. */
statLine(dd);
res = (*op)(dd,f, data);
if (res != NULL) return(res);
/* Check cache. */
res = cuddCacheLookup1(dd,(DD_MAOP)global_bloody_counter_unary,f);
if (res != NULL) return(res);
/* Recursive step. */
index = f->index;
ft = cuddT(f);
fe = cuddE(f);
T = cuddAddMonadicApplyWithDataRecur(dd,op,ft, data);
if (T == NULL) return(NULL);
cuddRef(T);
E = cuddAddMonadicApplyWithDataRecur(dd,op,fe, data);
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. */
cuddCacheInsert1(dd,(DD_MAOP)global_bloody_counter_unary,f,res);
return(res);
} /* end of cuddAddMonadicApplyWithDataRecur */
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_addMonadicApply.]
Description [Performs the recursive step of Cudd_addMonadicApply. Returns a
pointer to the result if successful; NULL otherwise.]
SideEffects [None]
SeeAlso [cuddAddApplyRecur]
******************************************************************************/
DdNode *
cuddAddMonadicApplyRecur(
DdManager * dd,
DdNode * (*op)(DdManager *, DdNode *),
DdNode * f)
{
DdNode *res, *ft, *fe, *T, *E;
unsigned int ford;
unsigned int index;
/* Check terminal cases. */
statLine(dd);
res = (*op)(dd,f);
if (res != NULL) return(res);
/* Check cache. */
res = cuddCacheLookup1(dd,op,f);
if (res != NULL) return(res);
/* Recursive step. */
ford = cuddI(dd,f->index);
index = f->index;
ft = cuddT(f);
fe = cuddE(f);
T = cuddAddMonadicApplyRecur(dd,op,ft);
if (T == NULL) return(NULL);
cuddRef(T);
E = cuddAddMonadicApplyRecur(dd,op,fe);
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. */
cuddCacheInsert1(dd,op,f,res);
return(res);
} /* end of cuddAddMonadicApplyRecur */
/**
@brief Implements the recursive step of Cudd_addNegate.
@return a pointer to the result.
@sideeffect None
*/
DdNode *
cuddAddNegateRecur(
DdManager * dd,
DdNode * f)
{
DdNode *res,
*fv, *fvn,
*T, *E;
statLine(dd);
/* Check terminal cases. */
if (cuddIsConstant(f)) {
res = cuddUniqueConst(dd,-cuddV(f));
return(res);
}
/* Check cache */
res = cuddCacheLookup1(dd,Cudd_addNegate,f);
if (res != NULL) return(res);
checkWhetherToGiveUp(dd);
/* Recursive Step */
fv = cuddT(f);
fvn = cuddE(f);
T = cuddAddNegateRecur(dd,fv);
if (T == NULL) return(NULL);
cuddRef(T);
E = cuddAddNegateRecur(dd,fvn);
if (E == NULL) {
Cudd_RecursiveDeref(dd,T);
return(NULL);
}
cuddRef(E);
res = (T == E) ? T : cuddUniqueInter(dd,(int)f->index,T,E);
if (res == NULL) {
Cudd_RecursiveDeref(dd, T);
Cudd_RecursiveDeref(dd, E);
return(NULL);
}
cuddDeref(T);
cuddDeref(E);
/* Store result. */
cuddCacheInsert1(dd,Cudd_addNegate,f,res);
return(res);
} /* end of cuddAddNegateRecur */
/**Function********************************************************************
Synopsis [Generates a BDD for the function x > y.]
Description [This function generates a BDD for the function x > y.
Both x and y are N-bit numbers, x\[0\] x\[1\] ... x\[N-1\] and
y\[0\] y\[1\] ... y\[N-1\], with 0 the most significant bit.
The BDD is built bottom-up.
It has 3*N-1 internal nodes, if the variables are ordered as follows:
x\[0\] y\[0\] x\[1\] y\[1\] ... x\[N-1\] y\[N-1\].
Argument z is not used by Cudd_Xgty: it is included to make it
call-compatible to Cudd_Dxygtdxz and Cudd_Dxygtdyz.]
SideEffects [None]
SeeAlso [Cudd_PrioritySelect Cudd_Dxygtdxz Cudd_Dxygtdyz]
******************************************************************************/
DdNode *
Cudd_Xgty(
DdManager * dd /* DD manager */,
int N /* number of x and y variables */,
DdNode ** z /* array of z variables: unused */,
DdNode ** x /* array of x variables */,
DdNode ** y /* array of y variables */)
{
DdNode *u, *v, *w;
int i;
/* Build bottom part of BDD outside loop. */
u = Cudd_bddAnd(dd, x[N-1], Cudd_Not(y[N-1]));
if (u == NULL) return(NULL);
cuddRef(u);
/* Loop to build the rest of the BDD. */
for (i = N-2; i >= 0; i--) {
v = Cudd_bddAnd(dd, y[i], Cudd_Not(u));
if (v == NULL) {
Cudd_RecursiveDeref(dd, u);
return(NULL);
}
cuddRef(v);
w = Cudd_bddAnd(dd, Cudd_Not(y[i]), u);
if (w == NULL) {
Cudd_RecursiveDeref(dd, u);
Cudd_RecursiveDeref(dd, v);
return(NULL);
}
cuddRef(w);
Cudd_RecursiveDeref(dd, u);
u = Cudd_bddIte(dd, x[i], Cudd_Not(v), w);
if (u == NULL) {
Cudd_RecursiveDeref(dd, v);
Cudd_RecursiveDeref(dd, w);
return(NULL);
}
cuddRef(u);
Cudd_RecursiveDeref(dd, v);
Cudd_RecursiveDeref(dd, w);
}
cuddDeref(u);
return(u);
} /* end of Cudd_Xgty */
/**
@brief Performs the recursive step of addScalarInverse.
@return a pointer to the resulting %ADD in case of success. Returns
NULL if any discriminants smaller than epsilon is encountered.
@sideeffect None
*/
DdNode *
cuddAddScalarInverseRecur(
DdManager * dd,
DdNode * f,
DdNode * epsilon)
{
DdNode *t, *e, *res;
CUDD_VALUE_TYPE value;
statLine(dd);
if (cuddIsConstant(f)) {
if (ddAbs(cuddV(f)) < cuddV(epsilon)) return(NULL);
value = 1.0 / cuddV(f);
res = cuddUniqueConst(dd,value);
return(res);
}
res = cuddCacheLookup2(dd,Cudd_addScalarInverse,f,epsilon);
if (res != NULL) return(res);
checkWhetherToGiveUp(dd);
t = cuddAddScalarInverseRecur(dd,cuddT(f),epsilon);
if (t == NULL) return(NULL);
cuddRef(t);
e = cuddAddScalarInverseRecur(dd,cuddE(f),epsilon);
if (e == NULL) {
Cudd_RecursiveDeref(dd, t);
return(NULL);
}
cuddRef(e);
res = (t == e) ? t : cuddUniqueInter(dd,(int)f->index,t,e);
if (res == NULL) {
Cudd_RecursiveDeref(dd, t);
Cudd_RecursiveDeref(dd, e);
return(NULL);
}
cuddDeref(t);
cuddDeref(e);
cuddCacheInsert2(dd,Cudd_addScalarInverse,f,epsilon,res);
return(res);
} /* end of cuddAddScalarInverseRecur */
/**Function********************************************************************
Synopsis [Performs a recursive step of Extra_zddGetSingletons.]
Description [Returns the set of ZDD singletons, containing those positive
polarity ZDD variables that correspond to the BDD variables in bVars.]
SideEffects []
SeeAlso []
******************************************************************************/
DdNode * extraZddGetSingletons(
DdManager * dd, /* the DD manager */
DdNode * bVars) /* the set of variables */
{
DdNode * zRes;
if ( bVars == b1 )
// if ( bVars == b0 ) // bug fixed by Jin Zhang, Jan 23, 2004
return z1;
if ( (zRes = cuddCacheLookup1Zdd(dd, extraZddGetSingletons, bVars)) )
return zRes;
else
{
DdNode * zTemp, * zPlus;
// solve subproblem
zRes = extraZddGetSingletons( dd, cuddT(bVars) );
if ( zRes == NULL )
return NULL;
cuddRef( zRes );
zPlus = cuddZddGetNode( dd, 2*bVars->index, z1, z0 );
if ( zPlus == NULL )
{
Cudd_RecursiveDerefZdd( dd, zRes );
return NULL;
}
cuddRef( zPlus );
// add these to the result
zRes = cuddZddUnion( dd, zTemp = zRes, zPlus );
if ( zRes == NULL )
{
Cudd_RecursiveDerefZdd( dd, zTemp );
Cudd_RecursiveDerefZdd( dd, zPlus );
return NULL;
}
cuddRef( zRes );
Cudd_RecursiveDerefZdd( dd, zTemp );
Cudd_RecursiveDerefZdd( dd, zPlus );
cuddDeref( zRes );
cuddCacheInsert1( dd, extraZddGetSingletons, bVars, zRes );
return zRes;
}
} /* end of extraZddGetSingletons */
/**Function*************************************************************
Synopsis [Performs the recursive step of Extra_bddSpaceCanonVars().]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
DdNode * extraBddSpaceCanonVars( DdManager * dd, DdNode * bF )
{
DdNode * bRes, * bFR;
statLine( dd );
bFR = Cudd_Regular(bF);
if ( cuddIsConstant(bFR) )
return bF;
if ( (bRes = cuddCacheLookup1(dd, extraBddSpaceCanonVars, bF)) )
return bRes;
else
{
DdNode * bF0, * bF1;
DdNode * bRes, * bRes0;
if ( bFR != bF ) // bF is complemented
{
bF0 = Cudd_Not( cuddE(bFR) );
bF1 = Cudd_Not( cuddT(bFR) );
}
else
{
bF0 = cuddE(bFR);
bF1 = cuddT(bFR);
}
if ( bF0 == b0 )
{
bRes = extraBddSpaceCanonVars( dd, bF1 );
if ( bRes == NULL )
return NULL;
}
else if ( bF1 == b0 )
{
bRes = extraBddSpaceCanonVars( dd, bF0 );
if ( bRes == NULL )
return NULL;
}
else
{
bRes0 = extraBddSpaceCanonVars( dd, bF0 );
if ( bRes0 == NULL )
return NULL;
cuddRef( bRes0 );
bRes = cuddUniqueInter( dd, bFR->index, bRes0, b0 );
if ( bRes == NULL )
{
Cudd_RecursiveDeref( dd,bRes0 );
return NULL;
}
cuddDeref( bRes0 );
}
cuddCacheInsert1( dd, extraBddSpaceCanonVars, bF, bRes );
return bRes;
}
}
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_addCmpl.]
Description [Performs the recursive step of Cudd_addCmpl. Returns a
pointer to the resulting ADD if successful; NULL otherwise.]
SideEffects [None]
SeeAlso [Cudd_addCmpl]
******************************************************************************/
DdNode *
cuddAddCmplRecur(
DdManager * dd,
DdNode * f)
{
DdNode *one,*zero;
DdNode *r,*Fv,*Fnv,*t,*e;
statLine(dd);
one = DD_ONE(dd);
zero = DD_ZERO(dd);
if (cuddIsConstant(f)) {
if (f == zero) {
return(one);
} else {
return(zero);
}
}
r = cuddCacheLookup1(dd,Cudd_addCmpl,f);
if (r != NULL) {
return(r);
}
Fv = cuddT(f);
Fnv = cuddE(f);
t = cuddAddCmplRecur(dd,Fv);
if (t == NULL) return(NULL);
cuddRef(t);
e = cuddAddCmplRecur(dd,Fnv);
if (e == NULL) {
Cudd_RecursiveDeref(dd,t);
return(NULL);
}
cuddRef(e);
r = (t == e) ? t : cuddUniqueInter(dd,(int)f->index,t,e);
if (r == NULL) {
Cudd_RecursiveDeref(dd, t);
Cudd_RecursiveDeref(dd, e);
return(NULL);
}
cuddDeref(t);
cuddDeref(e);
cuddCacheInsert1(dd,Cudd_addCmpl,f,r);
return(r);
} /* end of cuddAddCmplRecur */
/**Function********************************************************************
Synopsis [Computes the Hamming distance ADD.]
Description [Computes the Hamming distance ADD. Returns an ADD that
gives the Hamming distance between its two arguments if successful;
NULL otherwise. The two vectors xVars and yVars identify the variables
that form the two arguments.]
SideEffects [None]
SeeAlso []
******************************************************************************/
DdNode *
Cudd_addHamming(
DdManager * dd,
DdNode ** xVars,
DdNode ** yVars,
int nVars)
{
DdNode *result,*tempBdd;
DdNode *tempAdd,*temp;
int i;
result = DD_ZERO(dd);
cuddRef(result);
for (i = 0; i < nVars; i++) {
tempBdd = Cudd_bddIte(dd,xVars[i],Cudd_Not(yVars[i]),yVars[i]);
if (tempBdd == NULL) {
Cudd_RecursiveDeref(dd,result);
return(NULL);
}
cuddRef(tempBdd);
tempAdd = Cudd_BddToAdd(dd,tempBdd);
if (tempAdd == NULL) {
Cudd_RecursiveDeref(dd,tempBdd);
Cudd_RecursiveDeref(dd,result);
return(NULL);
}
cuddRef(tempAdd);
Cudd_RecursiveDeref(dd,tempBdd);
temp = Cudd_addApply(dd,Cudd_addPlus,tempAdd,result);
if (temp == NULL) {
Cudd_RecursiveDeref(dd,tempAdd);
Cudd_RecursiveDeref(dd,result);
return(NULL);
}
cuddRef(temp);
Cudd_RecursiveDeref(dd,tempAdd);
Cudd_RecursiveDeref(dd,result);
result = temp;
}
cuddDeref(result);
return(result);
} /* end of Cudd_addHamming */
/**Function********************************************************************
Synopsis [Converts an ADD to a BDD.]
Description [Converts an ADD to a BDD by replacing all
discriminants greater than or equal to lower and less than or equal to
upper with 1, and all other discriminants with 0. Returns a pointer to
the resulting BDD if successful; NULL otherwise.]
SideEffects [None]
SeeAlso [Cudd_addBddThreshold Cudd_addBddStrictThreshold
Cudd_addBddPattern Cudd_BddToAdd]
******************************************************************************/
DdNode *
Cudd_addBddInterval(
DdManager * dd,
DdNode * f,
CUDD_VALUE_TYPE lower,
CUDD_VALUE_TYPE upper)
{
DdNode *res;
DdNode *l;
DdNode *u;
/* NuSMV: begin add */
abort(); /* NOT USED BY NUSMV */
/* NuSMV: begin end */
/* Create constant nodes for the interval bounds, so that we can use
** the global cache.
*/
l = cuddUniqueConst(dd,lower);
if (l == NULL) return(NULL);
cuddRef(l);
u = cuddUniqueConst(dd,upper);
if (u == NULL) {
Cudd_RecursiveDeref(dd,l);
return(NULL);
}
cuddRef(u);
do {
dd->reordered = 0;
res = addBddDoInterval(dd, f, l, u);
} while (dd->reordered == 1);
if (res == NULL) {
Cudd_RecursiveDeref(dd, l);
Cudd_RecursiveDeref(dd, u);
return(NULL);
}
cuddRef(res);
Cudd_RecursiveDeref(dd, l);
Cudd_RecursiveDeref(dd, u);
cuddDeref(res);
return(res);
} /* end of Cudd_addBddInterval */
/**Function********************************************************************
Synopsis [Initializes the ZDD universe.]
Description [Initializes the ZDD universe. Returns 1 if successful; 0
otherwise.]
SideEffects [None]
SeeAlso [cuddZddFreeUniv]
******************************************************************************/
int
cuddZddInitUniv(
DdManager * zdd)
{
DdNode *p, *res;
int i;
#ifdef __osf__
#pragma pointer_size save
#pragma pointer_size short
#endif
zdd->univ = ALLOC(DdNode *, zdd->sizeZ);
#ifdef __osf__
#pragma pointer_size restore
#endif
if (zdd->univ == NULL) {
zdd->errorCode = CUDD_MEMORY_OUT;
return(0);
}
res = DD_ONE(zdd);
cuddRef(res);
for (i = zdd->sizeZ - 1; i >= 0; i--) {
unsigned int index = zdd->invpermZ[i];
p = res;
res = cuddUniqueInterZdd(zdd, index, p, p);
if (res == NULL) {
Cudd_RecursiveDerefZdd(zdd,p);
FREE(zdd->univ);
return(0);
}
cuddRef(res);
cuddDeref(p);
zdd->univ[i] = res;
}
#ifdef DD_VERBOSE
cuddZddP(zdd, zdd->univ[0]);
#endif
return(1);
} /* end of cuddZddInitUniv */
/**Function********************************************************************
Synopsis [Finds the number of variables on which a DD depends, using Cuddaux_Support.]
Description []
SideEffects [None]
SeeAlso [Cudd_SupportSize]
******************************************************************************/
int Cuddaux_SupportSize(DdManager* dd, DdNode* f)
{
DdNode* res;
int size;
res = Cuddaux_Support(dd,f);
cuddRef(res);
size = Cudd_DagSize(res) - 1;
assert(size>=0);
Cudd_IterDerefBdd(dd,res);
return size;
}
/**Function********************************************************************
Synopsis [Computes the compatible projection of R w.r.t. cube Y.]
Description [Computes the compatible projection of relation R with
respect to cube Y. Returns a pointer to the c-projection if
successful; NULL otherwise. For a comparison between Cudd_CProjection
and Cudd_PrioritySelect, see the documentation of the latter.]
SideEffects [None]
SeeAlso [Cudd_PrioritySelect]
******************************************************************************/
DdNode *
Cudd_CProjection(
DdManager * dd,
DdNode * R,
DdNode * Y)
{
DdNode *res;
DdNode *support;
if (cuddCheckCube(dd,Y) == 0) {
(void) fprintf(dd->err,
"Error: The third argument of Cudd_CProjection should be a cube\n");
dd->errorCode = CUDD_INVALID_ARG;
return(NULL);
}
/* Compute the support of Y, which is used by the abstraction step
** in cuddCProjectionRecur.
*/
support = Cudd_Support(dd,Y);
if (support == NULL) return(NULL);
cuddRef(support);
do {
dd->reordered = 0;
res = cuddCProjectionRecur(dd,R,Y,support);
} while (dd->reordered == 1);
if (res == NULL) {
Cudd_RecursiveDeref(dd,support);
return(NULL);
}
cuddRef(res);
Cudd_RecursiveDeref(dd,support);
cuddDeref(res);
return(res);
} /* end of Cudd_CProjection */
/**Function********************************************************************
Synopsis [Substitutes a variable with its complement in a ZDD.]
Description [Substitutes a variable with its complement in a ZDD.
returns a pointer to the result if successful; NULL
otherwise. cuddZddChange performs the same function as
Cudd_zddChange, but does not restart if reordering has taken
place. Therefore it can be called from within a recursive
procedure.]
SideEffects [None]
SeeAlso [Cudd_zddChange]
******************************************************************************/
DdNode *
cuddZddChange(
DdManager * dd,
DdNode * P,
int var)
{
DdNode *zvar, *res;
zvar = cuddUniqueInterZdd(dd, var, DD_ONE(dd), DD_ZERO(dd));
if (zvar == NULL) return(NULL);
cuddRef(zvar);
res = cuddZddChangeAux(dd, P, zvar);
if (res == NULL) {
Cudd_RecursiveDerefZdd(dd,zvar);
return(NULL);
}
cuddRef(res);
Cudd_RecursiveDerefZdd(dd,zvar);
cuddDeref(res);
return(res);
} /* end of cuddZddChange */
/**Function********************************************************************
Synopsis [Performs the triangulation step for the shortest path
computation.]
Description [Implements the semiring multiplication algorithm used in
the triangulation step for the shortest path computation. f
is assumed to depend on variables x (rows) and z (columns). g is
assumed to depend on variables z (rows) and y (columns). The product
of f and g then depends on x (rows) and y (columns). Only the z
variables have to be explicitly identified; they are the
"abstraction" variables. Returns a pointer to the result if
successful; NULL otherwise. ]
SideEffects [None]
SeeAlso [Cudd_addMatrixMultiply Cudd_bddAndAbstract]
******************************************************************************/
DdNode *
Cudd_addTriangle(
DdManager * dd,
DdNode * f,
DdNode * g,
DdNode ** z,
int nz)
{
int i, nvars, *vars;
DdNode *res, *cube;
nvars = dd->size;
vars = ALLOC(int, nvars);
if (vars == NULL) {
dd->errorCode = CUDD_MEMORY_OUT;
return(NULL);
}
for (i = 0; i < nvars; i++) vars[i] = -1;
for (i = 0; i < nz; i++) vars[z[i]->index] = i;
cube = Cudd_addComputeCube(dd, z, NULL, nz);
if (cube == NULL) {
FREE(vars);
return(NULL);
}
cuddRef(cube);
do {
dd->reordered = 0;
res = addTriangleRecur(dd, f, g, vars, cube);
} while (dd->reordered == 1);
if (res != NULL) cuddRef(res);
Cudd_RecursiveDeref(dd,cube);
if (res != NULL) cuddDeref(res);
FREE(vars);
return(res);
} /* end of Cudd_addTriangle */
/**Function********************************************************************
Synopsis [Performs the recursive step of Extra_zddSelectOneSubset.]
Description []
SideEffects [None]
SeeAlso []
******************************************************************************/
DdNode * extraZddSelectOneSubset(
DdManager * dd,
DdNode * zS )
// selects one subset from the ZDD zS
// returns z0 if and only if zS is an empty set of cubes
{
DdNode * zRes;
if ( zS == z0 ) return z0;
if ( zS == z1 ) return z1;
// check cache
if ( (zRes = cuddCacheLookup1Zdd( dd, extraZddSelectOneSubset, zS )) )
return zRes;
else
{
DdNode * zS0, * zS1, * zTemp;
zS0 = cuddE(zS);
zS1 = cuddT(zS);
if ( zS0 != z0 )
{
zRes = extraZddSelectOneSubset( dd, zS0 );
if ( zRes == NULL )
return NULL;
}
else // if ( zS0 == z0 )
{
assert( zS1 != z0 );
zRes = extraZddSelectOneSubset( dd, zS1 );
if ( zRes == NULL )
return NULL;
cuddRef( zRes );
zRes = cuddZddGetNode( dd, zS->index, zTemp = zRes, z0 );
if ( zRes == NULL )
{
Cudd_RecursiveDerefZdd( dd, zTemp );
return NULL;
}
cuddDeref( zTemp );
}
// insert the result into cache
cuddCacheInsert1( dd, extraZddSelectOneSubset, zS, zRes );
return zRes;
}
} /* end of extraZddSelectOneSubset */
/**Function********************************************************************
Synopsis [Convert a BDD from a manager to another one.]
Description [Convert a BDD from a manager to another one. Returns a
pointer to the BDD in the destination manager if successful; NULL
otherwise.]
SideEffects [None]
SeeAlso [Extra_TransferPermute]
******************************************************************************/
DdNode * extraTransferPermuteTime( DdManager * ddS, DdManager * ddD, DdNode * f, int * Permute, int TimeOut )
{
DdNode *res;
st_table *table = NULL;
st_generator *gen = NULL;
DdNode *key, *value;
table = st_init_table( st_ptrcmp, st_ptrhash );
if ( table == NULL )
goto failure;
res = extraTransferPermuteRecurTime( ddS, ddD, f, table, Permute, TimeOut );
if ( res != NULL )
cuddRef( res );
/* Dereference all elements in the table and dispose of the table.
** This must be done also if res is NULL to avoid leaks in case of
** reordering. */
gen = st_init_gen( table );
if ( gen == NULL )
goto failure;
while ( st_gen( gen, ( const char ** ) &key, ( char ** ) &value ) )
{
Cudd_RecursiveDeref( ddD, value );
}
st_free_gen( gen );
gen = NULL;
st_free_table( table );
table = NULL;
if ( res != NULL )
cuddDeref( res );
return ( res );
failure:
if ( table != NULL )
st_free_table( table );
if ( gen != NULL )
st_free_gen( gen );
return ( NULL );
} /* end of extraTransferPermuteTime */
/**Function********************************************************************
Synopsis [Convert a BDD from a manager to another one.]
Description [Convert a BDD from a manager to another one. Returns a
pointer to the BDD in the destination manager if successful; NULL
otherwise.]
SideEffects [None]
SeeAlso [Cudd_bddTransfer]
******************************************************************************/
DdNode *
cuddBddTransfer(
DdManager * ddS,
DdManager * ddD,
DdNode * f)
{
DdNode *res;
st_table *table = NULL;
st_generator *gen = NULL;
DdNode *key, *value;
/* NuSMV: begin add */
abort(); /* NOT USED BY NUSMV */
/* NuSMV: begin end */
table = st_init_table(st_ptrcmp,st_ptrhash);
if (table == NULL) goto failure;
res = cuddBddTransferRecur(ddS, ddD, f, table);
if (res != NULL) cuddRef(res);
/* Dereference all elements in the table and dispose of the table.
** This must be done also if res is NULL to avoid leaks in case of
** reordering. */
gen = st_init_gen(table);
if (gen == NULL) goto failure;
while (st_gen(gen, &key, &value)) {
Cudd_RecursiveDeref(ddD, value);
}
st_free_gen(gen); gen = NULL;
st_free_table(table); table = NULL;
if (res != NULL) cuddDeref(res);
return(res);
failure:
if (table != NULL) st_free_table(table);
if (gen != NULL) st_free_gen(gen);
return(NULL);
} /* end of cuddBddTransfer */
/**Function********************************************************************
Synopsis [Composes an ADD with a vector of ADDs.]
Description [Given a vector of ADDs, creates a new ADD by substituting the
ADDs for the variables of the ADD f. vectorOn contains ADDs to be substituted
for the x_v and vectorOff the ADDs to be substituted for x_v'. There should
be an entry in vector for each variable in the manager. If no substitution
is sought for a given variable, the corresponding projection function should
be specified in the vector. This function implements simultaneous
composition. Returns a pointer to the resulting ADD if successful; NULL
otherwise.]
SideEffects [None]
SeeAlso [Cudd_addVectorCompose Cudd_addNonSimCompose Cudd_addPermute
Cudd_addCompose Cudd_bddVectorCompose]
******************************************************************************/
DdNode *
Cudd_addGeneralVectorCompose(
DdManager * dd,
DdNode * f,
DdNode ** vectorOn,
DdNode ** vectorOff)
{
DdHashTable *table;
DdNode *res;
int deepest;
int i;
do {
dd->reordered = 0;
/* Initialize local cache. */
table = cuddHashTableInit(dd,1,2);
if (table == NULL) return(NULL);
/* Find deepest real substitution. */
for (deepest = dd->size - 1; deepest >= 0; deepest--) {
i = dd->invperm[deepest];
if (!ddIsIthAddVarPair(dd,vectorOn[i],vectorOff[i],i)) {
break;
}
}
/* Recursively solve the problem. */
res = cuddAddGeneralVectorComposeRecur(dd,table,f,vectorOn,
vectorOff,deepest);
if (res != NULL) cuddRef(res);
/* Dispose of local cache. */
cuddHashTableQuit(table);
} while (dd->reordered == 1);
if (res != NULL) cuddDeref(res);
return(res);
} /* end of Cudd_addGeneralVectorCompose */
/**Function********************************************************************
Synopsis [Permutes the variables of a BDD.]
Description [Given a permutation in array permut, creates a new BDD
with permuted variables. There should be an entry in array permut
for each variable in the manager. The i-th entry of permut holds the
index of the variable that is to substitute the i-th variable.
Returns a pointer to the resulting BDD if successful; NULL
otherwise.]
SideEffects [None]
SeeAlso [Cudd_addPermute Cudd_bddSwapVariables]
******************************************************************************/
DdNode *
Cudd_bddPermute(
DdManager * manager,
DdNode * node,
int * permut)
{
DdHashTable *table;
DdNode *res;
do {
manager->reordered = 0;
table = cuddHashTableInit(manager,1,2);
if (table == NULL) return(NULL);
res = cuddBddPermuteRecur(manager,table,node,permut);
if (res != NULL) cuddRef(res);
/* Dispose of local cache. */
cuddHashTableQuit(table);
} while (manager->reordered == 1);
if (res != NULL) cuddDeref(res);
return(res);
} /* end of Cudd_bddPermute */
/**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 */
/**
@brief Implements the recursive step of Cudd_addWalsh.
@return a pointer to the matrixi if successful; NULL otherwise.
@sideeffect None
@see Cudd_addWalsh
*/
static DdNode *
addWalshInt(
DdManager * dd,
DdNode ** x,
DdNode ** y,
int n)
{
DdNode *one, *minusone;
DdNode *t = NULL, *u, *t1, *u1, *v, *w;
int i;
one = DD_ONE(dd);
if (n == 0) return(one);
/* Build bottom part of ADD outside loop */
minusone = cuddUniqueConst(dd,(CUDD_VALUE_TYPE) -1);
if (minusone == NULL) return(NULL);
cuddRef(minusone);
v = Cudd_addIte(dd, y[n-1], minusone, one);
if (v == NULL) {
Cudd_RecursiveDeref(dd, minusone);
return(NULL);
}
cuddRef(v);
u = Cudd_addIte(dd, x[n-1], v, one);
if (u == NULL) {
Cudd_RecursiveDeref(dd, minusone);
Cudd_RecursiveDeref(dd, v);
return(NULL);
}
cuddRef(u);
Cudd_RecursiveDeref(dd, v);
if (n>1) {
w = Cudd_addIte(dd, y[n-1], one, minusone);
if (w == NULL) {
Cudd_RecursiveDeref(dd, minusone);
Cudd_RecursiveDeref(dd, u);
return(NULL);
}
cuddRef(w);
t = Cudd_addIte(dd, x[n-1], w, minusone);
if (t == NULL) {
Cudd_RecursiveDeref(dd, minusone);
Cudd_RecursiveDeref(dd, u);
Cudd_RecursiveDeref(dd, w);
return(NULL);
}
cuddRef(t);
Cudd_RecursiveDeref(dd, w);
}
cuddDeref(minusone); /* minusone is in the result; it won't die */
/* Loop to build the rest of the ADD */
for (i=n-2; i>=0; i--) {
t1 = t; u1 = u;
v = Cudd_addIte(dd, y[i], t1, u1);
if (v == NULL) {
Cudd_RecursiveDeref(dd, u1);
Cudd_RecursiveDeref(dd, t1);
return(NULL);
}
cuddRef(v);
u = Cudd_addIte(dd, x[i], v, u1);
if (u == NULL) {
Cudd_RecursiveDeref(dd, u1);
Cudd_RecursiveDeref(dd, t1);
Cudd_RecursiveDeref(dd, v);
return(NULL);
}
cuddRef(u);
Cudd_RecursiveDeref(dd, v);
if (i>0) {
w = Cudd_addIte(dd, y[i], u1, t1);
if (w == NULL) {
Cudd_RecursiveDeref(dd, u1);
Cudd_RecursiveDeref(dd, t1);
Cudd_RecursiveDeref(dd, u);
return(NULL);
}
cuddRef(w);
t = Cudd_addIte(dd, x[i], w, t1);
if (u == NULL) {
Cudd_RecursiveDeref(dd, u1);
Cudd_RecursiveDeref(dd, t1);
Cudd_RecursiveDeref(dd, u);
Cudd_RecursiveDeref(dd, w);
return(NULL);
}
cuddRef(t);
Cudd_RecursiveDeref(dd, w);
}
Cudd_RecursiveDeref(dd, u1);
Cudd_RecursiveDeref(dd, t1);
}
cuddDeref(u);
return(u);
} /* end of addWalshInt */
/**
@brief Builds an %ADD for the residue modulo m of an n-bit
number.
@details The modulus must be at least 2, and the number of bits at
least 1. Parameter options specifies whether the MSB should be on top
or the LSB; and whther the number whose residue is computed is in
two's complement notation or not. The macro CUDD_RESIDUE_DEFAULT
specifies LSB on top and unsigned number. The macro CUDD_RESIDUE_MSB
specifies MSB on top, and the macro CUDD_RESIDUE_TC specifies two's
complement residue. To request MSB on top and two's complement residue
simultaneously, one can OR the two macros:
CUDD_RESIDUE_MSB | CUDD_RESIDUE_TC.
@return a pointer to the resulting %ADD if successful; NULL
otherwise.
@sideeffect None
*/
DdNode *
Cudd_addResidue(
DdManager * dd /**< manager */,
int n /**< number of bits */,
int m /**< modulus */,
int options /**< options */,
int top /**< index of top variable */)
{
int msbLsb; /* MSB on top (1) or LSB on top (0) */
int tc; /* two's complement (1) or unsigned (0) */
int i, j, k, t, residue, thisOne, previous, index;
DdNode **array[2], *var, *tmp, *res;
/* Sanity check. */
if (n < 1 && m < 2) return(NULL);
msbLsb = options & CUDD_RESIDUE_MSB;
tc = options & CUDD_RESIDUE_TC;
/* Allocate and initialize working arrays. */
array[0] = ALLOC(DdNode *,m);
if (array[0] == NULL) {
dd->errorCode = CUDD_MEMORY_OUT;
return(NULL);
}
array[1] = ALLOC(DdNode *,m);
if (array[1] == NULL) {
FREE(array[0]);
dd->errorCode = CUDD_MEMORY_OUT;
return(NULL);
}
for (i = 0; i < m; i++) {
array[0][i] = array[1][i] = NULL;
}
/* Initialize residues. */
for (i = 0; i < m; i++) {
tmp = cuddUniqueConst(dd,(CUDD_VALUE_TYPE) i);
if (tmp == NULL) {
for (j = 0; j < i; j++) {
Cudd_RecursiveDeref(dd,array[1][j]);
}
FREE(array[0]);
FREE(array[1]);
return(NULL);
}
cuddRef(tmp);
array[1][i] = tmp;
}
/* Main iteration. */
residue = 1; /* residue of 2**0 */
for (k = 0; k < n; k++) {
/* Choose current and previous arrays. */
thisOne = k & 1;
previous = thisOne ^ 1;
/* Build an ADD projection function. */
if (msbLsb) {
index = top+n-k-1;
} else {
index = top+k;
}
var = cuddUniqueInter(dd,index,DD_ONE(dd),DD_ZERO(dd));
if (var == NULL) {
for (j = 0; j < m; j++) {
Cudd_RecursiveDeref(dd,array[previous][j]);
}
FREE(array[0]);
FREE(array[1]);
return(NULL);
}
cuddRef(var);
for (i = 0; i < m; i ++) {
t = (i + residue) % m;
tmp = Cudd_addIte(dd,var,array[previous][t],array[previous][i]);
if (tmp == NULL) {
for (j = 0; j < i; j++) {
Cudd_RecursiveDeref(dd,array[thisOne][j]);
}
for (j = 0; j < m; j++) {
Cudd_RecursiveDeref(dd,array[previous][j]);
}
FREE(array[0]);
FREE(array[1]);
return(NULL);
}
cuddRef(tmp);
array[thisOne][i] = tmp;
}
/* One layer completed. Free the other array for the next iteration. */
for (i = 0; i < m; i++) {
Cudd_RecursiveDeref(dd,array[previous][i]);
}
Cudd_RecursiveDeref(dd,var);
/* Update residue of 2**k. */
residue = (2 * residue) % m;
/* Adjust residue for MSB, if this is a two's complement number. */
if (tc && (k == n - 1)) {
residue = (m - residue) % m;
}
}
/* We are only interested in the 0-residue node of the top layer. */
for (i = 1; i < m; i++) {
Cudd_RecursiveDeref(dd,array[(n - 1) & 1][i]);
}
res = array[(n - 1) & 1][0];
FREE(array[0]);
FREE(array[1]);
cuddDeref(res);
return(res);
} /* end of Cudd_addResidue */
