예제 #1
0
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;
}
예제 #2
0
Automate *miroir( const Automate * automate){
	Automate* clone = creer_automate();
	ajouter_elements(clone->initiaux, automate->finaux);
	ajouter_elements(clone->finaux, automate->initiaux);

	pour_toute_transition(automate, reverse_transition, clone);
	return clone;
}
예제 #3
0
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; 
}
예제 #4
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;
}
예제 #5
0
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;
}
예제 #6
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;
}