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 * creer_automate(){
Automate * automate = xmalloc( sizeof(Automate) );
automate->etats = creer_ensemble( NULL, NULL, NULL );
automate->alphabet = creer_ensemble( NULL, NULL, NULL );
automate->transitions = creer_table(
( int(*)(const intptr_t, const intptr_t) ) comparer_cle ,
( intptr_t (*)( const intptr_t ) ) copier_cle,
( void(*)(intptr_t) ) supprimer_cle
);
automate->initiaux = creer_ensemble( NULL, NULL, NULL );
automate->finaux = creer_ensemble( NULL, NULL, NULL );
automate->vide = creer_ensemble( NULL, NULL, NULL );
return automate;
}
Ensemble * delta1(
const Automate* automate, int origine, char lettre
){
Ensemble * res = creer_ensemble( NULL, NULL, NULL );
ajouter_elements( res, voisins( automate, origine, lettre ) );
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;
}
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;
}
int l_ensemble_est_egal( int n, const Ensemble* ens, ... ){
va_list pile;
int res;
int i;
Ensemble * e = creer_ensemble( NULL, NULL, NULL );
va_start(pile,ens);
for (i=0;i<n;i++){
ajouter_element( e, va_arg(pile,int) );
}
res = comparer_ensemble( ens, e );
liberer_ensemble( e );
va_end(pile);
return res == 0;
}
Ensemble * delta(
const Automate* automate, const Ensemble * etats_courants, char lettre
){
Ensemble * res = creer_ensemble( NULL, NULL, NULL );
Ensemble_iterateur it;
for(
it = premier_iterateur_ensemble( etats_courants );
! iterateur_ensemble_est_vide( it );
it = iterateur_suivant_ensemble( it )
){
const Ensemble * fins = voisins(
automate, get_element( it ), lettre
);
ajouter_elements( res, fins );
}
return res;
}
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 );
}
int test_execute_fonctions(){
BEGIN_TEST
int res = 1;
Automate * automate2;
Automate * automate;
Automate * result = NULL;
Ensemble * ens = NULL;
Ensemble * ens1 = NULL;
automate = creer_automate();
result = NULL;
ajouter_lettre( automate, 'a' );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
ajouter_etat_final( automate, 1 );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
ajouter_etat_initial( automate, 1 );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
get_initiaux( automate );
liberer_automate( automate );
automate = creer_automate();
get_finaux( automate );
liberer_automate( automate );
automate = creer_automate();
get_alphabet( automate );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
est_un_etat_initial_de_l_automate( automate, 1 );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
est_un_etat_final_de_l_automate( automate, 1 );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
est_une_lettre_de_l_automate( automate, 'a' );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
ens = NULL;
ens1 = creer_ensemble( NULL, NULL, NULL );
ens = delta_star( automate, ens1, "aba" );
if( ens ) liberer_ensemble( ens );
liberer_ensemble( ens1 );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
le_mot_est_reconnu( automate, "abaa" );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = mot_to_automate( "abbaa" );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
ens = NULL;
ens = etats_accessibles( automate, 0 );
if( ens ) liberer_ensemble( ens );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = automate_accessible( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = miroir( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = automate_co_accessible(automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = creer_automate_des_prefixes( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = creer_automate_des_suffixes( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
result = creer_automate_des_facteurs( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
automate = creer_automate();
result = NULL;
ens = creer_ensemble( NULL, NULL, NULL );
result = creer_automate_des_sur_mot(
automate, ens
);
if( result ) liberer_automate( result );
liberer_automate( automate );
liberer_ensemble( ens );
automate = creer_automate();
automate2 = creer_automate();
result = NULL;
result = creer_automate_de_concatenation( automate, automate2 );
if( result ) liberer_automate( result );
liberer_automate( automate );
liberer_automate( automate2 );
automate = creer_automate();
result = NULL;
result = creer_automate_des_sous_mots( automate );
if( result ) liberer_automate( result );
liberer_automate( automate );
return res;
}
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;
}