本文整理汇总了C++中Cudd_Not函数的典型用法代码示例。如果您正苦于以下问题：C++ Cudd_Not函数的具体用法？C++ Cudd_Not怎么用？C++ Cudd_Not使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了Cudd_Not函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: selectMintermsFromUniverse
/**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 */示例2: bddVarToConst
/**Function********************************************************************
Synopsis [Replaces variables with constants if possible.]
Description [This function performs part of the transformation to
standard form by replacing variables with constants if possible.]
SideEffects [None]
SeeAlso [bddVarToCanonical bddVarToCanonicalSimple]
******************************************************************************/
static void
bddVarToConst(
DdNode * f,
DdNode ** gp,
DdNode ** hp,
DdNode * one)
{
DdNode *g = *gp;
DdNode *h = *hp;
if (f == g) { /* ITE(F,F,H) = ITE(F,1,H) = F + H */
*gp = one;
} else if (f == Cudd_Not(g)) { /* ITE(F,!F,H) = ITE(F,0,H) = !F * H */
*gp = Cudd_Not(one);
}
if (f == h) { /* ITE(F,G,F) = ITE(F,G,0) = F * G */
*hp = Cudd_Not(one);
} else if (f == Cudd_Not(h)) { /* ITE(F,G,!F) = ITE(F,G,1) = !F + G */
*hp = one;
}
} /* end of bddVarToConst */示例3: bddCheckPositiveCube
/**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 */示例4: Cudd_bddUnivAbstract
/**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 */示例5: Cudd_bddXnor
/**Function********************************************************************
Synopsis [Computes the exclusive NOR of two BDDs f and g.]
Description [Computes the exclusive NOR of two BDDs f and g. Returns a
pointer to the resulting BDD if successful; NULL if the intermediate
result blows up.]
SideEffects [None]
SeeAlso [Cudd_bddIte Cudd_addApply Cudd_bddAnd Cudd_bddOr
Cudd_bddNand Cudd_bddNor Cudd_bddXor]
******************************************************************************/
DdNode *
Cudd_bddXnor(
DdManager * dd,
DdNode * f,
DdNode * g)
{
DdNode *res;
do {
dd->reordered = 0;
res = cuddBddXorRecur(dd,f,Cudd_Not(g));
} while (dd->reordered == 1);
return(res);
} /* end of Cudd_bddXnor */示例6: Cudd_addHamming
/**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 */示例7: testBdd
/**
* @brief Basic BDD test.
* @return 0 if successful; -1 otherwise.
*/
static int
testBdd(int verbosity)
{
DdManager *dd;
DdNode *f, *var, *tmp;
int i, ret;
dd = Cudd_Init(0, 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0);
if (!dd) {
if (verbosity) {
printf("initialization failed\n");
}
return -1;
}
if (verbosity) {
printf("Started CUDD version ");
Cudd_PrintVersion(stdout);
}
f = Cudd_ReadOne(dd);
Cudd_Ref(f);
for (i = 3; i >= 0; i--) {
var = Cudd_bddIthVar(dd, i);
tmp = Cudd_bddAnd(dd, Cudd_Not(var), f);
if (!tmp) {
if (verbosity) {
printf("computation failed\n");
}
return -1;
}
Cudd_Ref(tmp);
Cudd_RecursiveDeref(dd, f);
f = tmp;
}
if (verbosity) {
Cudd_bddPrintCover(dd, f, f);
}
Cudd_RecursiveDeref(dd, f);
ret = Cudd_CheckZeroRef(dd);
if (ret != 0 && verbosity) {
printf("%d unexpected non-zero references\n", ret);
}
Cudd_Quit(dd);
return 0;
}示例8: Cudd_bddXnorLimit
/**Function********************************************************************
Synopsis [Computes the exclusive NOR of two BDDs f and g. Returns
NULL if too many nodes are required.]
Description [Computes the exclusive NOR of two BDDs f and g. Returns a
pointer to the resulting BDD if successful; NULL if the intermediate
result blows up or more new nodes than <code>limit</code> are
required.]
SideEffects [None]
SeeAlso [Cudd_bddXnor]
******************************************************************************/
DdNode *
Cudd_bddXnorLimit(
DdManager * dd,
DdNode * f,
DdNode * g,
unsigned int limit)
{
DdNode *res;
unsigned int saveLimit = dd->maxLive;
dd->maxLive = (dd->keys - dd->dead) + (dd->keysZ - dd->deadZ) + limit;
do {
dd->reordered = 0;
res = cuddBddXorRecur(dd,f,Cudd_Not(g));
} while (dd->reordered == 1);
dd->maxLive = saveLimit;
return(res);
} /* end of Cudd_bddXnorLimit */示例9: Abc_MvReadCube
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
DdNode * Abc_MvReadCube( DdManager * dd, char * pLine, int nVars )
{
DdNode * bCube, * bVar, * bTemp;
int i;
bCube = Cudd_ReadOne(dd); Cudd_Ref( bCube );
for ( i = 0; i < nVars; i++ )
{
if ( pLine[i] == '-' )
continue;
else if ( pLine[i] == '0' ) // 0
bVar = Cudd_Not( Cudd_bddIthVar(dd, 29-i) );
else if ( pLine[i] == '1' ) // 1
bVar = Cudd_bddIthVar(dd, 29-i);
else assert(0);
bCube = Cudd_bddAnd( dd, bTemp = bCube, bVar ); Cudd_Ref( bCube );
Cudd_RecursiveDeref( dd, bTemp );
}
Cudd_Deref( bCube );
return bCube;
}示例10: Cudd_Cofactor
/**Function********************************************************************
Synopsis [Computes the cofactor of f with respect to g.]
Description [Computes the cofactor of f with respect to g; g must be
the BDD or the ADD of a cube. Returns a pointer to the cofactor if
successful; NULL otherwise.]
SideEffects [None]
SeeAlso [Cudd_bddConstrain Cudd_bddRestrict]
******************************************************************************/
DdNode *
Cudd_Cofactor(
DdManager * dd,
DdNode * f,
DdNode * g)
{
DdNode *res,*zero;
zero = Cudd_Not(DD_ONE(dd));
if (g == zero || g == DD_ZERO(dd)) {
(void) fprintf(stdout,"Cudd_Cofactor: Invalid restriction 1\n");
return(NULL);
}
do {
dd->reordered = 0;
res = cuddCofactorRecur(dd,f,g);
} while (dd->reordered == 1);
return(res);
} /* end of Cudd_Cofactor */示例11: Cudd_bddBooleanDiff
/**Function********************************************************************
Synopsis [Computes the boolean difference of f with respect to x.]
Description [Computes the boolean difference of f with respect to the
variable with index x. Returns the BDD of the boolean difference if
successful; NULL otherwise.]
SideEffects [None]
SeeAlso []
******************************************************************************/
DdNode *
Cudd_bddBooleanDiff(
DdManager * manager,
DdNode * f,
int x)
{
DdNode *res, *var;
/* If the variable is not currently in the manager, f cannot
** depend on it.
*/
if (x >= manager->size) return(Cudd_Not(DD_ONE(manager)));
var = manager->vars[x];
do {
manager->reordered = 0;
res = cuddBddBooleanDiffRecur(manager, Cudd_Regular(f), var);
} while (manager->reordered == 1);
return(res);
} /* end of Cudd_bddBooleanDiff */示例12: cuddCheckCube
/**Function********************************************************************
Synopsis [Checks whether g is the BDD of a cube.]
Description [Checks whether g is the BDD of a cube. Returns 1 in case
of success; 0 otherwise. The constant 1 is a valid cube, but all other
constant functions cause cuddCheckCube to return 0.]
SideEffects [None]
SeeAlso []
******************************************************************************/
int
cuddCheckCube(
DdManager * dd,
DdNode * g)
{
DdNode *g1,*g0,*one,*zero;
one = DD_ONE(dd);
if (g == one) return(1);
if (Cudd_IsConstant(g)) return(0);
zero = Cudd_Not(one);
cuddGetBranches(g,&g1,&g0);
if (g0 == zero) {
return(cuddCheckCube(dd, g1));
}
if (g1 == zero) {
return(cuddCheckCube(dd, g0));
}
return(0);
} /* end of cuddCheckCube */示例13: bdd_encode_pc
/* encode the program counter in an array of boolean variables */
DdNode* bdd_encode_pc(DdManager* m, DdNode* node, int** pc_array, int pc_size,
int proc, int pc) {
int i;
DdNode* tmp, *var;
DdNode* ret = Cudd_ReadOne(m);
Cudd_Ref(ret);
for (i=0; i<pc_size; i++) { /* iterate for each bit in pc_size */
var = Cudd_bddIthVar(m, pc_array[proc][i]);
if (pc % 2) /* encode true bit */
tmp = Cudd_bddAnd(m, var, ret);
else /* encode false bit */
tmp = Cudd_bddAnd(m, Cudd_Not(var), ret);
Cudd_Ref(tmp);
Cudd_RecursiveDeref(m, ret); /* release the old bdd each time a new */
ret = tmp; /* one is made */
pc /= 2;
}
tmp = Cudd_bddAnd(m, ret, node); /* add encoding to existing edge */
Cudd_Ref(tmp);
Cudd_RecursiveDeref(m, ret);
Cudd_RecursiveDeref(m, node);
return tmp; /* return updated edge */
}示例14: shadow_negate
/* Compute negation. Creates CUDD reference. For ZDDs, records as reference */
ref_t shadow_negate(shadow_mgr mgr, ref_t a) {
ref_t r = REF_INVALID;
if (REF_IS_INVALID(a))
return a;
if (do_ref(mgr))
r = REF_NEGATE(a);
else {
DdNode *an = get_ddnode(mgr, a);
if (is_zdd(mgr, a)) {
DdNode *zone = Cudd_ReadZddOne(mgr->bdd_manager, 0);
reference_dd(mgr, zone);
DdNode *ann = Cudd_zddDiff(mgr->bdd_manager, zone, an);
reference_dd(mgr, ann);
unreference_dd(mgr, zone, IS_ZDD);
r = dd2ref(ann, IS_ZDD);
// For ZDDs, don't already have negated values recorded
add_ref(mgr, r, ann);
} else if (is_add(mgr, a)) {
DdNode *ann = Cudd_addCmpl(mgr->bdd_manager, an);
reference_dd(mgr, ann);
r = dd2ref(ann, IS_ADD);
// For ADDs, don't already have negated values recorded
add_ref(mgr, r, ann);
} else {
DdNode *ann = Cudd_Not(an);
reference_dd(mgr, ann);
r = dd2ref(ann, IS_BDD);
}
}
#if RPT >= 5
char buf[24], nbuf[24];
shadow_show(mgr, a, buf);
shadow_show(mgr, r, nbuf);
report(5, "Negated %s to get %s", buf, nbuf);
#endif
return r;
}示例15: d
/**Function********************************************************************
Synopsis [Generates a BDD for the function d(x,y) > d(y,z).]
Description [This function generates a BDD for the function d(x,y)
> d(y,z);
x, y, and z are N-bit numbers, x\[0\] x\[1\] ... x\[N-1\],
y\[0\] y\[1\] ... y\[N-1\], and z\[0\] z\[1\] ... z\[N-1\],
with 0 the most significant bit.
The distance d(x,y) is defined as:
\sum_{i=0}^{N-1}(|x_i - y_i| \cdot 2^{N-i-1}).
The BDD is built bottom-up.
It has 7*N-3 internal nodes, if the variables are ordered as follows:
x\[0\] y\[0\] z\[0\] x\[1\] y\[1\] z\[1\] ... x\[N-1\] y\[N-1\] z\[N-1\]. ]
SideEffects [None]
SeeAlso [Cudd_PrioritySelect Cudd_Dxygtdxz Cudd_Xgty Cudd_bddAdjPermuteX]
******************************************************************************/
DdNode *
Cudd_Dxygtdyz(
DdManager * dd /* DD manager */,
int N /* number of x, y, and z variables */,
DdNode ** x /* array of x variables */,
DdNode ** y /* array of y variables */,
DdNode ** z /* array of z variables */)
{
DdNode *one, *zero;
DdNode *z1, *z2, *z3, *z4, *y1_, *y2, *x1;
int i;
one = DD_ONE(dd);
zero = Cudd_Not(one);
/* Build bottom part of BDD outside loop. */
y1_ = Cudd_bddIte(dd, y[N-1], one, z[N-1]);
if (y1_ == NULL) return(NULL);
cuddRef(y1_);
y2 = Cudd_bddIte(dd, y[N-1], z[N-1], zero);
if (y2 == NULL) {
Cudd_RecursiveDeref(dd, y1_);
return(NULL);
}
cuddRef(y2);
x1 = Cudd_bddIte(dd, x[N-1], y1_, Cudd_Not(y2));
if (x1 == NULL) {
Cudd_RecursiveDeref(dd, y1_);
Cudd_RecursiveDeref(dd, y2);
return(NULL);
}
cuddRef(x1);
Cudd_RecursiveDeref(dd, y1_);
Cudd_RecursiveDeref(dd, y2);
/* Loop to build the rest of the BDD. */
for (i = N-2; i >= 0; i--) {
z1 = Cudd_bddIte(dd, z[i], x1, zero);
if (z1 == NULL) {
Cudd_RecursiveDeref(dd, x1);
return(NULL);
}
cuddRef(z1);
z2 = Cudd_bddIte(dd, z[i], x1, one);
if (z2 == NULL) {
Cudd_RecursiveDeref(dd, x1);
Cudd_RecursiveDeref(dd, z1);
return(NULL);
}
cuddRef(z2);
z3 = Cudd_bddIte(dd, z[i], one, x1);
if (z3 == NULL) {
Cudd_RecursiveDeref(dd, x1);
Cudd_RecursiveDeref(dd, z1);
Cudd_RecursiveDeref(dd, z2);
return(NULL);
}
cuddRef(z3);
z4 = Cudd_bddIte(dd, z[i], one, Cudd_Not(x1));
if (z4 == NULL) {
Cudd_RecursiveDeref(dd, x1);
Cudd_RecursiveDeref(dd, z1);
Cudd_RecursiveDeref(dd, z2);
Cudd_RecursiveDeref(dd, z3);
return(NULL);
}
cuddRef(z4);
Cudd_RecursiveDeref(dd, x1);
y1_ = Cudd_bddIte(dd, y[i], z2, z1);
if (y1_ == NULL) {
Cudd_RecursiveDeref(dd, z1);
Cudd_RecursiveDeref(dd, z2);
Cudd_RecursiveDeref(dd, z3);
Cudd_RecursiveDeref(dd, z4);
return(NULL);
}
cuddRef(y1_);
y2 = Cudd_bddIte(dd, y[i], z4, Cudd_Not(z3));
if (y2 == NULL) {
Cudd_RecursiveDeref(dd, z1);
//.........这里部分代码省略.........