예제 #1
0
const Ensemble * voisins( const Automate* automate, int origine, char lettre ){
	Cle cle;
	initialiser_cle( &cle, origine, lettre );
	Table_iterateur it = trouver_table( automate->transitions, (intptr_t) &cle );
	if( ! iterateur_est_vide( it ) ){
		return (Ensemble*) get_valeur( it );
	}else{
		return automate->vide;
	}
}
예제 #2
0
Automate *automate_accessible( const Automate * automate){
	Automate* clone = copier_automate(automate);
	Ensemble* etats = creer_ensemble(NULL, NULL, NULL);
	Ensemble_iterateur it_etat;
	Ensemble_iterateur it_lettre;

	// On calcule l'ensemble des états accessibles
	for(it_etat = premier_iterateur_ensemble(get_initiaux(automate));
		! iterateur_ensemble_est_vide( it_etat );
		it_etat = iterateur_suivant_ensemble( it_etat )){
		ajouter_elements(etats, etats_accessibles(automate, get_element(it_etat)));
		ajouter_element(etats, get_element(it_etat));
	}

	// On détermine les états qui ne sont pas accessibles => ceux qui sont dans get_etats mais pas dans etats
	Ensemble* non_accessible = creer_difference_ensemble(get_etats(automate), etats);

	// On parcourt l'ensemble obtenu	
	for(it_etat = premier_iterateur_ensemble(non_accessible);
		! iterateur_ensemble_est_vide( it_etat );
		it_etat = iterateur_suivant_ensemble( it_etat )){

		const intptr_t etat_courant = get_element(it_etat);

		// On cherche toutes les transitions partant d'un état
		for(it_lettre = premier_iterateur_ensemble(get_alphabet(automate));
			! iterateur_ensemble_est_vide( it_lettre );
			it_lettre = iterateur_suivant_ensemble( it_lettre )){
			
			Cle cle;
			initialiser_cle( &cle, etat_courant, get_element(it_lettre));				
			Table_iterateur it = trouver_table( clone->transitions, (intptr_t) &cle );				
			// Si on trouve une transition partant d'un état non accessible
			if( !iterateur_est_vide( it ) ){				
				delete_table( clone->transitions, (intptr_t) &cle); // on la supprime
			}			
		}
		// si c'est un état final, on pense à le supprimer
		if (est_un_etat_final_de_l_automate(automate, etat_courant))
		{
			retirer_element(clone->finaux, etat_courant);			
		}
		// si c'est un état initial, on pense à le supprimer
		if (est_un_etat_initial_de_l_automate(automate, etat_courant))
		{
			retirer_element(clone->initiaux, etat_courant);			
		}
	}
	// On supprime tous les états non accessibles de l'automate
	deplacer_ensemble(clone->etats, etats);
	
	return clone;
}
예제 #3
0
// abac est un sur-mot de aa
Automate * creer_automate_des_sur_mot(
	const Automate* automate, Ensemble * alphabet
){
	Automate* surmots = creer_automate();
	Ensemble_iterateur it_al;
	Table_iterateur it_trans;
	int etat_act = get_max_etat(automate) + 1;
	int etat_init = get_min_etat(automate) - 1;

	liberer_ensemble(surmots->alphabet);
	surmots->alphabet = (alphabet != NULL)? creer_union_ensemble(automate->alphabet, alphabet):copier_ensemble(automate->alphabet);
	
	// Pour chaques transition, on ajoute un état intermédiaire qui boucle sur lui même avec tout l'alphabet. En epsilon transition il passe à l'état suivant.
	for (it_trans = premier_iterateur_table(automate->transitions); !iterateur_est_vide(it_trans); it_trans = iterateur_suivant_table(it_trans)) {
		
		Cle * cle = (Cle*) get_cle(it_trans);
		Ensemble * fins = (Ensemble*) get_valeur(it_trans);
		
		ajouter_transition(surmots, cle->origine, cle->lettre, etat_act);
		
		for (it_al = premier_iterateur_ensemble(surmots->alphabet); !iterateur_ensemble_est_vide(it_al); it_al = iterateur_suivant_ensemble(it_al))
			ajouter_transition(surmots, etat_act, get_element(it_al), etat_act);
		
		for (it_al = premier_iterateur_ensemble(fins); !iterateur_ensemble_est_vide(it_al); it_al = iterateur_suivant_ensemble(it_al))
			ajouter_epsilon_transition(surmots, etat_act, get_element(it_al));
		
		etat_act++;
	}
	
	// On ajoute un état initial, et un état final qui bouclent sur eux-même avec l'alphabet.
	ajouter_etat_final(surmots, etat_act);
	ajouter_etat_initial(surmots, etat_init);
	
	for (it_al = premier_iterateur_ensemble(surmots->alphabet); !iterateur_ensemble_est_vide(it_al); it_al = iterateur_suivant_ensemble(it_al)) {
		
		ajouter_transition(surmots, etat_act, get_element(it_al), etat_act);
		ajouter_transition(surmots, etat_init, get_element(it_al), etat_init);
	}
	
	// Les anciens états initiaux/finaux viennent/vont sur les nouvaux.
	for (it_al = premier_iterateur_ensemble(automate->initiaux); !iterateur_ensemble_est_vide(it_al); it_al = iterateur_suivant_ensemble(it_al))
		ajouter_epsilon_transition(surmots, etat_init, get_element(it_al));
	for (it_al = premier_iterateur_ensemble(automate->finaux); !iterateur_ensemble_est_vide(it_al); it_al = iterateur_suivant_ensemble(it_al))
		ajouter_epsilon_transition(surmots, get_element(it_al), etat_act);;

	return surmots;
}
예제 #4
0
void ajouter_transition(
	Automate * automate, int origine, char lettre, int fin
){
	ajouter_etat( automate, origine );
	ajouter_etat( automate, fin );
	ajouter_lettre( automate, lettre );

	Cle cle;
	initialiser_cle( &cle, origine, lettre );
	Table_iterateur it = trouver_table( automate->transitions, (intptr_t) &cle );
	Ensemble * ens;
	if( iterateur_est_vide( it ) ){
		ens = creer_ensemble( NULL, NULL, NULL );
		add_table( automate->transitions, (intptr_t) &cle, (intptr_t) ens );
	}else{
		ens = (Ensemble*) get_valeur( it );
	}
	ajouter_element( ens, fin );
}
예제 #5
0
// À chaque itération de l'algo, on prend une lettre du premier ou du second automate, jusqu'à ce qu'on arrive à la dernière lettre.
// Produit cartésien des états.
// Exemple : mot 1 : aaaa, mot 2 : bbbb
// Quelques résulats possibles : aabbaabb; aaaabbbb: bbbbaaaa; aaababbb: baababba
Automate * creer_automate_du_melange(
	const Automate* automate1,  const Automate* automate2
){
	int i, j, k, nbelau1, nbelau2, etat_act, et1, et2;
	int ** nouveaux_etats = NULL;
	Automate * melange = creer_automate();
	Ensemble_iterateur it1, it2;
	Table_iterateur it_transition;
	Table *cle1 = creer_table(
		( int(*)(const intptr_t, const intptr_t) ) comparer_int , 
		( intptr_t (*)( const intptr_t ) ) copier_int,
		( void(*)(intptr_t) ) supprimer_int
	);
	Table *cle2 = creer_table(
		( int(*)(const intptr_t, const intptr_t) ) comparer_int , 
		( intptr_t (*)( const intptr_t ) ) copier_int,
		( void(*)(intptr_t) ) supprimer_int
	);
	const Ensemble * finaux1 = get_finaux(automate1); const Ensemble * finaux2 = get_finaux(automate2);
	const Ensemble * initiaux1 = get_initiaux(automate1); const Ensemble * initiaux2 = get_initiaux(automate2);
	
	nbelau1 = taille_ensemble(automate1->etats);
	nbelau2 = taille_ensemble(automate2->etats);
	nouveaux_etats = malloc(nbelau1 * sizeof(int *));
	for(i=0; i<nbelau1; i++)
		nouveaux_etats[i]=malloc(nbelau2 * sizeof(int));
	k = 0;
	
	// Création des états, états initiaux, états finaux de l'automate.
	for (it1 = premier_iterateur_ensemble(automate1->etats), i=0; ! iterateur_ensemble_est_vide(it1); it1 = iterateur_suivant_ensemble(it1), i++){
		
		et1 = get_element(it1);
		add_table(cle1, et1, i);
		for (it2 = premier_iterateur_ensemble(automate2->etats), j=0; ! iterateur_ensemble_est_vide(it2); it2 = iterateur_suivant_ensemble(it2), j++){
			
			et2 = get_element(it2);
			ajouter_etat(melange, k);
			add_table(cle2, et2, j);
			if (est_dans_l_ensemble(finaux1, et1) && est_dans_l_ensemble(finaux2, et2))
				ajouter_etat_final(melange, k);
			if (est_dans_l_ensemble(initiaux1, et1) && est_dans_l_ensemble(initiaux2, et2))
				ajouter_etat_initial(melange, k);
			
			
			nouveaux_etats[i][j] = k;
			k++;
		}
	}
	
	// Les transitions sont ensuite crées
	// D'abord celles de l'ancien automate 1
	for (it_transition = premier_iterateur_table(automate1->transitions); !iterateur_est_vide(it_transition); it_transition = iterateur_suivant_table(it_transition)) {
		
		Cle * cle = (Cle*) get_cle(it_transition);
		Ensemble * fins = (Ensemble*) get_valeur(it_transition);

		for (it1 = premier_iterateur_ensemble(fins), i=0; ! iterateur_ensemble_est_vide(it1); it1 = iterateur_suivant_ensemble(it1), i++){
			
			etat_act = get_element(it1);
			for(i = 0; i < nbelau2; i++) {

				ajouter_transition(melange,
					nouveaux_etats[(int)get_valeur(trouver_table(cle1, cle->origine))][i],
					cle->lettre,
					nouveaux_etats[(int)get_valeur(trouver_table(cle1, etat_act))][i]);
			}
		}
	}
	
	// Puis celles de l'ancien automate 2
	for (it_transition = premier_iterateur_table(automate2->transitions); !iterateur_est_vide(it_transition); it_transition = iterateur_suivant_table(it_transition)) {
		
		Cle * cle = (Cle*) get_cle(it_transition);
		Ensemble * fins = (Ensemble*) get_valeur(it_transition);

		for (it1 = premier_iterateur_ensemble(fins), i=0; ! iterateur_ensemble_est_vide(it1); it1 = iterateur_suivant_ensemble(it1), i++){
			
			etat_act = get_element(it1);
			for(i = 0; i < nbelau1; i++) {

				ajouter_transition(melange,
					nouveaux_etats[i][(int)get_valeur(trouver_table(cle2, cle->origine))],
					cle->lettre,
					nouveaux_etats[i][(int)get_valeur(trouver_table(cle2, etat_act))]);
			}
		}
	}
	
	liberer_table(cle1);
	liberer_table(cle2);
	return melange;
}
예제 #6
0
Automate * creer_automate_de_concatenation(
	const Automate* automate1, const Automate* automate2
	){
	/**
	 * \par Implémentation
	 * 
	 * On créé un automate, copie de automate1 avec comme états finaux ceux de automate2
	 */
	 Automate* concat = copier_automate(automate1);
	 deplacer_ensemble(concat->finaux, automate2->finaux);


	/**
	 * Puis on créé un modificateur qui nous permet de passer en paramètres de fonction
	 * l'automate de destination et une valeur de décalage des états.
	 * Cette valeur permet de ne pas avoir deux états avec la même valeur.
	 */
	 int decalage = get_max_etat(automate1);
	 AutomateInt* modificateur = creer_automate_int();
	 modificateur->automate = concat;
	 modificateur->valeur = decalage;

	/**
	 * On ajoute les transitions de l'automate 2 avec les états décalés.
	 */
	 pour_toute_transition(automate2, incrementer_etats_transition, modificateur);
	 liberer_automate_int(modificateur);

	/**
	 * Pour chaque état initial du second automate
	 */
	 Ensemble_iterateur initial2;
	 for(
	 	initial2 = premier_iterateur_ensemble(get_initiaux(automate2));
	 	! iterateur_ensemble_est_vide( initial2 );
	 	initial2 = iterateur_suivant_ensemble( initial2 )){
		/**
		 * Pour chaque lettre de son alphabet
		 */
		 Ensemble_iterateur lettre;
		 for(
		 	lettre = premier_iterateur_ensemble(get_alphabet(automate2));
		 	! iterateur_ensemble_est_vide(lettre);
		 	lettre = iterateur_suivant_ensemble(lettre)){

		 	Cle cle;
		 	printf("initial2 : %d\n", (int) get_element(initial2));
		 	printf("lettre : %c\n", (char) get_element(lettre));
		 	initialiser_cle(&cle, (int) get_element(initial2), (char) get_element(lettre));
		 	Table_iterateur destination = trouver_table(automate2->transitions, (intptr_t) &cle);
		 	printf("avant clé\n");
		 	print_cle(&cle);
		 	printf("après clé\n");
		 	if (!iterateur_est_vide(destination)){
		 		AutomateTransition* modif_trans = creer_automate_transition();
		 		modif_trans->automate = concat;
		 		modif_trans->lettre = get_element(lettre);

		 		Ensemble* destinations = (Ensemble*) get_valeur(destination);
		 		Ensemble_iterateur etat_dest;
				/**
				 * Pour chaque transition de la forme (i2, a2, q2), avec i2 intial, a2 lettre de l'alphabet
				 * et q2 état de l'automate2
				 */
				for(
				 	etat_dest = premier_iterateur_ensemble(destinations);
				 	! iterateur_ensemble_est_vide(etat_dest);
				 	etat_dest = iterateur_suivant_ensemble(etat_dest)){
				 	modif_trans->destination = get_element(etat_dest)+decalage;
					/**
					 * On ajoute une transition dans l'automate de concaténation ayant pour origine
					 * un état initial, la lettre a2 et l'état q2
					 */
					 pour_tout_element(get_finaux(automate1), simuler_epsilon_transition, modif_trans);
				}
				initialiser_cle(&cle, (int) get_element(initial2) + decalage, get_element(lettre));
		 		delete_table(concat->transitions, (intptr_t) &cle);
		 		liberer_automate_transition(modif_trans);
			}
		}
	 }

	return concat;
}