/**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 [Performs the recursive step of Cudd_MinHammingDist.]
Description [Performs the recursive step of Cudd_MinHammingDist.
It is based on the following identity. Let H(f) be the
minimum Hamming distance of the minterms of f from the reference
minterm. Then:
<xmp>
H(f) = min(H(f0)+h0,H(f1)+h1)
</xmp>
where f0 and f1 are the two cofactors of f with respect to its top
variable; h0 is 1 if the minterm assigns 1 to the top variable of f;
h1 is 1 if the minterm assigns 0 to the top variable of f.
The upper bound on the distance is used to bound the depth of the
recursion.
Returns the minimum distance unless it exceeds the upper bound or
computation fails.]
SideEffects [None]
SeeAlso [Cudd_MinHammingDist]
******************************************************************************/
static int
cuddMinHammingDistRecur(
DdNode * f,
int *minterm,
DdHashTable * table,
int upperBound)
{
DdNode *F, *Ft, *Fe;
double h, hT, hE;
DdNode *zero, *res;
DdManager *dd = table->manager;
statLine(dd);
if (upperBound == 0) return(0);
F = Cudd_Regular(f);
if (cuddIsConstant(F)) {
zero = Cudd_Not(DD_ONE(dd));
if (f == dd->background || f == zero) {
return(upperBound);
} else {
return(0);
}
}
if ((res = cuddHashTableLookup1(table,f)) != NULL) {
//Rob Apr 6 2001: might need to change this, not sure what it does.....
h = (*cuddV(res)).get_val();
if (res->ref == 0) {
dd->dead++;
dd->constants.dead++;
}
return((int) h);
}
Ft = cuddT(F); Fe = cuddE(F);
if (Cudd_IsComplement(f)) {
Ft = Cudd_Not(Ft); Fe = Cudd_Not(Fe);
}
if (minterm[F->index] == 0) {
DdNode *temp = Ft;
Ft = Fe; Fe = temp;
}
hT = cuddMinHammingDistRecur(Ft,minterm,table,upperBound);
if (hT == CUDD_OUT_OF_MEM) return(CUDD_OUT_OF_MEM);
if (hT == 0) {
hE = upperBound;
} else {
hE = cuddMinHammingDistRecur(Fe,minterm,table,upperBound - 1);
if (hE == CUDD_OUT_OF_MEM) return(CUDD_OUT_OF_MEM);
}
h = ddMin(hT, hE + 1);
if (F->ref != 1) {
ptrint fanout = (ptrint) F->ref;
cuddSatDec(fanout);
Terminal hTerminal;
hTerminal.set((double) h);
res = cuddUniqueConst(dd,&hTerminal);
//res = cuddUniqueConst(dd, (CUDD_VALUE_TYPE) h);
if (!cuddHashTableInsert1(table,f,res,fanout)) {
cuddRef(res); Cudd_RecursiveDeref(dd, res);
return(CUDD_OUT_OF_MEM);
}
}
return((int) h);
} /* end of cuddMinHammingDistRecur */
