/**Function********************************************************************
Synopsis [Performs the recursive step for Cudd_addBddInterval.]
Description [Performs the recursive step for Cudd_addBddInterval.
Returns a pointer to the BDD if successful; NULL otherwise.]
SideEffects [None]
SeeAlso [addBddDoThreshold addBddDoStrictThreshold]
******************************************************************************/
static DdNode *
addBddDoInterval(
DdManager * dd,
DdNode * f,
DdNode * l,
DdNode * u)
{
DdNode *res, *T, *E;
DdNode *fv, *fvn;
int v;
statLine(dd);
/* Check terminal case. */
if (cuddIsConstant(f)) {
return(Cudd_NotCond(DD_TRUE(dd),cuddV(f) < cuddV(l) || cuddV(f) > cuddV(u)));
}
/* Check cache. */
res = cuddCacheLookup(dd,DD_ADD_BDD_DO_INTERVAL_TAG,f,l,u);
if (res != NULL) return(res);
/* Recursive step. */
v = f->index;
fv = cuddT(f); fvn = cuddE(f);
T = addBddDoInterval(dd,fv,l,u);
if (T == NULL) return(NULL);
cuddRef(T);
E = addBddDoInterval(dd,fvn,l,u);
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. */
cuddCacheInsert(dd,DD_ADD_BDD_DO_INTERVAL_TAG,f,l,u,res);
return(res);
} /* end of addBddDoInterval */
/**Function********************************************************************
Synopsis [Takes the exclusive OR of two BDDs and simultaneously abstracts the
variables in cube.]
Description [Takes the exclusive OR of two BDDs and simultaneously abstracts
the variables in cube. The variables are existentially abstracted. Returns a
pointer to the result is successful; NULL otherwise.]
SideEffects [None]
SeeAlso [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;
unsigned int topf, topg, topcube, top, 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);
}
/* 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 [Implements the recursive step of Cudd_bddIte.]
Description [Implements the recursive step of Cudd_bddIte. Returns a
pointer to the resulting BDD. NULL if the intermediate result blows
up or if reordering occurs.]
SideEffects [None]
SeeAlso []
******************************************************************************/
DdNode *
cuddBddIteRecur(
DdManager * dd,
DdNode * f,
DdNode * g,
DdNode * h)
{
DdNode *one, *zero, *res;
DdNode *r, *Fv, *Fnv, *Gv, *Gnv, *H, *Hv, *Hnv, *t, *e;
unsigned int topf, topg, toph, v;
int index = -1;
int comple;
statLine(dd);
/* Terminal cases. */
/* One variable cases. */
if (f == (one = DD_ONE(dd))) /* ITE(1,G,H) = G */
return(g);
if (f == (zero = Cudd_Not(one))) /* ITE(0,G,H) = H */
return(h);
/* From now on, f is known not to be a constant. */
if (g == one || f == g) { /* ITE(F,F,H) = ITE(F,1,H) = F + H */
if (h == zero) { /* ITE(F,1,0) = F */
return(f);
} else {
res = cuddBddAndRecur(dd,Cudd_Not(f),Cudd_Not(h));
return(Cudd_NotCond(res,res != NULL));
}
} else if (g == zero || f == Cudd_Not(g)) { /* ITE(F,!F,H) = ITE(F,0,H) = !F * H */
if (h == one) { /* ITE(F,0,1) = !F */
return(Cudd_Not(f));
} else {
res = cuddBddAndRecur(dd,Cudd_Not(f),h);
return(res);
}
}
if (h == zero || f == h) { /* ITE(F,G,F) = ITE(F,G,0) = F * G */
res = cuddBddAndRecur(dd,f,g);
return(res);
} else if (h == one || f == Cudd_Not(h)) { /* ITE(F,G,!F) = ITE(F,G,1) = !F + G */
res = cuddBddAndRecur(dd,f,Cudd_Not(g));
return(Cudd_NotCond(res,res != NULL));
}
/* Check remaining one variable case. */
if (g == h) { /* ITE(F,G,G) = G */
return(g);
} else if (g == Cudd_Not(h)) { /* ITE(F,G,!G) = F <-> G */
res = cuddBddXorRecur(dd,f,h);
return(res);
}
/* From here, there are no constants. */
comple = bddVarToCanonicalSimple(dd, &f, &g, &h, &topf, &topg, &toph);
/* f & g are now regular pointers */
v = ddMin(topg, toph);
/* A shortcut: ITE(F,G,H) = (v,G,H) if F = (v,1,0), v < top(G,H). */
if (topf < v && cuddT(f) == one && cuddE(f) == zero) {
r = cuddUniqueInter(dd, (int) f->index, g, h);
return(Cudd_NotCond(r,comple && r != NULL));
}
/* Check cache. */
r = cuddCacheLookup(dd, DD_BDD_ITE_TAG, f, g, h);
if (r != NULL) {
return(Cudd_NotCond(r,comple));
}
/* Compute cofactors. */
if (topf <= v) {
v = ddMin(topf, v); /* v = top_var(F,G,H) */
index = f->index;
Fv = cuddT(f); Fnv = cuddE(f);
} else {
Fv = Fnv = f;
}
if (topg == v) {
index = g->index;
Gv = cuddT(g); Gnv = cuddE(g);
} else {
Gv = Gnv = g;
}
if (toph == v) {
H = Cudd_Regular(h);
index = H->index;
Hv = cuddT(H); Hnv = cuddE(H);
if (Cudd_IsComplement(h)) {
Hv = Cudd_Not(Hv);
Hnv = Cudd_Not(Hnv);
}
} else {
Hv = Hnv = h;
}
/* Recursive step. */
t = cuddBddIteRecur(dd,Fv,Gv,Hv);
if (t == NULL) return(NULL);
cuddRef(t);
e = cuddBddIteRecur(dd,Fnv,Gnv,Hnv);
if (e == NULL) {
Cudd_IterDerefBdd(dd,t);
return(NULL);
}
cuddRef(e);
r = (t == e) ? t : cuddUniqueInter(dd,index,t,e);
if (r == NULL) {
Cudd_IterDerefBdd(dd,t);
Cudd_IterDerefBdd(dd,e);
return(NULL);
}
cuddDeref(t);
cuddDeref(e);
cuddCacheInsert(dd, DD_BDD_ITE_TAG, f, g, h, r);
return(Cudd_NotCond(r,comple));
} /* end of cuddBddIteRecur */
/**Function********************************************************************
Synopsis [Implements ITEconstant(f,g,h).]
Description [Implements ITEconstant(f,g,h). Returns a pointer to the
resulting BDD (which may or may not be constant) or DD_NON_CONSTANT.
No new nodes are created.]
SideEffects [None]
SeeAlso [Cudd_bddIte Cudd_bddIntersect Cudd_bddLeq Cudd_addIteConstant]
******************************************************************************/
DdNode *
Cudd_bddIteConstant(
DdManager * dd,
DdNode * f,
DdNode * g,
DdNode * h)
{
DdNode *r, *Fv, *Fnv, *Gv, *Gnv, *H, *Hv, *Hnv, *t, *e;
DdNode *one = DD_ONE(dd);
DdNode *zero = Cudd_Not(one);
int comple;
unsigned int topf, topg, toph, v;
statLine(dd);
/* Trivial cases. */
if (f == one) /* ITE(1,G,H) => G */
return(g);
if (f == zero) /* ITE(0,G,H) => H */
return(h);
/* f now not a constant. */
bddVarToConst(f, &g, &h, one); /* possibly convert g or h */
/* to constants */
if (g == h) /* ITE(F,G,G) => G */
return(g);
if (Cudd_IsConstant(g) && Cudd_IsConstant(h))
return(DD_NON_CONSTANT); /* ITE(F,1,0) or ITE(F,0,1) */
/* => DD_NON_CONSTANT */
if (g == Cudd_Not(h))
return(DD_NON_CONSTANT); /* ITE(F,G,G') => DD_NON_CONSTANT */
/* if F != G and F != G' */
comple = bddVarToCanonical(dd, &f, &g, &h, &topf, &topg, &toph);
/* Cache lookup. */
r = cuddConstantLookup(dd, DD_BDD_ITE_CONSTANT_TAG, f, g, h);
if (r != NULL) {
return(Cudd_NotCond(r,comple && r != DD_NON_CONSTANT));
}
v = ddMin(topg, toph);
/* ITE(F,G,H) = (v,G,H) (non constant) if F = (v,1,0), v < top(G,H). */
if (topf < v && cuddT(f) == one && cuddE(f) == zero) {
return(DD_NON_CONSTANT);
}
/* Compute cofactors. */
if (topf <= v) {
v = ddMin(topf, v); /* v = top_var(F,G,H) */
Fv = cuddT(f); Fnv = cuddE(f);
} else {
Fv = Fnv = f;
}
if (topg == v) {
Gv = cuddT(g); Gnv = cuddE(g);
} else {
Gv = Gnv = g;
}
if (toph == v) {
H = Cudd_Regular(h);
Hv = cuddT(H); Hnv = cuddE(H);
if (Cudd_IsComplement(h)) {
Hv = Cudd_Not(Hv);
Hnv = Cudd_Not(Hnv);
}
} else {
Hv = Hnv = h;
}
/* Recursion. */
t = Cudd_bddIteConstant(dd, Fv, Gv, Hv);
if (t == DD_NON_CONSTANT || !Cudd_IsConstant(t)) {
cuddCacheInsert(dd, DD_BDD_ITE_CONSTANT_TAG, f, g, h, DD_NON_CONSTANT);
return(DD_NON_CONSTANT);
}
e = Cudd_bddIteConstant(dd, Fnv, Gnv, Hnv);
if (e == DD_NON_CONSTANT || !Cudd_IsConstant(e) || t != e) {
cuddCacheInsert(dd, DD_BDD_ITE_CONSTANT_TAG, f, g, h, DD_NON_CONSTANT);
return(DD_NON_CONSTANT);
}
cuddCacheInsert(dd, DD_BDD_ITE_CONSTANT_TAG, f, g, h, t);
return(Cudd_NotCond(t,comple));
} /* end of Cudd_bddIteConstant */
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_addOuterSum.]
Description [Performs the recursive step of Cudd_addOuterSum.
Returns a pointer to the result if successful; NULL otherwise.]
SideEffects [None]
SeeAlso []
******************************************************************************/
static DdNode *
cuddAddOuterSumRecur(
DdManager *dd,
DdNode *M,
DdNode *r,
DdNode *c)
{
DdNode *P, *R, *Mt, *Me, *rt, *re, *ct, *ce, *Rt, *Re;
int topM, topc, topr;
int v, index;
statLine(dd);
/* Check special cases. */
if (r == DD_PLUS_INFINITY(dd) || c == DD_PLUS_INFINITY(dd)) return(M);
if (cuddIsConstant(c) && cuddIsConstant(r)) {
R = cuddUniqueConst(dd,Cudd_V(c)+Cudd_V(r));
cuddRef(R);
if (cuddIsConstant(M)) {
if (cuddV(R) <= cuddV(M)) {
cuddDeref(R);
return(R);
} else {
Cudd_RecursiveDeref(dd,R);
return(M);
}
} else {
P = Cudd_addApply(dd,Cudd_addMinimum,R,M);
cuddRef(P);
Cudd_RecursiveDeref(dd,R);
cuddDeref(P);
return(P);
}
}
/* Check the cache. */
R = cuddCacheLookup(dd,DD_ADD_OUT_SUM_TAG,M,r,c);
if (R != NULL) return(R);
topM = cuddI(dd,M->index); topr = cuddI(dd,r->index);
topc = cuddI(dd,c->index);
v = ddMin(topM,ddMin(topr,topc));
/* Compute cofactors. */
if (topM == v) { Mt = cuddT(M); Me = cuddE(M); } else { Mt = Me = M; }
if (topr == v) { rt = cuddT(r); re = cuddE(r); } else { rt = re = r; }
if (topc == v) { ct = cuddT(c); ce = cuddE(c); } else { ct = ce = c; }
/* Recursively solve. */
Rt = cuddAddOuterSumRecur(dd,Mt,rt,ct);
if (Rt == NULL) return(NULL);
cuddRef(Rt);
Re = cuddAddOuterSumRecur(dd,Me,re,ce);
if (Re == NULL) {
Cudd_RecursiveDeref(dd, Rt);
return(NULL);
}
cuddRef(Re);
index = dd->invperm[v];
R = (Rt == Re) ? Rt : cuddUniqueInter(dd,index,Rt,Re);
if (R == NULL) {
Cudd_RecursiveDeref(dd, Rt);
Cudd_RecursiveDeref(dd, Re);
return(NULL);
}
cuddDeref(Rt);
cuddDeref(Re);
/* Store the result in the cache. */
cuddCacheInsert(dd,DD_ADD_OUT_SUM_TAG,M,r,c,R);
return(R);
} /* end of cuddAddOuterSumRecur */
/**Function********************************************************************
Synopsis [Performs the recursive step of Cudd_addTriangle.]
Description [Performs the recursive step of Cudd_addTriangle. Returns
a pointer to the result if successful; NULL otherwise.]
SideEffects [None]
******************************************************************************/
static DdNode *
addTriangleRecur(
DdManager * dd,
DdNode * f,
DdNode * g,
int * vars,
DdNode *cube)
{
DdNode *fv, *fvn, *gv, *gvn, *t, *e, *res;
CUDD_VALUE_TYPE value;
int top, topf, topg, index;
statLine(dd);
if (f == DD_PLUS_INFINITY(dd) || g == DD_PLUS_INFINITY(dd)) {
return(DD_PLUS_INFINITY(dd));
}
if (cuddIsConstant(f) && cuddIsConstant(g)) {
value = cuddV(f) + cuddV(g);
res = cuddUniqueConst(dd, value);
return(res);
}
if (f < g) {
DdNode *tmp = f;
f = g;
g = tmp;
}
if (f->ref != 1 || g->ref != 1) {
res = cuddCacheLookup(dd, DD_ADD_TRIANGLE_TAG, f, g, cube);
if (res != NULL) {
return(res);
}
}
topf = cuddI(dd,f->index); topg = cuddI(dd,g->index);
top = ddMin(topf,topg);
if (top == topf) {fv = cuddT(f); fvn = cuddE(f);} else {fv = fvn = f;}
if (top == topg) {gv = cuddT(g); gvn = cuddE(g);} else {gv = gvn = g;}
t = addTriangleRecur(dd, fv, gv, vars, cube);
if (t == NULL) return(NULL);
cuddRef(t);
e = addTriangleRecur(dd, fvn, gvn, vars, cube);
if (e == NULL) {
Cudd_RecursiveDeref(dd, t);
return(NULL);
}
cuddRef(e);
index = dd->invperm[top];
if (vars[index] < 0) {
res = (t == e) ? t : cuddUniqueInter(dd,index,t,e);
if (res == NULL) {
Cudd_RecursiveDeref(dd, t);
Cudd_RecursiveDeref(dd, e);
return(NULL);
}
cuddDeref(t);
cuddDeref(e);
} else {
res = cuddAddApplyRecur(dd,Cudd_addMinimum,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);
cuddDeref(res);
}
if (f->ref != 1 || g->ref != 1) {
cuddCacheInsert(dd, DD_ADD_TRIANGLE_TAG, f, g, cube, res);
}
return(res);
} /* end of addTriangleRecur */
/**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 */
/**
@brief Approximates the AND 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_bddClippingAndAbstract
*/
static DdNode *
cuddBddClipAndAbsRecur(
DdManager * manager,
DdNode * f,
DdNode * g,
DdNode * cube,
int distance,
int direction)
{
DdNode *F, *ft, *fe, *G, *gt, *ge;
DdNode *one, *zero, *r, *t, *e, *Cube;
int topf, topg, topcube, top;
unsigned int index;
ptruint cacheTag;
statLine(manager);
one = DD_ONE(manager);
zero = Cudd_Not(one);
/* Terminal cases. */
if (f == zero || g == zero || f == Cudd_Not(g)) return(zero);
if (f == one && g == one) return(one);
if (cube == one) {
return(cuddBddClippingAndRecur(manager, f, g, distance, direction));
}
if (f == one || f == g) {
return (cuddBddExistAbstractRecur(manager, g, cube));
}
if (g == one) {
return (cuddBddExistAbstractRecur(manager, f, cube));
}
if (distance == 0) return(Cudd_NotCond(one,(direction == 0)));
/* At this point f, g, and cube are not constant. */
distance--;
/* Check cache. */
if (f > g) { /* Try to increase cache efficiency. */
DdNode *tmp = f;
f = g; g = tmp;
}
F = Cudd_Regular(f);
G = Cudd_Regular(g);
cacheTag = direction ? DD_BDD_CLIPPING_AND_ABSTRACT_UP_TAG :
DD_BDD_CLIPPING_AND_ABSTRACT_DOWN_TAG;
if (F->ref != 1 || G->ref != 1) {
r = cuddCacheLookup(manager, cacheTag,
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.
*/
topf = manager->perm[F->index];
topg = manager->perm[G->index];
top = ddMin(topf, topg);
topcube = manager->perm[cube->index];
if (topcube < top) {
return(cuddBddClipAndAbsRecur(manager, f, g, cuddT(cube),
distance, direction));
}
/* Now, topcube >= top. */
if (topf == top) {
index = F->index;
ft = cuddT(F);
fe = cuddE(F);
if (Cudd_IsComplement(f)) {
ft = Cudd_Not(ft);
fe = Cudd_Not(fe);
}
} else {
index = G->index;
ft = fe = f;
}
if (topg == top) {
gt = cuddT(G);
ge = cuddE(G);
if (Cudd_IsComplement(g)) {
gt = Cudd_Not(gt);
ge = Cudd_Not(ge);
}
} else {
gt = ge = g;
}
if (topcube == top) {
Cube = cuddT(cube);
} else {
Cube = cube;
}
t = cuddBddClipAndAbsRecur(manager, ft, gt, Cube, distance, direction);
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) {
if (F->ref != 1 || G->ref != 1)
cuddCacheInsert(manager, cacheTag, f, g, cube, one);
return(one);
}
cuddRef(t);
e = cuddBddClipAndAbsRecur(manager, fe, ge, Cube, distance, direction);
if (e == NULL) {
Cudd_RecursiveDeref(manager, t);
return(NULL);
}
cuddRef(e);
if (topcube == top) { /* abstract */
r = cuddBddClippingAndRecur(manager, Cudd_Not(t), Cudd_Not(e),
distance, (direction == 0));
if (r == NULL) {
Cudd_RecursiveDeref(manager, t);
Cudd_RecursiveDeref(manager, e);
return(NULL);
}
r = Cudd_Not(r);
cuddRef(r);
Cudd_RecursiveDeref(manager, t);
Cudd_RecursiveDeref(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_RecursiveDeref(manager, t);
Cudd_RecursiveDeref(manager, e);
return(NULL);
}
r = Cudd_Not(r);
} else {
r = cuddUniqueInter(manager,(int)index,t,e);
if (r == NULL) {
Cudd_RecursiveDeref(manager, t);
Cudd_RecursiveDeref(manager, e);
return(NULL);
}
}
cuddDeref(e);
cuddDeref(t);
}
if (F->ref != 1 || G->ref != 1)
cuddCacheInsert(manager, cacheTag, f, g, cube, r);
return (r);
} /* end of cuddBddClipAndAbsRecur */
/**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 [Implements the recursive step of Cudd_addIte(f,g,h).]
Description [Implements the recursive step of Cudd_addIte(f,g,h).
Returns a pointer to the resulting ADD if successful; NULL
otherwise.]
SideEffects [None]
SeeAlso [Cudd_addIte]
******************************************************************************/
DdNode *
cuddAddIteRecur(
DdManager * dd,
DdNode * f,
DdNode * g,
DdNode * h)
{
DdNode *one,*zero;
DdNode *r,*Fv,*Fnv,*Gv,*Gnv,*Hv,*Hnv,*t,*e;
unsigned int topf,topg,toph,v;
int index;
statLine(dd);
/* Trivial cases. */
/* One variable cases. */
if (f == (one = DD_ONE(dd))) { /* ITE(1,G,H) = G */
return(g);
}
if (f == (zero = DD_ZERO(dd))) { /* ITE(0,G,H) = H */
return(h);
}
/* From now on, f is known to not be a constant. */
addVarToConst(f,&g,&h,one,zero);
/* Check remaining one variable cases. */
if (g == h) { /* ITE(F,G,G) = G */
return(g);
}
if (g == one) { /* ITE(F,1,0) = F */
if (h == zero) return(f);
}
topf = cuddI(dd,f->index);
topg = cuddI(dd,g->index);
toph = cuddI(dd,h->index);
v = ddMin(topg,toph);
/* A shortcut: ITE(F,G,H) = (x,G,H) if F=(x,1,0), x < top(G,H). */
if (topf < v && cuddT(f) == one && cuddE(f) == zero) {
r = cuddUniqueInter(dd,(int)f->index,g,h);
return(r);
}
if (topf < v && cuddT(f) == zero && cuddE(f) == one) {
r = cuddUniqueInter(dd,(int)f->index,h,g);
return(r);
}
/* Check cache. */
r = cuddCacheLookup(dd,DD_ADD_ITE_TAG,f,g,h);
if (r != NULL) {
return(r);
}
/* Compute cofactors. */
if (topf <= v) {
v = ddMin(topf,v); /* v = top_var(F,G,H) */
index = f->index;
Fv = cuddT(f); Fnv = cuddE(f);
} else {
Fv = Fnv = f;
}
if (topg == v) {
index = g->index;
Gv = cuddT(g); Gnv = cuddE(g);
} else {
Gv = Gnv = g;
}
if (toph == v) {
index = h->index;
Hv = cuddT(h); Hnv = cuddE(h);
} else {
Hv = Hnv = h;
}
/* Recursive step. */
t = cuddAddIteRecur(dd,Fv,Gv,Hv);
if (t == NULL) return(NULL);
cuddRef(t);
e = cuddAddIteRecur(dd,Fnv,Gnv,Hnv);
if (e == NULL) {
Cudd_RecursiveDeref(dd,t);
return(NULL);
}
cuddRef(e);
r = (t == e) ? t : cuddUniqueInter(dd,index,t,e);
if (r == NULL) {
Cudd_RecursiveDeref(dd,t);
Cudd_RecursiveDeref(dd,e);
return(NULL);
}
cuddDeref(t);
cuddDeref(e);
cuddCacheInsert(dd,DD_ADD_ITE_TAG,f,g,h,r);
return(r);
} /* end of cuddAddIteRecur */
/**Function********************************************************************
Synopsis [Implements ITEconstant for ADDs.]
Description [Implements ITEconstant for ADDs. f must be a 0-1 ADD.
Returns a pointer to the resulting ADD (which may or may not be
constant) or DD_NON_CONSTANT. No new nodes are created. This function
can be used, for instance, to check that g has a constant value
(specified by h) whenever f is 1. If the constant value is unknown,
then one should use Cudd_addEvalConst.]
SideEffects [None]
SeeAlso [Cudd_addIte Cudd_addEvalConst Cudd_bddIteConstant]
******************************************************************************/
DdNode *
Cudd_addIteConstant(
DdManager * dd,
DdNode * f,
DdNode * g,
DdNode * h)
{
DdNode *one,*zero;
DdNode *Fv,*Fnv,*Gv,*Gnv,*Hv,*Hnv,*r,*t,*e;
unsigned int topf,topg,toph,v;
statLine(dd);
/* Trivial cases. */
if (f == (one = DD_ONE(dd))) { /* ITE(1,G,H) = G */
return(g);
}
if (f == (zero = DD_ZERO(dd))) { /* ITE(0,G,H) = H */
return(h);
}
/* From now on, f is known not to be a constant. */
addVarToConst(f,&g,&h,one,zero);
/* Check remaining one variable cases. */
if (g == h) { /* ITE(F,G,G) = G */
return(g);
}
if (cuddIsConstant(g) && cuddIsConstant(h)) {
return(DD_NON_CONSTANT);
}
topf = cuddI(dd,f->index);
topg = cuddI(dd,g->index);
toph = cuddI(dd,h->index);
v = ddMin(topg,toph);
/* ITE(F,G,H) = (x,G,H) (non constant) if F = (x,1,0), x < top(G,H). */
if (topf < v && cuddIsConstant(cuddT(f)) && cuddIsConstant(cuddE(f))) {
return(DD_NON_CONSTANT);
}
/* Check cache. */
r = cuddConstantLookup(dd,DD_ADD_ITE_CONSTANT_TAG,f,g,h);
if (r != NULL) {
return(r);
}
/* Compute cofactors. */
if (topf <= v) {
v = ddMin(topf,v); /* v = top_var(F,G,H) */
Fv = cuddT(f); Fnv = cuddE(f);
} else {
Fv = Fnv = f;
}
if (topg == v) {
Gv = cuddT(g); Gnv = cuddE(g);
} else {
Gv = Gnv = g;
}
if (toph == v) {
Hv = cuddT(h); Hnv = cuddE(h);
} else {
Hv = Hnv = h;
}
/* Recursive step. */
t = Cudd_addIteConstant(dd,Fv,Gv,Hv);
if (t == DD_NON_CONSTANT || !cuddIsConstant(t)) {
cuddCacheInsert(dd, DD_ADD_ITE_CONSTANT_TAG, f, g, h, DD_NON_CONSTANT);
return(DD_NON_CONSTANT);
}
e = Cudd_addIteConstant(dd,Fnv,Gnv,Hnv);
if (e == DD_NON_CONSTANT || !cuddIsConstant(e) || t != e) {
cuddCacheInsert(dd, DD_ADD_ITE_CONSTANT_TAG, f, g, h, DD_NON_CONSTANT);
return(DD_NON_CONSTANT);
}
cuddCacheInsert(dd, DD_ADD_ITE_CONSTANT_TAG, f, g, h, t);
return(t);
} /* end of Cudd_addIteConstant */
DdNode *
cuddAddTernaryApplyWithDataRecur(
DdManager * dd,
DD_TAOPD op,
DdNode * f,
DdNode * g,
DdNode * h,
void * data)
{
DdNode *res,
*fv, *fvn, *gv, *gvn, *hv, *hvn,
*T, *E;
unsigned int ford, gord, hord;
unsigned int index;
ptruint cacheOp;
/* Check terminal cases. Op may swap f and g to increase the
* cache hit rate.
*/
statLine(dd);
res = (*op)(dd,&f,&g,&h, data);
if (res != NULL) return(res);
/* Check cache. */
cacheOp = (ptruint)global_bloody_counter_ternary;
res = cuddCacheLookup(dd,cacheOp,f,g,h);
if (res != NULL) return(res);
/* Recursive step. */
ford = cuddI(dd,f->index);
gord = cuddI(dd,g->index);
hord = cuddI(dd,h->index);
if ((ford <= gord) && (ford <= hord)) {
index = f->index;
fv = cuddT(f);
fvn = cuddE(f);
} else {
fv = fvn = f;
}
if ((gord <= ford) && (gord <= hord)) {
index = g->index;
gv = cuddT(g);
gvn = cuddE(g);
} else {
gv = gvn = g;
}
if ((hord <= ford) && (hord <= gord)) {
index = h->index;
hv = cuddT(h);
hvn = cuddE(h);
} else {
hv = hvn = h;
}
T = cuddAddTernaryApplyWithDataRecur(dd,op,fv,gv,hv, data);
if (T == NULL) return(NULL);
cuddRef(T);
E = cuddAddTernaryApplyWithDataRecur(dd,op,fvn,gvn,hvn, 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. */
cuddCacheInsert(dd,cacheOp,f,g,h,res);
return(res);
} /* end of cuddAddTernaryApplyWithDataRecur */
/**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 [Takes the AND of two BDDs and simultaneously abstracts the
variables in cube.]
Description [Takes the AND of two BDDs and simultaneously abstracts
the variables in cube. The variables are existentially abstracted.
Returns a pointer to the result is successful; NULL otherwise.]
SideEffects [None]
SeeAlso [Cudd_bddAndAbstract]
******************************************************************************/
DdNode *
cuddBddAndAbstractRecur(
DdManager * manager,
DdNode * f,
DdNode * g,
DdNode * cube)
{
DdNode *F, *ft, *fe, *G, *gt, *ge;
DdNode *one, *zero, *r, *t, *e;
unsigned int topf, topg, topcube, top, index;
statLine(manager);
one = DD_ONE(manager);
zero = Cudd_Not(one);
/* Terminal cases. */
if (f == zero || g == zero || f == Cudd_Not(g)) return(zero);
if (f == one && g == one) return(one);
if (cube == one) {
return(cuddBddAndRecur(manager, f, g));
}
if (f == one || f == g) {
return(cuddBddExistAbstractRecur(manager, g, cube));
}
if (g == one) {
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;
}
/* Here we can skip the use of cuddI, because the operands are known
** to be non-constant.
*/
F = Cudd_Regular(f);
G = Cudd_Regular(g);
topf = manager->perm[F->index];
topg = manager->perm[G->index];
top = ddMin(topf, topg);
topcube = manager->perm[cube->index];
while (topcube < top) {
cube = cuddT(cube);
if (cube == one) {
return(cuddBddAndRecur(manager, f, g));
}
topcube = manager->perm[cube->index];
}
/* Now, topcube >= top. */
/* Check cache. */
if (F->ref != 1 || G->ref != 1) {
r = cuddCacheLookup(manager, DD_BDD_AND_ABSTRACT_TAG, f, g, cube);
if (r != NULL) {
return(r);
}
}
if ( manager->TimeStop && manager->TimeStop < clock() )
return NULL;
if (topf == top) {
index = F->index;
ft = cuddT(F);
fe = cuddE(F);
if (Cudd_IsComplement(f)) {
ft = Cudd_Not(ft);
fe = Cudd_Not(fe);
}
} else {
index = G->index;
ft = fe = f;
}
if (topg == top) {
gt = cuddT(G);
ge = cuddE(G);
if (Cudd_IsComplement(g)) {
gt = Cudd_Not(gt);
ge = Cudd_Not(ge);
}
} else {
gt = ge = g;
}
if (topcube == top) { /* quantify */
DdNode *Cube = cuddT(cube);
t = cuddBddAndAbstractRecur(manager, ft, gt, Cube);
if (t == NULL) return(NULL);
/* Special case: 1 OR anything = 1. Hence, no need to compute
** the else branch if t is 1. Likewise t + t * anything == t.
** Notice that t == fe implies that fe does not depend on the
** variables in Cube. Likewise for t == ge.
*/
if (t == one || t == fe || t == ge) {
if (F->ref != 1 || G->ref != 1)
cuddCacheInsert(manager, DD_BDD_AND_ABSTRACT_TAG,
f, g, cube, t);
return(t);
}
cuddRef(t);
/* Special case: t + !t * anything == t + anything. */
if (t == Cudd_Not(fe)) {
e = cuddBddExistAbstractRecur(manager, ge, Cube);
} else if (t == Cudd_Not(ge)) {
e = cuddBddExistAbstractRecur(manager, fe, Cube);
} else {
e = cuddBddAndAbstractRecur(manager, fe, ge, Cube);
}
if (e == NULL) {
Cudd_IterDerefBdd(manager, t);
return(NULL);
}
if (t == e) {
r = t;
cuddDeref(t);
} else {
cuddRef(e);
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_DelayedDerefBdd(manager, t);
Cudd_DelayedDerefBdd(manager, e);
cuddDeref(r);
}
} else {
t = cuddBddAndAbstractRecur(manager, ft, gt, cube);
if (t == NULL) return(NULL);
cuddRef(t);
e = cuddBddAndAbstractRecur(manager, fe, ge, cube);
if (e == NULL) {
Cudd_IterDerefBdd(manager, t);
return(NULL);
}
if (t == e) {
r = t;
cuddDeref(t);
} else {
cuddRef(e);
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);
}
}
if (F->ref != 1 || G->ref != 1)
cuddCacheInsert(manager, DD_BDD_AND_ABSTRACT_TAG, f, g, cube, r);
return (r);
} /* end of cuddBddAndAbstractRecur */
/**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_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_ZERO(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_ONE(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 [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 */
/**Function********************************************************************
Synopsis [Performs a recursive step of Extra_zddGetSymmetricVars.]
Description [Returns the set of ZDD singletons, containing those positive
ZDD variables that correspond to BDD variables x, for which it is true
that bF(x=0) == bG(x=1).]
SideEffects []
SeeAlso []
******************************************************************************/
DdNode * extraZddGetSymmetricVars(
DdManager * dd, /* the DD manager */
DdNode * bF, /* the first function - originally, the positive cofactor */
DdNode * bG, /* the second function - originally, the negative cofactor */
DdNode * bVars) /* the set of variables, on which F and G depend */
{
DdNode * zRes;
DdNode * bFR = Cudd_Regular(bF);
DdNode * bGR = Cudd_Regular(bG);
if ( cuddIsConstant(bFR) && cuddIsConstant(bGR) )
{
if ( bF == bG )
return extraZddGetSingletons( dd, bVars );
else
return z0;
}
assert( bVars != b1 );
if ( (zRes = cuddCacheLookupZdd(dd, DD_GET_SYMM_VARS_TAG, bF, bG, bVars)) )
return zRes;
else
{
DdNode * zRes0, * zRes1;
DdNode * zPlus, * zTemp;
DdNode * bF0, * bF1;
DdNode * bG0, * bG1;
DdNode * bVarsNew;
int LevelF = cuddI(dd,bFR->index);
int LevelG = cuddI(dd,bGR->index);
int LevelFG;
if ( LevelF < LevelG )
LevelFG = LevelF;
else
LevelFG = LevelG;
// at least one of the arguments is not a constant
assert( LevelFG < dd->size );
// every variable in bF and bG should be also in bVars, therefore LevelFG cannot be above LevelV
// if LevelFG is below LevelV, scroll through the vars in bVars to the same level as LevelFG
for ( bVarsNew = bVars; LevelFG > dd->perm[bVarsNew->index]; bVarsNew = cuddT(bVarsNew) );
assert( LevelFG == dd->perm[bVarsNew->index] );
// cofactor the functions
if ( LevelF == LevelFG )
{
if ( bFR != bF ) // bF is complemented
{
bF0 = Cudd_Not( cuddE(bFR) );
bF1 = Cudd_Not( cuddT(bFR) );
}
else
{
bF0 = cuddE(bFR);
bF1 = cuddT(bFR);
}
}
else
bF0 = bF1 = bF;
if ( LevelG == LevelFG )
{
if ( bGR != bG ) // bG is complemented
{
bG0 = Cudd_Not( cuddE(bGR) );
bG1 = Cudd_Not( cuddT(bGR) );
}
else
{
bG0 = cuddE(bGR);
bG1 = cuddT(bGR);
}
}
else
bG0 = bG1 = bG;
// solve subproblems
zRes0 = extraZddGetSymmetricVars( dd, bF0, bG0, cuddT(bVarsNew) );
if ( zRes0 == NULL )
return NULL;
cuddRef( zRes0 );
// if there is not symmetries in the negative cofactor
// there is no need to test the positive cofactor
if ( zRes0 == z0 )
zRes = zRes0; // zRes takes reference
else
{
zRes1 = extraZddGetSymmetricVars( dd, bF1, bG1, cuddT(bVarsNew) );
if ( zRes1 == NULL )
{
Cudd_RecursiveDerefZdd( dd, zRes0 );
return NULL;
}
cuddRef( zRes1 );
// only those variables should belong to the resulting set
// for which the property is true for both cofactors
zRes = cuddZddIntersect( dd, zRes0, zRes1 );
if ( zRes == NULL )
{
Cudd_RecursiveDerefZdd( dd, zRes0 );
Cudd_RecursiveDerefZdd( dd, zRes1 );
return NULL;
}
cuddRef( zRes );
Cudd_RecursiveDerefZdd( dd, zRes0 );
Cudd_RecursiveDerefZdd( dd, zRes1 );
}
// add one more singleton if the property is true for this variable
if ( bF0 == bG1 )
{
zPlus = cuddZddGetNode( dd, 2*bVarsNew->index, z1, z0 );
if ( zPlus == NULL )
{
Cudd_RecursiveDerefZdd( dd, zRes );
return NULL;
}
cuddRef( zPlus );
// add these variable pairs 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 );
}
if ( bF == bG && bVars != bVarsNew )
{
// if the functions are equal, so are their cofactors
// add those variables from V that are above F and G
DdNode * bVarsExtra;
assert( LevelFG > dd->perm[bVars->index] );
// create the BDD of the extra variables
bVarsExtra = cuddBddExistAbstractRecur( dd, bVars, bVarsNew );
if ( bVarsExtra == NULL )
{
Cudd_RecursiveDerefZdd( dd, zRes );
return NULL;
}
cuddRef( bVarsExtra );
zPlus = extraZddGetSingletons( dd, bVarsExtra );
if ( zPlus == NULL )
{
Cudd_RecursiveDeref( dd, bVarsExtra );
Cudd_RecursiveDerefZdd( dd, zRes );
return NULL;
}
cuddRef( zPlus );
Cudd_RecursiveDeref( dd, bVarsExtra );
// 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 );
cuddCacheInsert( dd, DD_GET_SYMM_VARS_TAG, bF, bG, bVars, zRes );
return zRes;
}
} /* end of extraZddGetSymmetricVars */
/**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 */
