/**
@brief Existentially abstracts all the variables in cube from f.
@return the abstracted %BDD if successful; NULL otherwise.
@sideeffect None
@see Cudd_bddUnivAbstract Cudd_addExistAbstract
*/
DdNode *
Cudd_bddExistAbstract(
DdManager * manager,
DdNode * f,
DdNode * cube)
{
DdNode *res;
if (bddCheckPositiveCube(manager, cube) == 0) {
(void) fprintf(manager->err,
"Error: Can only abstract positive cubes\n");
manager->errorCode = CUDD_INVALID_ARG;
return(NULL);
}
do {
manager->reordered = 0;
res = cuddBddExistAbstractRecur(manager, f, cube);
} while (manager->reordered == 1);
if (manager->errorCode == CUDD_TIMEOUT_EXPIRED && manager->timeoutHandler) {
manager->timeoutHandler(manager, manager->tohArg);
}
return(res);
} /* end of Cudd_bddExistAbstract */
/**Function********************************************************************
Synopsis [Existentially abstracts all the variables in cube from f.]
Description [Existentially abstracts all the variables in cube from f.
Returns the abstracted BDD if successful; NULL if the intermediate
result blows up or more new nodes than <code>limit</code> are
required.]
SideEffects [None]
SeeAlso [Cudd_bddExistAbstract]
******************************************************************************/
DdNode *
Cudd_bddExistAbstractLimit(
DdManager * manager,
DdNode * f,
DdNode * cube,
unsigned int limit)
{
DdNode *res;
unsigned int saveLimit = manager->maxLive;
if (bddCheckPositiveCube(manager, cube) == 0) {
(void) fprintf(manager->err,
"Error: Can only abstract positive cubes\n");
manager->errorCode = CUDD_INVALID_ARG;
return(NULL);
}
manager->maxLive = (manager->keys - manager->dead) +
(manager->keysZ - manager->deadZ) + limit;
do {
manager->reordered = 0;
res = cuddBddExistAbstractRecur(manager, f, cube);
} while (manager->reordered == 1);
manager->maxLive = saveLimit;
return(res);
} /* end of Cudd_bddExistAbstractLimit */
/**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_bddUnivAbstract Cudd_bddExistAbstract Cudd_bddAndAbstract]
******************************************************************************/
DdNode *
Cudd_bddXorExistAbstract(
DdManager * manager,
DdNode * f,
DdNode * g,
DdNode * cube)
{
DdNode *res;
/* NuSMV: begin add */
abort(); /* NOT USED BY NUSMV */
/* NuSMV: begin end */
if (bddCheckPositiveCube(manager, cube) == 0) {
(void) fprintf(manager->err,
"Error: Can only abstract positive cubes\n");
manager->errorCode = CUDD_INVALID_ARG;
return(NULL);
}
do {
manager->reordered = 0;
res = cuddBddXorExistAbstractRecur(manager, f, g, cube);
} while (manager->reordered == 1);
return(res);
} /* end of Cudd_bddXorExistAbstract */
/**Function********************************************************************
Synopsis [Checks whether cube is an BDD representing the product of
positive literals.]
Description [Returns 1 in case of success; 0 otherwise.]
SideEffects [None]
******************************************************************************/
static int
bddCheckPositiveCube(
DdManager * manager,
DdNode * cube)
{
if (Cudd_IsComplement(cube)) return(0);
if (cube == DD_ONE(manager)) return(1);
if (cuddIsConstant(cube)) return(0);
if (cuddE(cube) == Cudd_Not(DD_ONE(manager))) {
return(bddCheckPositiveCube(manager, cuddT(cube)));
}
return(0);
} /* end of bddCheckPositiveCube */
/**Function********************************************************************
Synopsis [Universally abstracts all the variables in cube from f.]
Description [Universally abstracts all the variables in cube from f.
Returns the abstracted BDD if successful; NULL otherwise.]
SideEffects [None]
SeeAlso [Cudd_bddExistAbstract Cudd_addUnivAbstract]
******************************************************************************/
DdNode *
Cudd_bddUnivAbstract(
DdManager * manager,
DdNode * f,
DdNode * cube)
{
DdNode *res;
if (bddCheckPositiveCube(manager, cube) == 0) {
(void) fprintf(manager->err,
"Error: Can only abstract positive cubes\n");
manager->errorCode = CUDD_INVALID_ARG;
return(NULL);
}
do {
manager->reordered = 0;
res = cuddBddExistAbstractRecur(manager, Cudd_Not(f), cube);
} while (manager->reordered == 1);
if (res != NULL) res = Cudd_Not(res);
return(res);
} /* end of Cudd_bddUnivAbstract */