Ensemble* etats_accessibles( const Automate * automate, int etat ){ Ensemble * res = creer_ensemble(NULL, NULL, NULL); Ensemble * etape = creer_ensemble(NULL, NULL, NULL); ajouter_element(etape, etat); Ensemble_iterateur it_lettre; Ensemble_iterateur it_etat; // Tant que des états sont à traiter while (taille_ensemble(etape) > 0) { Ensemble * trouves = creer_ensemble(NULL, NULL, NULL); for( it_lettre = premier_iterateur_ensemble( get_alphabet( automate ) ); ! iterateur_ensemble_est_vide( it_lettre ); it_lettre = iterateur_suivant_ensemble( it_lettre ) ){ for( it_etat = premier_iterateur_ensemble(etape); ! iterateur_ensemble_est_vide( it_etat ); it_etat = iterateur_suivant_ensemble( it_etat ) ){ // on ajoute les voisins aux éléments trouvés ajouter_elements(trouves, voisins(automate, get_element(it_etat), get_element(it_lettre) )); } } etape = creer_difference_ensemble(trouves, res); ajouter_elements(res, etape); } return res; }
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; }
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 ); }
L_ligne* symetries_translation() { L_ligne* retour = NULL; Token t; Valeur v; Arbre* x; Arbre* y; Arbre* z; x = NULL; t = VAR; v.variable = X; x = ajouter_element(x, creer_element(t,v)); t = OP; v.operateur = PLUS; x = ajouter_element(x, creer_element(t,v)); t = REEL; v.reel = 1.; x = ajouter_element(x, creer_element(t,v)); y = NULL; t = VAR; v.variable = Y; y = ajouter_element(y, creer_element(t,v)); z = NULL; t = VAR; v.variable = Z; z = ajouter_element(z, creer_element(t,v)); add_to_l_ligne(&retour, x, y, z); x = NULL; t = VAR; v.variable = X; x = ajouter_element(x, creer_element(t,v)); y = NULL; t = VAR; v.variable = Y; y = ajouter_element(y, creer_element(t,v)); t = OP; v.operateur = PLUS; y = ajouter_element(y, creer_element(t,v)); t = REEL; v.reel = 1.; y = ajouter_element(y, creer_element(t,v)); z = NULL; t = VAR; v.variable = Z; z = ajouter_element(z, creer_element(t,v)); add_to_l_ligne(&retour, x, y, z); x = NULL; t = VAR; v.variable = X; x = ajouter_element(x, creer_element(t,v)); y = NULL; t = VAR; v.variable = Y; y = ajouter_element(y, creer_element(t,v)); z = NULL; t = VAR; v.variable = Z; z = ajouter_element(z, creer_element(t,v)); t = OP; v.operateur = PLUS; z = ajouter_element(z, creer_element(t,v)); t = REEL; v.reel = 1.; z = ajouter_element(z, creer_element(t,v)); add_to_l_ligne(&retour, x, y, z); return retour; }
int test_delta_delta_star(){ BEGIN_TEST; int result = 1; Automate* automate = creer_automate(); ajouter_etat( automate, 3 ); ajouter_etat( automate, 5 ); ajouter_transition( automate, 3, 'a', 5 ); ajouter_transition( automate, 5, 'b', 3 ); ajouter_transition( automate, 5, 'a', 5 ); ajouter_transition( automate, 5, 'c', 6 ); ajouter_etat_initial( automate, 3 ); ajouter_etat_final( automate, 6 ); TEST( 1 && est_un_etat_de_l_automate( automate, 3 ) && est_un_etat_de_l_automate( automate, 5 ) && est_un_etat_de_l_automate( automate, 6 ) && est_un_etat_initial_de_l_automate( automate, 3 ) && ! est_un_etat_initial_de_l_automate( automate, 5 ) && ! est_un_etat_initial_de_l_automate( automate, 6 ) && ! est_un_etat_final_de_l_automate( automate, 3 ) && ! est_un_etat_final_de_l_automate( automate, 5 ) && est_un_etat_final_de_l_automate( automate, 6 ) && est_une_lettre_de_l_automate( automate, 'a' ) && est_une_lettre_de_l_automate( automate, 'b' ) && est_une_lettre_de_l_automate( automate, 'c' ) && ! est_une_lettre_de_l_automate( automate, 'd' ) && est_une_transition_de_l_automate( automate, 3, 'a', 5 ) && est_une_transition_de_l_automate( automate, 5, 'b', 3 ) && est_une_transition_de_l_automate( automate, 5, 'a', 5 ) && est_une_transition_de_l_automate( automate, 5, 'c', 6 ) && ! est_une_transition_de_l_automate( automate, 3, 'b', 5 ) && ! est_une_transition_de_l_automate( automate, 1, 'b', 5 ) && ! est_une_transition_de_l_automate( automate, 3, 'a', 1 ) , result ); Ensemble * etat_courant = creer_ensemble( NULL, NULL, NULL ); ajouter_element( etat_courant, 3 ); deplacer_ensemble( etat_courant, delta( automate, etat_courant, 'a' ) ); TEST( 1 && est_dans_l_ensemble( etat_courant, 5 ) && taille_ensemble( etat_courant ) ==1 , result ); deplacer_ensemble( etat_courant, delta_star( automate, etat_courant, "ab" ) ); TEST( 1 && est_dans_l_ensemble( etat_courant, 3 ) && taille_ensemble( etat_courant ) ==1 , result ); deplacer_ensemble( etat_courant, delta_star( automate, etat_courant, "ac" ) ); TEST( 1 && est_dans_l_ensemble( etat_courant, 6 ) && taille_ensemble( etat_courant ) ==1 , result ); deplacer_ensemble( etat_courant, delta_star( automate, etat_courant, "" ) ); TEST( 1 && est_dans_l_ensemble( etat_courant, 6 ) && taille_ensemble( etat_courant ) ==1 , result ); deplacer_ensemble( etat_courant, delta_star( automate, etat_courant, "c" ) ); TEST( 1 && taille_ensemble( etat_courant ) == 0 , result ); liberer_ensemble( etat_courant ); liberer_automate( automate ); return result; }
void ajouter_etat_initial( Automate * automate, int etat_initial ){ ajouter_element(automate->initiaux, etat_initial); ajouter_etat(automate, etat_initial); }
void ajouter_etat_final( Automate * automate, int etat_final ){ ajouter_element(automate->finaux, etat_final); ajouter_etat(automate, etat_final); }
void ajouter_lettre( Automate * automate, char lettre ){ ajouter_element(automate->alphabet, lettre); }
void ajouter_etat( Automate * automate, int etat ){ ajouter_element( automate->etats, etat ); }