Пример #1
0
Automate::~Automate(){

    deleteTableTranstion();
    deleteQ();
    deleteI();
    deleteT();
}
Пример #2
0
void main()
{
        int queue[MAX];
        int front,rear;
        int n,value;
        front=0; rear=0;
      do
      {

        do
        {
          printf("Enter the element to be inserted\n");
          scanf("%d",&value);
          insert(queue,&rear,front,value);
          printf("Enter 1 to continue\n");
          scanf("%d",&n);
        } while(n == 1);
        
        printf("Enter 1 to delete an element\n");
        scanf("%d",&n);
          while( n == 1)
          {
     deleteQ(queue,&front,rear,&value);
          printf("The value deleted is %d\n",value);
          printf("Enter 1 to delete an element\n");
          scanf("%d",&n);
          }
        printf("Enter 1 to continue\n");
        scanf("%d",&n);
      } while(n == 1);
 }
Пример #3
0
int main(int argc, char const *argv[])
{
	Queue *q = createQueue();
	for (int i = 0; i < MAX_SIZE; ++i)
	{
		addQ(q, i);
	}
	for (int i = 0; i < MAX_SIZE; ++i)
	{
		deleteQ(q);
	}
	return 0;
}
Пример #4
0
main () 
{
	int i, M, N, nodeNumber, continueLoop = 1;
	int tsd, res, optVal,tsItems,tpnamsz, tplength, status;
	char tpname[128];
	double L, ubb, lbb, profit, cap, globalOptimal;
	NODE *node;	
	ELEM *PbyW;
	static int itemsCopied = 0;

	puts("Going to start Worker bfsKnap");
	fflush(stdout);
	tsItems = cnf_open("Items", 0);
	tsd = cnf_open("Nodes", 0);
	res = cnf_open("Results", 0);
	optVal = cnf_open("OptVal", 0);

	
    while(1) {	
	puts("WORKER TIME STARTED");
	fflush(stdout);
	startTime = time((long *)0);
	maxLiveNodes = 1;
	atLevel = 0;
	qLive = NULL;
	endQLive = NULL;
	numOps = 0;
	/* get tuple put by master */
	strcpy(tpname, "*\0");
	tpnamsz = strlen(tpname);
	tplength = sizeof(struct ituple);
	status = cnf_tsget(tsd, tpname, &ituple, 0);
	if (status > 0) {
	    //printItuple(ituple);
	    if(ituple.numItems == 0) {
#ifdef DEBUG
		puts("Worker found last tuple");
		fflush(stdout);
#endif
		status = cnf_tsput(tsd, tpname, &ituple,status);
		cnf_term();
	     }
	/* get the global optimal if not the first iteration of while loop*/	
	if(itemsCopied) {
		strcpy(tpname, "*");
		tpnamsz = strlen(tpname);
		tplength = sizeof(double);
		status = cnf_tsread(optVal, tpname, &globalOptimal, 0);
		if (status > 0)	{
			if (ituple.L < globalOptimal){
				tplength = sizeof(struct otuple);

				otuple.nodeNumber = ituple.nodeNumber;
				otuple.L = 0;
				otuple.numOps = numOps;
				sprintf(tpname, "node%d\0",ituple.nodeNumber);
#ifdef DEBUG
		printf("Worker going to put otuple without processing\n");
		fflush(stdout);
#endif
				cnf_tsput(res, tpname, &otuple, tplength);
		printf("worker fake tp(%s) returned\n",tpname);
		fflush(stdout); 
				continue; /* to the start of WHILE LOOP */
			}
		} else{
			printf("Error in reading global optimal\n");
			fflush(stdout);
		}
			
	}
	/* fill in L etc */
		i = ituple.level;
		L = ituple.L;
		ubb = ituple.ubb;
		M = ituple.capacity;
		N = ituple.numItems;
		nodeNumber = ituple.nodeNumber;	
	}
	else {
		printf("Error in getting node in worker ");
		fflush(stdout);
		exit(1);
	}	

	if(!itemsCopied) {
		PbyW = (ELEM *) malloc( N * sizeof(ELEM) );
		tplength = N * sizeof(ELEM);
#ifdef DEBUG
		puts("Going to get the items");
		fflush(stdout);
#endif
		strcpy(tpname,"Items"); 
		status = cnf_tsread(tsItems, tpname, PbyW, 0); /* Just copy */
		if (status <= 0) {
			printf("Error in getting items back in worker ");
			fflush(stdout);
			exit(2);
		}
		//else printf("Items copied\n");
		itemsCopied = 1;
	}
	
	//luBound(PbyW, M, 0, N, 0, &L, &ubb);		
	//printf("L is %g and ubb is %g\n", L, ubb);
	//newNode(NULL, 0, M, 0, ubb);	
	newNode(NULL, ituple.tag, ituple.cu, ituple.profit, ituple.ub);
	addQLevelMarker();
	while(i < N) {
		for(;continueLoop;) {
			node = deleteQ();
			//printNode(node);
			switch(node->tag) {
		   	   case -1:
				continueLoop = 0;
				break;
		   	   default:
	//printf("Node->ub is %g and L is %g\n", node->ub, L);
				if(node->ub >= L){
					cap = node->cu;
					profit = node->profit;
					if(cap >= PbyW[i].wt) {
						newNode(node, 1, (cap - PbyW[i].wt), (profit + PbyW[i].profit), node->ub);
						numOps += 2;
					}
					luBound(PbyW, cap, profit, N, (i+1), &lbb, &ubb);
					++numOps;
			//printf("Cap is %g, PbyW[%d].wt is %g, ubb is %g\n", cap,i ,PbyW[i].wt, ubb);
					if(ubb >= L) {
						newNode(node, 0, cap, profit, ubb);
						L = (L > lbb)? L: lbb;
					}
				}
				free(node);
				break;	      
			}
		}
		addQLevelMarker();
		continueLoop = 1;
		//printf("Live nodes at level(root at 0) %d are %ld\n", i, numLiveNodes);
		if(numLiveNodes == 0){
			printf("Going to discard this node %d\n", nodeNumber);
			qLive = NULL;
			endQLive = NULL;
			i = N; /* break from while loop */
		}
		if(numLiveNodes > maxLiveNodes){
			maxLiveNodes = numLiveNodes;
			atLevel = 1;
		}
			
	i++;
	}
        if(qLive == NULL)
		packResults(0, qLive, N, M, nodeNumber, res, optVal);
	else for(; qLive; qLive = qLive->next) {
		if(qLive->profit == L) {
			packResults(L, qLive, N, M, nodeNumber, res, optVal);
			break;
		}
	     }
	endTime = time((long *)0) - startTime;
	puts("WORKER TIME ENDED");
	fflush(stdout);
  
   /*
	for(; qLive; qLive = qLive->next) {
		if(qLive->profit == L) 
			packResults(L, qLive, N, M, nodeNumber, res, optVal);
	}
   */
   }
}	
Пример #5
0
void bfsKnap(ELEM *PbyW, int M, int N) 
{
	int i, continueLoop = 1, knapCapacity;
	int tsd, res, tsItems, optVal, tpnamsz;
	double L, ubb, lbb, profit, cap;
	NODE *node;
	int CONS;

	CONS = atoi(getenv("NUMT"));	
//	CONS = 1;
	knapCapacity = M;
	puts("Going to start bfsKnap");
	fflush(stdout);
	maxLiveNodes = 1;
	atLevel = 0;
	
	tsd = cnf_open("Nodes", 0);
	tsItems = cnf_open("Items", 0);
	res = cnf_open("Results", 0);
	optVal = cnf_open("OptVal", 0);

	cnf_tsput(tsItems, "Items", PbyW, (N * sizeof(ELEM)));

	numProcessors = cnf_getP();
	puts("TIME STARTED");
	fflush(stdout);
	startTime = time((long *)0);
	i = 0;	
	luBound(PbyW, M, 0, N, 0, &L, &ubb);		
	//printf("L is %g and ubb is %g\n", L, ubb);
	newNode(NULL, 0, M, 0, ubb);	
	addQLevelMarker();
	while(i < N) {
		for(;continueLoop;) {
			node = deleteQ();
			//printNode(node);
			switch(node->tag) {
		   	   case -1:
				continueLoop = 0;
				break;
		   	   default:
	//printf("Node->ub is %g and L is %g\n", node->ub, L);
				if(node->ub >= L){
					cap = node->cu;
					profit = node->profit;
					if(cap >= PbyW[i].wt) {
						newNode(node, 1, (cap - PbyW[i].wt), (profit + PbyW[i].profit), node->ub);
						numOps += 2;
					}
					luBound(PbyW, cap, profit, N, (i+1), &lbb, &ubb);
					++numOps;
			//printf("Cap is %g, PbyW[%d].wt is %g, ubb is %g\n", cap,i ,PbyW[i].wt, ubb);
					if(ubb >= L) {
						newNode(node, 0, cap, profit, ubb);
						L = (L > lbb)? L: lbb;
					}
				}
				free(node);
				break;	      
			}
		}
		addQLevelMarker();
		continueLoop = 1;
		//printf("Live nodes at level(root at 0) %d are %ld\n", i, numLiveNodes);
		if(numLiveNodes == 0){
			puts("Num Live Nodes becoms Zero. ERROR");
			printf("Value of optimal filling %g\n", L);
			break;
		}
		if(numLiveNodes >= (CONS * numProcessors)) {
			/* Going to parallelize */
			/* Distribute the live Nodes */
			/* exit from the while loop by setting i = N */

			int status, nodeNumber = 0;
			char tpname[128];
			int tplength = sizeof(struct ituple);
			NODE *liveNode;	
#ifdef DEBUG
			printf("Num Live nodes to distribute %ld\n", numLiveNodes);
#endif
			for(liveNode = qLive; liveNode->tag != -1; liveNode = liveNode->next, ++nodeNumber) { 
				ituple.level = i;
				ituple.cu = liveNode->cu;
				ituple.profit = liveNode->profit;
				ituple.tag = liveNode->tag;
				ituple.ub = liveNode->ub;
				ituple.capacity = M;
				ituple.ubb = ubb;
				ituple.L = L;
				ituple.numItems = N;
				ituple.nodeNumber = nodeNumber;
				sprintf(tpname, "node%d\0", nodeNumber);
#ifdef DEBUG
				printf("Master putting %s\n", tpname);
#endif
				status = cnf_tsput(tsd, tpname, &ituple, tplength);
			}
			/* now put the terminating tuple */
			ituple.numItems = 0;
			ituple.nodeNumber = nodeNumber;
			sprintf(tpname, "node%d\0", nodeNumber);
#ifdef DEBUG
			printf("Master putting the termination tuple %s\n", tpname);
#endif
			status = cnf_tsput(tsd, tpname, &ituple, tplength);
			
			strcpy(tpname, "OPTVAL\0");
#ifdef DEBUG
			printf("Master putting the optimal value tuple called %s with %g\n",tpname, L);	
#endif
			tplength = sizeof(double);
			status = cnf_tsput(optVal, tpname, &L, tplength);


			i = N; /* to exit from while loop */
		}			
	i++;
	}
	printResults(numLiveNodes, res, knapCapacity);
	cnf_close(tsd);
	cnf_close(tsItems);
	cnf_close(res);
	cnf_close(optVal);
	cnf_term();
}	
Пример #6
0
bool Automate::ouvrir(const string& nomFichier){

    deleteTableTranstion();
    deleteA();
    deleteQ();
    deleteI();
    deleteT();

    ifstream fichier(nomFichier.c_str(), ios::in);
    if (fichier.is_open()){

        string charA;
        string charQ;
        string charI;
        string charT;
        string charTDT;
        string temp;

        getline(fichier,charA);

        for(unsigned int i = 0; i < charA.size(); i++)
        {
            temp.clear();
            while ((i < charA.size())&&(charA[i] == ' '))
                i++;
            while((i < charA.size())&&(charA[i] != ' ')){
                temp += charA.substr(i,1);
                i++;
            }
            _A.push_back(temp);
        }

        getline(fichier,charQ);

        for(unsigned int i = 0; i < charQ.size(); i++)
        {
            temp.clear();
            while ((i < charQ.size())&&(charQ[i] == ' '))
                i++;
            while((i < charQ.size())&&(charQ[i] != ' ')){
                temp += charQ.substr(i,1);
                i++;
            }
            _Q.push_back(new list<string>);
            (*--_Q.end())->push_back(temp);
        }

        getline(fichier,charI);

        for(unsigned int i = 0; i < charI.size(); i++)
        {
            temp.clear();
            while ((i < charI.size())&&(charI[i] == ' '))
                i++;
            while((i < charI.size())&&(charI[i] != ' ')){
                temp += charI.substr(i,1);
                i++;
            }
            _I.push_back(new list<string>);
            (*--_I.end())->push_back(temp);
        }

        getline(fichier,charT);

        for(unsigned int i = 0; i < charT.size(); i++)
        {
            temp.clear();
            while ((i < charT.size())&&(charT[i] == ' '))
                i++;
            while((i < charT.size())&&(charT[i] != ' ')){
                temp += charT.substr(i,1);
                i++;
            }
            _T.push_back(new list<string>);
            (*--_T.end())->push_back(temp);
        }

        list<list<string>*>::iterator iQ;

        for(iQ=_Q.begin(); iQ!=_Q.end(); iQ++){

            _tab[*iQ]=new list<list<string>*>[_A.size()];
        }

        getline(fichier,charTDT);
        iQ = _Q.begin();

        unsigned int col;
        unsigned int start;
        while ((!fichier.eof())&&(iQ != _Q.end())){

            getline(fichier,charTDT);
            col = 0;
            start = 0;
            while ((start < charTDT.size())&&(charTDT[start] == ' '))
                start++;
            while(charTDT[start] != ' ')
                start++;

            for(unsigned int i=start; i < charTDT.size(); i++){

                temp.clear();
                while ((i < charTDT.size())&&(charTDT[i] == ' '))
                    i++;
                while((i < charTDT.size())&&(charTDT[i] != ',')&&(charTDT[i] != ' ')){
                    temp += charTDT.substr(i,1);
                    i++;
                }

                if (temp != "-"){
                    _tab[*iQ][col].push_back(new list<string>);
                    (*--_tab[*iQ][col].end())->push_back(temp);
                }

                if (charTDT[i] == ','){
                    i++;
                }
                else{
                    col++;
                }
            }
            iQ++;
        }

        return true;
    }

    return false;
}
Пример #7
0
bool Automate::minimiser(){

    /* Minimise l'automate
     * Retourne true si l'automate etait deja minimal <=> Le nombre de groupe cree lors de la minimisation est egal au nombre d'etat de l'automate
     * Retourne false si l'automate n'etait pas minimal
     * */

    list<string> groupes; // La liste des groupes Ex : {NT, T}
    list<string> tempgroupes; // Une liste des groupes temporaires
    string  groupeString; // Le groupe auquel appartient un etat
    map<string, list<list<string>*>*> tabG; // Un tableau indexe par les groupes contenant la liste des etats dans un groupe

    //Initialisation de tempGroupes et de tabG
    tempgroupes.push_back("NT");
    tempgroupes.push_back("T");

    tabG["NT"] = new list<list<string>*>;
    tabG["T"] = new list<list<string>*>;

    for(list<list<string>*>::iterator iQ=_T.begin(); iQ!=_T.end(); iQ++)
        tabG["T"]->push_back(*iQ);

    for(list<list<string>*>::iterator iQ=_Q.begin(); iQ!=_Q.end(); iQ++){

        int temp = 0;

        for(list<list<string>*>::iterator iT=_T.begin(); iT!=_T.end(); iT++){

             if( ((*iT)->size() == (*iQ)->size()) && (equal(  (*iQ)->begin(), (*iQ)->end(), (*iT)->begin())  )){
                 temp = 1;
             }
        }

        if(temp == 0)
           tabG["NT"]->push_back(*iQ);
    }

    list<string>::iterator iG;
    QStringList liste;
    QString tempS;
    int cptG;

    // Tant que le nombre de groupe n'est pas egal a celui de la derniere iteration
    while (groupes.size() != tempgroupes.size()) {

        // Initialisation de groupes et reinitialisation de tempgroupes
        groupes = tempgroupes;
        tempgroupes.clear();

        cptG = 1;

        for(list<string>::iterator i = groupes.begin(); i != groupes.end(); i++){

            tempS.clear();

            tempS += "Group " + QString::number(cptG) + " : ";
            for(list<list<string>*>::iterator ii = tabG[*i]->begin(); ii != tabG[*i]->end(); ii++){

                if (ii != tabG[*i]->begin())
                    tempS += ", ";

                tempS += "{";

                for(list<string>::iterator iii = (*ii)->begin(); iii != (*ii)->end(); iii++){

                    if(iii != (*ii)->begin())
                        tempS += ", ";

                    tempS += QString::fromStdString(*iii);
                }

                tempS += "}";
            }

            liste << tempS;
            cptG++;
        }

        liste << "";


        // Pour chaque etat
        for(list<list<string>*>::iterator iQ=_Q.begin(); iQ!=_Q.end(); iQ++){

            // Reinitialisation de groupeString
            groupeString.clear();

            iG = groupes.begin();

            int temp;

            // Faire tant que nous ne trouvons pas dans quel groupe est cet etat
            temp = 1;
            do {

                for(list<list<string>*>::iterator iiG = tabG[*iG]->begin(); iiG != tabG[*iG]->end(); iiG++){

                    // Si les etats sont egaux
                    if (((*iiG)->size() == (*iQ)->size())&&(equal((*iiG)->begin(), (*iiG)->end(), (*iQ)->begin())))
                        temp = 0;
                }

                iG++;

            }while(temp == 1);

            iG--;

            // Insertion de ce groupe dans groupeString
            groupeString = groupeString + *iG;

            for (unsigned int cpt = 0; cpt != _A.size(); cpt++){

                int temp;
                iG = groupes.begin();

                temp = 1;
                 do{

                     list<list<string>*>::iterator iTab = _tab[*iQ][cpt].begin();

                     for(list<list<string>*>::iterator iiG = tabG[*iG]->begin(); iiG != tabG[*iG]->end(); iiG++){

                         if (((*iiG)->size() == (*iTab)->size())&&(equal((*iiG)->begin(), (*iiG)->end(), (*iTab)->begin()))) // Si les etats ne sont pas egaux
                             temp = 0;
                     }

                     iG++;

                 }while(temp == 1);

                 iG--;

                 // Insertion de ce groupe dans groupeString
                 groupeString = groupeString + *iG;
             }

             if(tabG[groupeString] == NULL){
                 tabG[groupeString] = new list<list<string>*>;
             }

             // Insertion de cet etat dans son groupe
             tabG[groupeString]->push_back(*iQ);

             tempgroupes.push_back(groupeString);

             tempgroupes.sort();
             tempgroupes.unique();
        }

        // Suppression des anciens groupes
        for (list<string>::iterator it=groupes.begin(); it != groupes.end(); it++)
            tabG[*it]->clear();
    }

    Interface::messageMinimiser(&liste);

    groupes = tempgroupes;
    tempgroupes.clear();

    if(groupes.size() == _Q.size())
        return true;

    list<list<string>*> Qmin, Tmin, Imin;

    list<string>::iterator iGG;
    list<list<string>*>::iterator iTabG;
    list<list<string>*>::iterator iTab;

    int temp;

    list<list<string>*>::iterator iI;
    list<list<string>*>::iterator iIm;

    iI = _I.begin();
    iG=groupes.begin();
    temp = 1;
    do {

        for(list<list<string>*>::iterator iiG = tabG[*iG]->begin(); iiG != tabG[*iG]->end(); iiG++){

            if (((*iiG)->size() == (*iI)->size())&&(equal((*iiG)->begin(), (*iiG)->end(), (*iI)->begin()))) // Si les etats ne sont pas egaux
                temp = 0;
        }

        iG++;

    }while(temp == 1);

    iG--;

    Imin.push_back(new list<string>);
    iIm =-- Imin.end();

    for(list<list<string>*>::iterator iTabGG = tabG[*iG]->begin(); iTabGG != tabG[*iG]->end(); iTabGG++)
        (*iIm)->insert(--(*iIm)->end(), (*iTabGG)->begin(), (*iTabGG)->end());

    deleteI();
    _I = Imin;

    list<list<string>*>::iterator iTmin;

    for(list<string>::iterator iG = groupes.begin(); iG != groupes.end(); iG++){

        if ((*iG).at(0) == 'T'){

            Tmin.push_back(new list<string>);
            iTmin =-- Tmin.end();

            for(list<list<string>*>::iterator iTabG = tabG[*iG]->begin(); iTabG != tabG[*iG]->end(); iTabG++){

                (*iTmin)->insert(--(*iTmin)->end(), (*iTabG)->begin(), (*iTabG)->end());
            }
        }
    }

    deleteT();
    _T = Tmin;

    list<list<string>*>::iterator iQmin;
    list<list<string>*>::iterator iTabmin;

    for(list<string>::iterator iG=groupes.begin(); iG != groupes.end(); iG++){

        // Creation des états
        Qmin.push_back(new list<string>);
        iQmin = --Qmin.end();

        for(iTabG = tabG[*iG]->begin(); iTabG != tabG[*iG]->end(); iTabG++){

            (*iQmin)->insert(--(*iQmin)->end(), (*iTabG)->begin(), (*iTabG)->end());
        }

        // Creation des transitions associes a chaque etat
        _tab[*(--Qmin.end())] = new list<list<string>*>[_A.size()];

        // Pour chaque transition
        for(unsigned int cpt = 0; cpt < _A.size(); cpt++){

            // Pour un etat dans le groupe
            iTabG = tabG[*iG]->begin();

            // Pour une transition de de cet etat dans le groupe
            iTab = _tab[*iTabG][cpt].begin();

            int temp;
            iGG = groupes.begin();

            temp = 1;

            // Faire tant que nous ne trouvons pas dans quel groupe est cet etat
            do {

                for(list<list<string>*>::iterator iiG = tabG[*iGG]->begin(); iiG != tabG[*iGG]->end(); iiG++){

                    if (((*iiG)->size() == (*iTab)->size())&&(equal((*iiG)->begin(), (*iiG)->end(), (*iTab)->begin())))
                        temp = 0;
                    }

                    iGG++;

            }while(temp == 1);

            iGG--;

            _tab[*(--Qmin.end())][cpt].push_back(new list<string>);

            iTabmin =-- _tab[*(--Qmin.end())][cpt].end();

            for(list<list<string>*>::iterator iTabGG = tabG[*iGG]->begin(); iTabGG != tabG[*iGG]->end(); iTabGG++)
                (*iTabmin)->insert(--(*iTabmin)->end(), (*iTabGG)->begin(), (*iTabGG)->end());
        }
    }

    deleteQ();
    _Q = Qmin;

    return false;
}
Пример #8
0
void Automate::determinisation(){

    /* Determinise l'automate
     * */

    list<list<string>*> Qdet;
    list<list<string>*> Tdet;

    // Creation de l'etat initial (= premier etat de la liste des etats)
    Qdet.push_back(new list<string>);
    list<list<string>*>::iterator iQdet = Qdet.begin();
    _tab[*iQdet] = new list<list<string>*>[_A.size()];

    for(list<list<string>*>::iterator iI=_I.begin(); iI!=_I.end(); iI++)
        (*iQdet)->insert((*iQdet)->begin(),(*iI)->begin(),(*iI)->end());


    (*iQdet)->sort();
    (*iQdet)->unique();

    // Remplace les etats initiaux pour le nouvel etat initial
    _I.clear();
    _I.push_back(new list<string>);
    (*_I.begin())->assign((*iQdet)->begin(),(*iQdet)->end());

    // Creer la nouvelle table de transition et la nouvelle liste des etats
    list<list<string>*>::iterator iQ;
    list<string>::iterator iiQdet;
    unsigned int cpt;

    // Tant qu'il y a des etats dans la nouvelle liste des etats
    while(iQdet != Qdet.end()){

        for(cpt=0; cpt<_A.size(); cpt++){
            _tab[*iQdet][cpt].push_back(new list<string>);
        }

        // Creation des nouvelles transitions pour l'etat concerne
        for(iQ=_Q.begin(); iQ!=_Q.end(); iQ++){
            for(iiQdet=(*iQdet)->begin(); iiQdet!=(*iQdet)->end(); iiQdet++){

                if (find((*iQ)->begin(),(*iQ)->end(),*iiQdet) != (*iQ)->end()){

                    for(cpt=0; cpt<_A.size(); cpt++){

                        list<list<string>*>::iterator iiTab;

                        iiTab = _tab[*iQdet][cpt].begin();
                        for(list<list<string>*>::iterator iTab=_tab[*iQ][cpt].begin(); iTab!=_tab[*iQ][cpt].end(); iTab++)
                            (*iiTab)->insert(--(*iiTab)->end(),(*iTab)->begin(),(*iTab)->end());
                    }
                }
            }
        }

        int temp;
        list<list<string>*>::iterator iTab;

        // Tri des nouvelles transitions pour l'etat concerne, et creation d'un nouvel etat a partir des nouvelles transition (s'il n'existait pas deja)
        for(cpt=0; cpt<_A.size(); cpt++){

            iTab=_tab[*iQdet][cpt].begin();
            while((!_tab[*iQdet][cpt].empty())&&(iTab!=_tab[*iQdet][cpt].end())){

                if((*iTab)->empty()){
                    _tab[*iQdet][cpt].erase(iTab);
                    iTab--;
                }
                else{
                    (*iTab)->sort();
                    (*iTab)->unique();
                }

                iTab++;
            }

            temp = 0;
            iTab = _tab[*iQdet][cpt].begin();

            // Creation d'un nouvel etat (s'il n'existait pas deja)
            for(iQ=Qdet.begin(); iQ!=Qdet.end(); iQ++){

                if((_tab[*iQdet][cpt].empty())||(((*iTab)->size() == (*iQ)->size())&&(equal((*iTab)->begin(),(*iTab)->end(),(*iQ)->begin()))))
                    temp = 1;
            }
            if (temp == 0){

                Qdet.push_back(new list<string>);
                _tab[*(--Qdet.end())] = new list<list<string>*>[_A.size()];
                (*(--Qdet.end()))->assign((*iTab)->begin(),(*iTab)->end());
            }
        }

        iQdet++;
    }

    // Suppression de l'ancienne table de transition
    deleteTableTranstion();

    // Remplace l'ancienne liste des etats par la nouvelle
    deleteQ();
    _Q = Qdet;

    // Creation de la nouvelle liste des etats teminaux (tout etat contenant un ancien etat terminal est terminal)
    for(list<list<string>*>::iterator iT=_T.begin(); iT!=_T.end(); iT++){
        for(iQ=_Q.begin(); iQ!=_Q.end(); iQ++){

            if(search((*iQ)->begin(),(*iQ)->end(),(*iT)->begin(),(*iT)->end()) != (*iQ)->end()){

                int temp = 0;
                list<list<string>*>::iterator iTdet;

                iTdet = Tdet.begin();
                while ((iTdet != Tdet.end())&&(temp == 0)){

                    if (((*iQ)->size() == (*iTdet)->size())&&(equal((*iQ)->begin(),(*iQ)->end(),(*iTdet)->begin())))
                        temp = 1;
                    iTdet++;
                }

                if (temp == 0){
                    Tdet.push_back(new list<string>);
                    (*(--Tdet.end()))->assign((*iQ)->begin(),(*iQ)->end());
                }
            }
        }
    }

    // Remplace l'ancienne liste des etats terminaux par la nouvelle
    deleteT();
    _T = Tdet;

}