Automate * translater_etat( const Automate* automate, int n ){
Automate * res = creer_automate();
Ensemble_iterateur it;
for(
it = premier_iterateur_ensemble( get_etats( automate ) );
! iterateur_ensemble_est_vide( it );
it = iterateur_suivant_ensemble( it )
){
ajouter_etat( res, get_element( it ) + n );
}
Table_iterateur it1;
Ensemble_iterateur it2;
for(
it1 = premier_iterateur_table( automate->transitions );
! iterateur_ensemble_est_vide( it1 );
it1 = iterateur_suivant_ensemble( it1 )
){
Cle * cle = (Cle*) get_cle( it1 );
Ensemble * fins = (Ensemble*) get_valeur( it1 );
for(
it2 = premier_iterateur_ensemble( fins );
! iterateur_ensemble_est_vide( it2 );
it2 = iterateur_suivant_ensemble( it2 )
){
int fin = get_valeur( it2 );
ajouter_transition(
res, cle->origine + n, cle->lettre, fin + n
);
}
};
return res;
}
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* copier_automate( const Automate* automate ){
Automate * res = creer_automate();
Ensemble_iterateur it1;
// On ajoute les états de l'automate
for(
it1 = premier_iterateur_ensemble( get_etats( automate ) );
! iterateur_ensemble_est_vide( it1 );
it1 = iterateur_suivant_ensemble( it1 )
){
ajouter_etat( res, get_element( it1 ) );
}
// On ajoute les états initiaux
for(
it1 = premier_iterateur_ensemble( get_initiaux( automate ) );
! iterateur_ensemble_est_vide( it1 );
it1 = iterateur_suivant_ensemble( it1 )
){
ajouter_etat_initial( res, get_element( it1 ) );
}
// On ajoute les états finaux
for(
it1 = premier_iterateur_ensemble( get_finaux( automate ) );
! iterateur_ensemble_est_vide( it1 );
it1 = iterateur_suivant_ensemble( it1 )
){
ajouter_etat_final( res, get_element( it1 ) );
}
// On ajoute les lettres
for(
it1 = premier_iterateur_ensemble( get_alphabet( automate ) );
! iterateur_ensemble_est_vide( it1 );
it1 = iterateur_suivant_ensemble( it1 )
){
ajouter_lettre( res, (char) get_element( it1 ) );
}
// On ajoute les transitions
Table_iterateur it2;
for(
it2 = premier_iterateur_table( automate->transitions );
! iterateur_ensemble_est_vide( it2 );
it2 = iterateur_suivant_ensemble( it2 )
){
Cle * cle = (Cle*) get_cle( it2 );
Ensemble * fins = (Ensemble*) get_valeur( it2 );
for(
it1 = premier_iterateur_ensemble( fins );
! iterateur_ensemble_est_vide( it1 );
it1 = iterateur_suivant_ensemble( it1 )
){
int fin = get_element( it1 );
ajouter_transition( res, cle->origine, cle->lettre, fin );
}
};
return res;
}
// 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 );
}
Matrice creer_matrice_transistions(Automate* a, char c){
Automate * abis = creer_automate_etats_0_n(a);
int n = taille_ensemble(get_etats(abis));
Matrice m = creer_matrice(n);
tree t=tree_creat();
tree_set(t, c);
m->mot = t;
int i, j;
for(i = 0; i < m->taille; i++){
for(j = 0; j< m->taille; j++){
m->tab[i][j] = INFINI;
}
}
Table_iterateur it1;
Ensemble_iterateur it2;
for ( it1 = premier_iterateur_table(get_transitions(abis));
! iterateur_ensemble_est_vide(it1);
it1 = iterateur_suivant_ensemble(it1)
){
Cle * cle = (Cle*) get_cle(it1);
Ensemble * fins = (Ensemble*) get_valeur(it1);
int tmp = get_lettre_cle(cle);
if(tmp == (int)c){
for( it2 = premier_iterateur_ensemble(fins);
! iterateur_ensemble_est_vide(it2);
it2 = iterateur_suivant_ensemble(it2)
){
int f = get_element(it2);
int cout = get_cout_cle(cle)==0 ? 0: 1;
m->tab[get_origine_cle(cle)][f] = cout;
}
}
}
liberer_automate(abis);
return m;
}
void pour_toute_transition(
const Automate* automate,
void (* action )( int origine, char lettre, int fin, void* data ),
void* data
){
Table_iterateur it1;
Ensemble_iterateur it2;
for(
it1 = premier_iterateur_table( automate->transitions );
! iterateur_ensemble_est_vide( it1 );
it1 = iterateur_suivant_ensemble( it1 )
){
Cle * cle = (Cle*) get_cle( it1 );
Ensemble * fins = (Ensemble*) get_valeur( it1 );
for(
it2 = premier_iterateur_ensemble( fins );
! iterateur_ensemble_est_vide( it2 );
it2 = iterateur_suivant_ensemble( it2 )
){
int fin = get_element( it2 );
action( cle->origine, cle->lettre, fin, data );
}
};
}
void creergraphe(Automate *a){
FILE* f=fopen("./auto.gv","w+");
fprintf(f, "digraph graphe {\n\trankdir=S;\n\tsize=\"8,5\"\n\tnode [shape = doublecircle];\n\t");
Ensemble_iterateur it;
for(it = premier_iterateur_ensemble(get_finaux(a));
! iterateur_ensemble_est_vide( it );
it = iterateur_suivant_ensemble( it )){
fprintf(f, "%d ", (int)get_element( it));
}
fprintf(f,";\n\t");
fprintf(f,"\n\tnode [shape = circle];\n\t");
Table_iterateur it2;
for( it2 = premier_iterateur_table(get_transitions( a ));
! iterateur_ensemble_est_vide( it2 );
it2 = iterateur_suivant_ensemble( it2 )
){
Cle * cle = (Cle*) get_cle( it2 );
Ensemble * fins = (Ensemble*) get_valeur( it2 );
for( it = premier_iterateur_ensemble( fins );
! iterateur_ensemble_est_vide( it );
it = iterateur_suivant_ensemble( it )
){
int fin = get_element( it );
fprintf(f,"%d",(int)get_origine_cle(cle));
fprintf(f," -> ");
fprintf(f,"%d",(int)fin);
fprintf(f," [ label =\"");
char lettre=get_lettre_cle(cle);
fprintf(f,"%c",lettre);
fprintf(f, ":");
fprintf(f,"%d",get_cout_cle(cle));
fprintf(f,"\"];\n\t");
}
}
fprintf(f,"node [shape = point];\n\t");
for(it = premier_iterateur_ensemble(get_initiaux(a));
! iterateur_ensemble_est_vide( it );
it = iterateur_suivant_ensemble( it )){
fprintf(f,"i%d ",(int)get_element(it));
}
fprintf(f,";\n\t");
for(it = premier_iterateur_ensemble(get_initiaux(a));
! iterateur_ensemble_est_vide( it );
it = iterateur_suivant_ensemble( it )){
fprintf(f,"i%d",(int)get_element(it));
fprintf(f," -> ");
fprintf(f,"%d",(int)get_element(it));
fprintf(f," [ label =\"start\" ];\n\t");
}
fprintf(f,"}\n");
fclose(f);
}
// À 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;
}