Ejemplo n.º 1
0
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;
}
Ejemplo n.º 2
0
/**
 * \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;
}
Ejemplo n.º 3
0
int test_automate_vide(){
	BEGIN_TEST;

	int result = 1;

	Automate * automate = creer_automate();

	TEST( 
		1
		&& ! est_un_etat_de_l_automate( automate, 0)
		&& ! est_un_etat_final_de_l_automate( automate, 0)
		&& ! est_un_etat_initial_de_l_automate( automate, 0)
		&& ! est_une_lettre_de_l_automate( automate, 'a')
		&& ! est_une_transition_de_l_automate( automate, 0, 'a', 0 )
		, result
	);

	liberer_automate( automate );

	return result;

}
Ejemplo n.º 4
0
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;
}
Ejemplo n.º 5
0
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;
}
Ejemplo n.º 6
0
int test_creer_automate(){
	BEGIN_TEST;

	int result = 1;

	Automate * automate = creer_automate();

	ajouter_lettre( automate, 'a' );
	ajouter_lettre( automate, 'd' );

	ajouter_etat( automate, 3 );
	ajouter_etat_final( automate, 6 );

	ajouter_transition( automate, 3, 'a', 5 );
	ajouter_transition( automate, 3, 'b', 3 );

	ajouter_etat_final( automate, 5 );
	ajouter_etat_initial( automate, 3 );

	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)
		, result
	);
	TEST( 
		1
		&& ! 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)
		, result
	);
	TEST( 
		1
		&& est_un_etat_initial_de_l_automate( automate, 3)
		&& ! est_un_etat_initial_de_l_automate( automate, 5)
		, result
	);
	TEST( 
		1
		&& est_une_lettre_de_l_automate( automate, 'a')
		&& est_une_lettre_de_l_automate( automate, 'b')
		&& est_une_lettre_de_l_automate( automate, 'd')
		&& ! est_une_lettre_de_l_automate( automate, 'c')
		, result
	);
	TEST( 
		1
		&& est_une_transition_de_l_automate( automate, 3, 'a', 5 )
		&& est_une_transition_de_l_automate( automate, 3, 'b', 3 )
		&& ! est_une_transition_de_l_automate( automate, 3, 'b', 5 )
		&& ! est_une_transition_de_l_automate( automate, 3, 'a', 3 )
		&& ! est_une_transition_de_l_automate( automate, 5, 'a', 3 )
		&& ! 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, 'b', 5 )
		, result
	);

	const Ensemble* ens = get_initiaux( automate );

	TEST( 
		1
		&& ens
		&& est_dans_l_ensemble( ens, 3 )
		&& ! est_dans_l_ensemble( ens, 5 )
		&& ! est_dans_l_ensemble( ens, 6 )
		, result
	);

	ens = get_finaux( automate );

	TEST( 
		1
		&& ens
		&& ! est_dans_l_ensemble( ens, 3 )
		&& est_dans_l_ensemble( ens, 5 )
		&& est_dans_l_ensemble( ens, 6 )
		, result
	);

	ens = get_alphabet( automate );

	TEST( 
		1
		&& ens
		&& est_dans_l_ensemble( ens, 'a')
		&& est_dans_l_ensemble( ens, 'b')
		&& ! est_dans_l_ensemble( ens, 'c')
		&& est_dans_l_ensemble( ens, 'd')
		, result
	);


	liberer_automate( automate );

	return result;
}