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