/**Function********************************************************************
Synopsis [Returns the minimum Hamming distance between f and minterm.]
Description [Returns the minimum Hamming distance between the
minterms of a function f and a reference minterm. The function is
given as a BDD; the minterm is given as an array of integers, one
for each variable in the manager. Returns the minimum distance if
it is less than the upper bound; the upper bound if the minimum
distance is at least as large; CUDD_OUT_OF_MEM in case of failure.]
SideEffects [None]
SeeAlso [Cudd_addHamming]
******************************************************************************/
int
Cudd_MinHammingDist(
DdManager *dd /* DD manager */,
DdNode *f /* function to examine */,
int *minterm /* reference minterm */,
int upperBound /* distance above which an approximate answer is OK */)
{
DdHashTable *table;
CUDD_VALUE_TYPE epsilon;
int res;
table = cuddHashTableInit(dd,1,2);
if (table == NULL) {
return(CUDD_OUT_OF_MEM);
}
epsilon = Cudd_ReadEpsilon(dd);
Terminal zero;
zero.set(0.0);
Cudd_SetEpsilon(dd,&zero);
//Cudd_SetEpsilon(dd,(CUDD_VALUE_TYPE)0.0);
res = cuddMinHammingDistRecur(f,minterm,table,upperBound);
cuddHashTableQuit(table);
Cudd_SetEpsilon(dd,epsilon);
return(res);
} /* end of Cudd_MinHammingDist */
/**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 */