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;
}
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;
}
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;
}
