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;
}
}
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;
}
// 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;
}
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 );
}
// À 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;
}
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;
}