Beispiel #1
0
bvt bv_utilst::negate(const bvt &bv)
{
  bvt result=inverted(bv);
  literalt carry_out;
  incrementer(result, const_literal(true), carry_out);
  return result;
}
Beispiel #2
0
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;
}
Beispiel #3
0
bool File< Objet >::estPleine ( void ) const
/*------------------------------------------------------------------------- */
{
	int indice = dernier;
	indice = incrementer ( indice ) ;
	if ( indice == premier ) return true;
	return false;
}
Beispiel #4
0
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;
}
Beispiel #5
0
/* *************************************************************** */  
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 */
    }   
}   
Beispiel #6
0
  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;
}
Beispiel #7
0
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;
}
Beispiel #8
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);   
}