Ensemble * delta_star(
const Automate* automate, const Ensemble * etats_courants, const char* mot
){
Ensemble * fins = copier_ensemble(etats_courants);
int i;
for(i = 0; i < strlen(mot); i++)
{
// deplacer_ensemble(fins, delta(automate, fins, mot[i]));
fins = delta(automate, fins, mot[i]);
}
return fins;
}
Ensemble * delta_star(
const Automate* automate, const Ensemble * etats_courants, const char* mot
){
Ensemble * res = creer_ensemble(NULL, NULL, NULL);
Ensemble * fins = copier_ensemble(etats_courants);
int i;
for(i = 0; i < strlen(mot); i++)
{
fins = delta(automate, fins, mot[i]);
ajouter_elements(res, fins);
}
return res;
}
/**
* \par Implémentation
* La fonction ne considère que les derniers états atteints avant de tester si au moins un est final</br>
* \par
* On lit un mot depuis l'ensemble des états initiaux puis réitère à partir des voisins trouvés à l'étape précédente
* @param automate
* @param mot
* @return
*/
int le_mot_est_reconnu( const Automate* automate, const char* mot ){
Ensemble * fins = copier_ensemble(get_initiaux(automate));
int i;
for(i = 0; i < strlen(mot); i++)
{
fins = delta(automate, fins, mot[i]);
}
Ensemble_iterateur it1;
for(
it1 = premier_iterateur_ensemble(fins);
! iterateur_ensemble_est_vide( it1 );
it1 = iterateur_suivant_ensemble( it1 )
){
if (est_un_etat_final_de_l_automate(automate, get_element(it1)))
return 1;
}
return 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;
}
