bvt bv_utilst::negate(const bvt &bv)
{
bvt result=inverted(bv);
literalt carry_out;
incrementer(result, const_literal(true), carry_out);
return result;
}
int main(int argc,char **argv)
{
if(argc!=2)
{
std::cout << "usage: " << argv[0] << "<integer>\n";
exit(0);
}
std::cout << std::boolalpha;
std::vector<int> number;
const int N = atoi(argv[1]);
const int SUMN = (N-1)*N/2;
for(int i=0;i<N;++i)
{
number.push_back(i);
}
std::vector<int> largest_number = number;
std::reverse(largest_number.begin(),largest_number.end());
int count = 0;
while(number!=largest_number)
{
int sum = incrementer(number);
if(sum==SUMN)
{
++count;
std::cout << "p: " << number << std::endl;
}
}
++count;
std::cout << count << std::endl;
return 0;
}
bool File< Objet >::estPleine ( void ) const
/*------------------------------------------------------------------------- */
{
int indice = dernier;
indice = incrementer ( indice ) ;
if ( indice == premier ) return true;
return false;
}
File< Objet > & File< Objet >::sortir ( Objet &recupere ) throw ( FileVide )
/*------------------------------------------------------------------------- */
{
if ( estVide ( ) ) throw File::FileVide ( ) ;
recupere = *objets[ premier ];
premier = incrementer( premier );
if ( ( capacite - fournirNombreDObjets ( ) ) == 2*increment )
restituer ( ) ;
return *this;
}
/* *************************************************************** */
void renouvellementNoeud(char c) {
if(!pCharNoeud[c]) { /* element c n'est pas dans l'arbre => 1er fois entree */
/* remplace pNYT par sous-arbre => fils gauche : pNYT
fils droit : char c */
pNYT->poids = 1;
pNYT->Char = -1;
pNYT->pFils[1] = (PNOEUD) malloc(sizeof(NOEUD));//nouvelle feuille
pNYT->pFils[0] = (PNOEUD) malloc(sizeof(NOEUD));//nouveau NYT
/* mettre les donnees de fils gauche */
pNYT->pFils[0]->pPere = pNYT;
pNYT->pFils[0]->numNo = pNYT->numNo-2;
pNYT->pFils[0]->poids = 0;
pNYT->pFils[0]->Char = -1;
memset(pNYT->pFils[0]->pFils,0,sizeof(pNYT->pFils[0]->pFils));
pNYT->pFils[0]->pPrev = NULL;
pNYT->pFils[0]->pbloc = NULL;
/* mettre les donnees de fils droit */
pNYT->pFils[1]->pPere = pNYT;
pNYT->pFils[1]->numNo = pNYT->numNo-1;
pNYT->pFils[1]->poids = 1;
pNYT->pFils[1]->Char = c;
memset(pNYT->pFils[1]->pFils,0,sizeof(pNYT->pFils[1]->pFils));
pNYT->pFils[1]->pPrev = NULL;
pNYT->pFils[1]->pbloc = NULL;
/* ajout c dans l'arbre */
pCharNoeud[c] = pNYT->pFils[1];
pNYT = pNYT->pFils[0];
renouvellementBloc(pNYT->pPere);
pCharNoeud[c]->pbloc = pCharNoeud[c]->pPere->pbloc;
pCharNoeud[c]->pPere->pPrev = pCharNoeud[c];
incrementer(pCharNoeud[c]->pPere->pPere); /* le noeud a incrementer : son grand-pere*/
}
else { /* element c est deja dans l'arbre */
incrementer(pCharNoeud[c]); /* le noeud a incrementer : soi-meme */
}
}
bool
next_mapping(BidirectionalIterator first,
BidirectionalIterator last,
T first_value, T last_value, Incrementer increment)
{
if (last == first ) {
return false;
}
do {
if (incrementer(*(--last)) != last_value) {
return true;
}
*last = first_value;
} while (last != first);
return false;
}
int main() {
omp_init_lock(&g_lock_a);
omp_lock_t lock_b;
omp_init_lock(&lock_b);
#pragma omp parallel num_threads(THREADS)
incrementer(&lock_b);
if(!(g_a == LOOP_ITS*THREADS && g_b == LOOP_ITS*THREADS)) {
printf("FAILURE\n");
return 0;
}
#pragma omp parallel num_threads(THREADS)
decrementer(&lock_b);
if (!(g_a == 0 && g_b == 0)) {
printf("FAILURE\n");
return 0;
}
printf("success\n");
return 0;
}
/* *************************************************************** */
void incrementer(PNOEUD pNoeud)
{
NOEUD noeud;
PNOEUD pNext;
/* si pNoeud est vide => 1er fois ajouter de noeud*/
if(!pNoeud) return;
/* le noued a plus grand numNo dans le blos de pNoeud (P_max) n'est pas le pere de pNoeud
=> cas general */
if(pNoeud->pbloc->pPrem != pNoeud->pPere) {
/* c'est le cas : on a besoin de echanger les noeuds */
if(pNoeud->pbloc->pPrem->numNo > pNoeud->numNo) {
/* la partie echange dans l'arbre */
/* sauvegarder P_max */
noeud = *pNoeud->pbloc->pPrem;
/* P_max est le frere de pNoeud */
if(pNoeud->pbloc->pPrem->pPere == pNoeud->pPere) {
/* echanger */
pNoeud->pPere->pFils[0] = (pNoeud->pPere->pFils[0] == pNoeud)?pNoeud->pbloc->pPrem:pNoeud;
pNoeud->pPere->pFils[1] = (pNoeud->pPere->pFils[1] == pNoeud)?pNoeud->pbloc->pPrem:pNoeud;
}
else {
/* pere de P_max n'est pas vide => P_max n'est pas racine */
if(pNoeud->pbloc->pPrem->pPere) {
/* echanger */
/* si P_max est le fils gauche */
if(pNoeud->pbloc->pPrem->pPere->pFils[0] == pNoeud->pbloc->pPrem)
pNoeud->pbloc->pPrem->pPere->pFils[0] = pNoeud;
else /* P_max est le fils droit */
pNoeud->pbloc->pPrem->pPere->pFils[1] = pNoeud;
}
/* pere de pNoeud n'est pas vide => pNoeud n'est pas racine */
if(pNoeud->pPere) {
/* pNoeud est fils gauche */
if(pNoeud->pPere->pFils[0] == pNoeud)
pNoeud->pPere->pFils[0] = pNoeud->pbloc->pPrem;
else /* pNoeud est fils droit */
pNoeud->pPere->pFils[1] = pNoeud->pbloc->pPrem;
}
pNoeud->pbloc->pPrem->pPere = pNoeud->pPere;
pNoeud->pPere = noeud.pPere;
}
/* la partie echange dans le bloc */
/* pNext = P_max */
pNext = pNoeud->pbloc->pPrem;
/* chercher pNoeud dans le bloc */
while(pNext->pPrev->numNo > pNoeud->numNo) pNext = pNext->pPrev;
/* numNo de pNoeud est bien max, echanger pas */
if(pNext == pNoeud->pbloc->pPrem) {
/* mettre pNoeud au Prem de son bloc */
pNoeud->pbloc->pPrem->pPrev = pNoeud->pPrev;
pNoeud->pPrev = pNoeud->pbloc->pPrem;
}
else { /* on a besoin de echanger P_max <=> pNoeud */
pNoeud->pbloc->pPrem->pPrev = pNoeud->pPrev;
pNext->pPrev = pNoeud->pbloc->pPrem;
pNoeud->pPrev = noeud.pPrev;
}
pNoeud->pbloc->pPrem->numNo = pNoeud->numNo;
pNoeud->numNo = noeud.numNo;
pNoeud->pbloc->pPrem = pNoeud;
}
/* apres echanger, pNoued a plus grand numNo
mettre le suivant noeud au pPrem de bloc (pNoeud vas etre ajouter dans l'autre bloc)*/
if(pNoeud->pPrev) pNoeud->pbloc->pPrem = pNoeud->pPrev;
else { /* ce bloc contient un seul noeud => pNoeud
=> supprimer ce bloc */
if(pNoeud->pbloc->pPrev)
pNoeud->pbloc->pPrev->pNext = pNoeud->pbloc->pNext;
if(pNoeud->pbloc->pNext)
pNoeud->pbloc->pNext->pPrev = pNoeud->pbloc->pPrev;
free(pNoeud->pbloc);
}
}
else { /* P_max est le pere de pNoeud => cas particulier
supprimer pNoeud depuis le bloc */
pNext = pNoeud->pbloc->pPrem;
/* chercher pNoeud */
while(pNext->pPrev != pNoeud) pNext = pNext->pPrev;
pNext->pPrev = pNoeud->pPrev;
}
/* supprimer le champs bloc de pNoeud */
pNoeud->pbloc = NULL;
pNoeud->poids++;
/* mise a jour le champs bloc de pNoeud */
renouvellementBloc(pNoeud);
incrementer(pNoeud->pPere);
}