/**Function******************************************************************** Synopsis [Check that minterm counts have not changed.] Description [Counts the minterms in the global functions of the primary outputs of the network passed as argument. When it is calld with the second argument set to NULL, it allocates a symbol table and stores, for each output, the minterm count. If an output does not have a BDD, it stores a NULL pointer for it. If it is called with a non-null second argument, it assumes that the symbol table contains the minterm counts measured previously and it compares the new counts to the old ones. Finally, it frees the symbol table. check_minterms is designed so that it can be called twice: once before reordering, and once after reordering. Returns a pointer to the symbol table on the first invocation and NULL on the second invocation.] SideEffects [None] SeeAlso [] ******************************************************************************/ st_table * checkMinterms( BnetNetwork * net, DdManager * dd, st_table * previous) { BnetNode *po; int numPi; char *name; double *count, newcount, *oldcount; int flag,err,i; numPi = net->ninputs; if (previous == NULL) { previous = st_init_table(strcmp,st_strhash); if (previous == NULL) { (void) printf("checkMinterms out-of-memory\n"); return(NULL); } for (i = 0; i < net->noutputs; i++) { if (!st_lookup(net->hash,net->outputs[i],&po)) { exit(2); } name = net->outputs[i]; if (po->dd != NULL) { count = ALLOC(double,1); *count = Cudd_CountMinterm(dd,po->dd,numPi); err = st_insert(previous, name, (char *) count); } else {
static keyvalue_table_ptr cudd_count(shadow_mgr mgr, set_ptr roots) { word_t wk, wv; keyvalue_table_ptr result = word_keyvalue_new(); set_iterstart(roots); while (set_iternext(roots, &wk)) { ref_t r = (ref_t) wk; DdNode *n = get_ddnode(mgr, r); bool zdd = is_zdd(mgr, r); #if USE_APA int digits; DdApaNumber num = Cudd_ApaCountMinterm(mgr->bdd_manager, n, mgr->nvars, &digits); wv = apa2word(num, digits); FREE(num); #else double fv = 0.0; if (zdd) { fv = Cudd_zddCountMinterm(mgr->bdd_manager, n, mgr->nzvars); } else { fv = Cudd_CountMinterm(mgr->bdd_manager, n, mgr->nvars); } wv = (word_t) fv; #endif keyvalue_insert(result, wk, wv); } return result; }
void BDD::printTuples(int a, std::ostream& os) const { if (node ==CDD_ONE(Cudd::dd)) { os << "Universe"; return; } if (node == CDD_ZERO(Cudd::dd)) { os << "Empty"; return; } DdGen* gen; int *cube = (int*)malloc(sizeof(int)*(1<<(BBV+BA))); int tuple[1<<BA]; CUDD_VALUE_TYPE val; int done; int i,k,j; os << "#(" << Cudd_CountMinterm(Cudd::dd,node,a<<BBV) << "){"; //printf("Cardinality: %f\n", Cudd_CountMinterm(Cudd::dd,node,a<<BBV)); for(k=0;k<1<<BA;k++)tuple[k]=0; Cudd_ForeachCube(Cudd::dd,node,gen,cube,val){ done=0; while(!done){ done=1; for(i=(1<<(BBV+BA))-1;i>=0;i--){ if((i&((1<<BA)-1))<a){ tuple[i&((1<<BA)-1)]&=~(1<<((1<<BBV)-1-(i>>BA))); tuple[i&((1<<BA)-1)]|=(cube[i]&1)<<((1<<BBV)-1-(i>>BA)); if((cube[i]&2)&&done){ done&=cube[i]&1; cube[i]^=1; } } } os << "<"; for(j = 0; j < a; j++) { os << tuple[j] << ",";//printf("%d,",tuple[j]); } //printf(">\n"); os << ">, "; }
/**Function************************************************************* Synopsis [] Description [] SideEffects [] SeeAlso [] ***********************************************************************/ void Abc_MvRead( Mv_Man_t * p ) { FILE * pFile; char Buffer[1000], * pLine; DdNode * bCube, * bTemp, * bProd, * bVar0, * bVar1, * bCubeSum; int i, v; // start the cube bCubeSum = Cudd_ReadLogicZero(p->dd); Cudd_Ref( bCubeSum ); // start the values for ( i = 0; i < 15; i++ ) for ( v = 0; v < 4; v++ ) { p->bValues[i][v] = Cudd_ReadLogicZero(p->dd); Cudd_Ref( p->bValues[i][v] ); p->bValueDcs[i][v] = Cudd_ReadLogicZero(p->dd); Cudd_Ref( p->bValueDcs[i][v] ); } // read the file pFile = fopen( "input.pla", "r" ); while ( fgets( Buffer, 1000, pFile ) ) { if ( Buffer[0] == '#' ) continue; if ( Buffer[0] == '.' ) { if ( Buffer[1] == 'e' ) break; continue; } // get the cube bCube = Abc_MvReadCube( p->dd, Buffer, 18 ); Cudd_Ref( bCube ); // add it to the values of the output functions pLine = Buffer + 19; for ( i = 0; i < 15; i++ ) { if ( pLine[2*i] == '-' && pLine[2*i+1] == '-' ) { for ( v = 0; v < 4; v++ ) { p->bValueDcs[i][v] = Cudd_bddOr( p->dd, bTemp = p->bValueDcs[i][v], bCube ); Cudd_Ref( p->bValueDcs[i][v] ); Cudd_RecursiveDeref( p->dd, bTemp ); } continue; } else if ( pLine[2*i] == '0' && pLine[2*i+1] == '0' ) // 0 v = 0; else if ( pLine[2*i] == '1' && pLine[2*i+1] == '0' ) // 1 v = 1; else if ( pLine[2*i] == '0' && pLine[2*i+1] == '1' ) // 2 v = 2; else if ( pLine[2*i] == '1' && pLine[2*i+1] == '1' ) // 3 v = 3; else assert( 0 ); // add the value p->bValues[i][v] = Cudd_bddOr( p->dd, bTemp = p->bValues[i][v], bCube ); Cudd_Ref( p->bValues[i][v] ); Cudd_RecursiveDeref( p->dd, bTemp ); } // add the cube bCubeSum = Cudd_bddOr( p->dd, bTemp = bCubeSum, bCube ); Cudd_Ref( bCubeSum ); Cudd_RecursiveDeref( p->dd, bTemp ); Cudd_RecursiveDeref( p->dd, bCube ); } // add the complement of the domain to all values for ( i = 0; i < 15; i++ ) for ( v = 0; v < 4; v++ ) { if ( p->bValues[i][v] == Cudd_Not(Cudd_ReadOne(p->dd)) ) continue; p->bValues[i][v] = Cudd_bddOr( p->dd, bTemp = p->bValues[i][v], p->bValueDcs[i][v] ); Cudd_Ref( p->bValues[i][v] ); Cudd_RecursiveDeref( p->dd, bTemp ); p->bValues[i][v] = Cudd_bddOr( p->dd, bTemp = p->bValues[i][v], Cudd_Not(bCubeSum) ); Cudd_Ref( p->bValues[i][v] ); Cudd_RecursiveDeref( p->dd, bTemp ); } printf( "Domain = %5.2f %%.\n", 100.0*Cudd_CountMinterm(p->dd, bCubeSum, 32)/Cudd_CountMinterm(p->dd, Cudd_ReadOne(p->dd), 32) ); Cudd_RecursiveDeref( p->dd, bCubeSum ); // create each output function for ( i = 0; i < 15; i++ ) { p->bFuncs[i] = Cudd_ReadLogicZero(p->dd); Cudd_Ref( p->bFuncs[i] ); for ( v = 0; v < 4; v++ ) { bVar0 = Cudd_NotCond( Cudd_bddIthVar(p->dd, 30), ((v & 1) == 0) ); bVar1 = Cudd_NotCond( Cudd_bddIthVar(p->dd, 31), ((v & 2) == 0) ); bCube = Cudd_bddAnd( p->dd, bVar0, bVar1 ); Cudd_Ref( bCube ); bProd = Cudd_bddAnd( p->dd, p->bValues[i][v], bCube ); Cudd_Ref( bProd ); Cudd_RecursiveDeref( p->dd, bCube ); // add the value p->bFuncs[i] = Cudd_bddOr( p->dd, bTemp = p->bFuncs[i], bProd ); Cudd_Ref( p->bFuncs[i] ); Cudd_RecursiveDeref( p->dd, bTemp ); Cudd_RecursiveDeref( p->dd, bProd ); } } }
double BDD::minterms(int nvars) const { return Cudd_CountMinterm(Cudd::dd, node, nvars<<BBV); }