Animation d algorithmes sur les automates d états finis

Transcription

1 Animation d algorithmes sur les automates d états finis FACCHINI Jocelyn, RIZZON Léo Responsable de projet : Olga KOUCHNARENKO Université de Franche-Comté Licence 3 Informatique 10 mars 2009

2 Table des matières 1 Analyse Analyse des objectifs Le but du projet Les objectifs initiaux Les objectifs minimums Analyse des besoins Analyse de l existant GraphViz Grappa Librairies graphiques Java : Swing et AWT Développement Outils Java Eclipse GraphViz Grappa L A TEX Structures de données Les structures de base Le lien entre les structures basiques et l affichage L IHM Algorithme de déterminisation Affichage graphique La fenêtre principale L affichage des graphes Stockage Le stockage persistant La classe Exemple Problèmes rencontrés Les problèmes rencontrés La résolution du problème d affichage Fonctionnement de l application et expérience Utiliser l application Expérience Ce qu il reste à faire

3 Remerciements Nous tenons tout d abord à remercier notre responsable de projet Mme Olga Kouchnarenko, pour nous avoir suivi et soutenu durant la réalisation du projet. Elle a su nous prodiguer beaucoup de conseils particulièrements utiles et intéressants. Elle nous a fait profiter de son expérience pour l organisation et le déroulement du projet mais aussi pour l élaboration de ce rapport. Nous la remercions enfin pour les documents qu elle nous a sympathiquement prêtés. Nous espérons avoir été à la hauteur de la confiance qu elle nous a accordée. Nous souhaitons également remercier Mme Violeta Felea pour le temps et l attention qu elle nous a consacrés pour résoudre certains de nos problèmes en Java. Ses compétences dans ce langage mais aussi les qualités pédagogiques dont elle a fait preuve nous ont été d un grand secours. 2

4 Introduction Durant notre dernière année de Licence Informatique, nous avons été amené à réaliser un projet d assez grande ampleur. Il nous a été proposé par Mme Olga Kouchnarenko, et a pour but de proposer une présentation graphique d animation d algorithmes sur des automates d états finis. Il s incrit dans un cadre pédagogique : il s agit d apporter un nouveau moyen de compréhension du cours de Théorie des Langages qui s axe en partie sur l application de ces algorithmes. Nous commencerons par vous présenter notre analyse du sujet et notre étude de l existant afin de bien cerner et définir le travail que nous devions réaliser. Par la suite, nous décrivons comment nous avons procédé pour développer notre application, quels problèmes nous avons rencontrés, les choix que nous avons effectués. Enfin nous concluons par un petit mode d emploi de l application. Nous expliquons également les tests que nous avons effectués sur celle-ci. Pour finir nous proposons une ouverture sur les possibles améliorations de notre projet. 3

5 Chapitre 1 Analyse 1.1 Analyse des objectifs Le but du projet Il existe plusieurs utilisations possible de ce projet. Le principal objectif étant de simplifier et illustrer le déroulement d algorithmes effectués sur des automates d états finis. En effet, certains algorithmes sont un peu complexes à assimiler. Il existe des étapes qui peuvent être nombreuses, et on se représente mal la création pas à pas de l automate résultant. C est pourquoi, expliquer ces algorithmes uniquement avec des déroulements mathématiques et algorithmiques est parfois délicat. Cette problématique est encore plus présente lors de l enseignement à distance car il n y a aucun professeur présent en personne pour apporter des explications supplémentaires. Notre projet consiste donc à créer une application permettant de voir à l écran les étapes d un déroulement d un algorithme. Il est ainsi plus aisé de se représenter l algorithme dans son fonctionnement Les objectifs initiaux Les objectifs initialements prévus étaient assez ambitieux. Tout d abord, l application se devait d être portable et légère. Sa distribution, à travers la plateforme d enseignement à distance, imposait en effet de permettre un téléchargement rapide. De plus, les systèmes des étudiants n étant pas forcément uniformisés, il fallait qu elle puisse fonctionner chez tout le monde. Ensuite, il était souhaitable que l application fournisse plusieurs fonctions : Chargement à la demande d automates existants Création d automates Invocation des algorithmes sur les automates créés Historique des commandes invoquées sur les automates Possibilité de parcourir en avant, en arrière Les objectifs minimums Les objectifs initiaux étant proposés dans l idéal, nous avons redéfinis avec Olga Kouchnarenko des objectifs minimums. En effet il nous était difficile d évaluer la charge de travail étant donné notre faible expérience mais également la nouveauté de ce type de projet, c est à dire l absence d exemples sur lesquels s appuyer pour faire une estimation (on ne savait pas de quoi allait être composé notre projet). Nous nous sommes donc mis d accord sur le fait que la partie graphique de l application, c est à dire l interface Homme-Machine, était très importante. Il était primordiale d avoir un affichage. Il était également obligatoire de pouvoir appliquer l algorithme de déterminisation sur des automates prédéfinis. L étape suivante était la possibilité d entrer soit même des automates et d implémenter la minimisation. 4

6 1.2 Analyse des besoins Afin de mieux nous organiser, nous avons tenter de définir nos besoins. Nous avons de cette manière distingué plusieurs parties : Nous avions besoin de structures solides pour représenter notre automate. Il fallait qu elles soient réutilisables, et assez générales pour qu on puisse y appliquer toutes sortes de traitements. Nous avions besoin d une interface graphique assez évoluée. Nous devions faire le lien entre la partie code et la partie graphique. La partie concernant les structures demandait beaucoup de réflexion (il s agissait de ne pas se tromper, c est la base). Les connaissances techniques requises n étaient pas particulièrement importantes pour cette partie. Nous n avions que très peu fait d interface graphique mais finalement ce fut une partie techniquement assez accessible. Néanmoins, la découverte et l apprentissage demandait un peu de temps. Faire le lien entre le code et l affichage était la partie la plus obscure et totalement inconnue. Cela nous a inquieté, c est pourquoi nous avons concentré nos recherches dessus au début. 1.3 Analyse de l existant GraphViz GraphViz est un programme de visualisation de graphe (Graph Visualization), développé par l équipe de recherche de la société AT&T. Pour pouvoir utiliser ce logiciel, il est nécessaire de s initier au langage DOT spécialement conçut pour ce logiciel afin de décrire un graphe. Une fois le code DOT rédigé, on utilise le programme dot de GraphViz pour générer, dans différents formats, le graphe correspondant. Si on ne précise pas de format de sortie, dot nous retourne un code DOT amélioré définissant la mise en forme des éléments du graphe Grappa Grappa est un package Java qui permet de dessiner des graphes dans des applications Java. De plus, ce package est capable de lire et d écrire du code DOT. Ce programme nous a permis d afficher un automate sans passer par GraphViz. En effet, la première idée que nous avons eu était d afficher des images d automates générées par GraphViz. Heureusement, Grappa permet de créer un panel, que nous avons utilisé avec Swing, contenant l automate que nous créons. Avec ce package nous pouvons faire une mise en forme de l automate en utilisant le programme dot de GraphViz grâce à un appel de processus Librairies graphiques Java : Swing et AWT La partie graphique de notre projet est assez importante. Comme notre formation en Java s est arrêtée avant l utilisation des bibliothèques graphiques, il nous a été nécessaire de nous demander quelle(s) librairie(s) choisir, sans vraiment les connaître! Après des recherches sur internet, il nous est apparu que le choix entre les différentes librairies était assez important mais également assez technique. A priori les bibliothèques natives Swing et AWT sont les plus simples et c est celles-la que nous avons sélectionnées. Elles sont complémentaires et plusieurs tutoriaux bien fait les concernent. L IHM que nous avons réalisée n est pas de la plus grande complexité et nous n utiliserons pas les arcanes secrètes de ces librairies. Il est à noter qu il existe certaines incompatibilités entre Swing et AWT si l on mélange des composants appartenant aux deux bibliothèques. Nous n avons a priori rencontré aucun problèmes de ce type. AWT est plus ancien et moins performant. Swing est plus récent et permet d avoir de meilleures performances et un accès à de multiples fonctionnalités intéressantes. Pour plus d informations sur les différences entre ces librairies : http ://java.developpez.com/faq/gui/?page=generalitesawtswing#graphique AWT vs SWING 5

7 Chapitre 2 Développement 2.1 Outils Java Le choix d utiliser le Java pour ce projet s est imposé à nous très rapidement. Notre responsable de projet ayant eu la même idée, nous nous sommes lancé sans hésiter : notre formation comportait une bonne part de Java, nous étions donc assez à l aise. Le paramètre de portablilité étant important mais aussi l aspect interface graphique faisait de ce langage le candidat idéal. On peut noter l utilisation d une classe particulière, fournie durant notre deuxième année de licence par nos enseignants : la classe Keyboard. Il s agit d une classe simplifiant énormement les saisies au clavier en nous épargnant l utilisation parfois fastidieuse des Scanner ou autre Eclipse Nous avons utilisé Eclipse comme environnement de développement. Il est bien connu pour son incroyable puissance! Et il l a démontré une fois de plus. Entre les corrections en deux clics pour des erreurs qui auraient pu nous torturer des heures, l excellente auto-complétion, l importation des classes dont on a besoin en deux temps trois mouvements, la génération automatisée des accesseurs et plein d autres choses encore, nous pouvons avancer sans exagérer qu Eclipse nous a fait économiser plusieurs heures et a épargné notre patience et notre motivation! De plus, il nous a permis d intégrer en trois minutes le package Grappa, chose que nous ne savons absolument pas faire autrement. Merci Eclipse! GraphViz Notre responsable de projet nous a tout de suite guidé vers GraphViz pour pouvoir afficher un automate. Nous avons donc fait nos recherches sur ce programme. GraphViz est en fait un ensemble d outils permettant de manipuler des graphes à travers un langage, créé spécialement pour ces outils, appelé DOT. Ces outils sont sous la licence libre Common Public License 1. La création de notre premier d automate fut assez simple. Voici un premier exemple qui provient du site internet de GraphViz. digraph G{ Hello->World } Nous créons de cette manière un graphe orienté contenant deux noeuds avec une transition depuis Hello vers World. Dans un automate, les transitions ont une étiquette afin de les différencier, pour cela nous ajoutons à la transition le code [label=etiquette]. De plus, on peut définir une liste de noeuds 1 C est une licence Open Source d IBM qui autorise la modification du code source et garantit le respect des brevets logiciels. 6

8 cibles à la transition en mettant les noeuds entre accolades séparés par des points virgules, par exemple Etat1 -> {Etat2; Etat3}. D un point de vue esthétique les états d un automate sont représentés par des cercles et les états finaux par deux cercles imbriqués. En DOT nous devons ajouter deux instructions : node [shape = doublecircle]; LesEtatsFinaux; permet de définir les états finaux suivis de la liste des noms des états finaux et node [shape = circle]; definit, par défaut, les noeuds par des cercles. Voici la structure de base que nous utilisons pour créer un automate d état fini. digraphe G : permet de créer un graphe orienté nommé G. rankdir = LR; : permet de changer le sens du graphe (Left-Right). node [shape = point]; o; : Nous permet de définir une flèche avec un point afin que celle-ci indique les états initiaux. node [shape = doublecircle]; 1 4; : Nous permet de représenter les états finaux par des noeuds en forme de cercles imbriqués. node [shape = circle]; : Définit par défaut la forme des noeuds 1 -> {3;} [label=b] : Voici une transition depuis l état 1 vers l état 3 par la lettre de transition b o -> {0;} : Ici on a un cas particulier de transitions. En dot, un arc se fait toujours entre deux noeuds c est pourquoi nous avons créé un noeud factice représenté par un point. Nous créons donc l ensemble des états initiaux avec cette instruction. À partir de ce code DOT placé dans un fichier exemple.dot, nous générons, en ligne de commande, l automate sous différents formats graphiques tel que PNG, JPEG, GIF etc... Lorsqu aucun format de sortie n est précisé, GraphViz nous retourne une code DOT avec un positionnement des éléments du graphe. Par exemple, GraphViz nous retourne, pour notre Hello World, le code suivant : digraph G{ node [label="\n"]; graph [bb="0,0,70,108"]; Hello [pos="35,90", width="0.83", height="0.50"]; World [pos="35,18", width="0.97", height="0.50"]; Hello -> World [pos="e,35,36 35,72 35, 64 35,55 35,46"]; } Grappa Dans cette partie, nous allons décrire comment nous sommes arrivé à utiliser Grappa. Malheureusement, nous n avons pas trouvé de tutoriel, ni de pages d explication sur ce package Java sauf sur le site officiel. Bien que celui-ci nous propose le téléchargement d une démo, nous n avons pas pu la lancer. Le seul moyen que nous avions pour comprendre comment utiliser ce package était de lire la javadoc de Grappa. À la première lecture des classes de ce packages, nous avons trouvé la classe GrappaPanel qui est la classe à utiliser pour dessiner un graphe. Cette classe hérite de JPanel, ce qui tombe bien pour nous car nous utilisons Swing pour notre interface graphique. Le constructeur de cette classe prend en paramètre un objet de type Subgraph, nous sommes donc allés voir les caractéristiques de celui-ci. La documentation nous dit que cette classe décrit un sous-graphe, lequel peut être constitué de noeuds, de bords et d autres sous-graphes. Le constructeur d un Subgraph prend en paramètre un objet Subgraph, ce qui peut sembler bizarre mais la documentation précise une petite note nous informant que le sous-graphe racine doit être un graphe entier de type Graph. Cet objet hérite donc de Subgraph, il fournit les methodes permettant de travailler sur un graphe. À partir de là, nous avons pu faire un premier panneau constitué d un noeud avec le code suivant : Graph g = new Graph("Nom du Graphe"); Node n = new Node(g,"Nom du noeud"); 7

9 GrappaPanel gpan = new GrappaPanel(g); Ensuite, nous n avons plus qu à ajouter ce panneau dans un objet de type JFrame. Dans la présentation de Grappa sur le site internet officiel, nous avons pu lire qu il existe des méthodes, dans ce package, pour lire et écrire des graphes avec le langage DOT. Nous avons donc repéré la classe Parser dans la liste des classes de Grappa. Le constructeur de ce parser prend en paramètre un objet de type InputStream. En cherchant dans l api Java, nous avons remarqué qu il existe une classe FileInputStream qui hérite de InputStream. Ainsi nous pouvons lire dans un fichier un code DOT d un graphe ayant déjà été positionné. Nous utilisons donc le code suivant, pour un fichier nommé Hello- World.dot contenant le code retourné par GraphViz. FileInputStream fis = new FileInputStream(new File("HelloWorld.dot")); Parser p = new Parser(fis); Graph g = p.getgraph(); GrappaPanel gpan = new GrappaPanel(g); Mais cette technique a un inconvénient pour le développement de notre application. En effet, nous avons vu qu il faut que le code DOT doit avoir des instructions de positionnement. Un code en langage DOT rédigé à la main ne contient pas forcément de positionnement et nous ne savons pas à l avance combien de noeuds comportera le graphe à étudier. Il est assez difficile de développer un algorithme de mise en forme de graphe, de plus il est inutile pour nous de le créer car GraphViz contient cet algorithme. Nous verrons plus loin comment résoudre le problème de positionnement des éléments dans un graphe (voir 2.6.2) L A TEX Pour rédiger notre rapport, nous avons découvert le logiciel L A TEX souvent utilisé pour les rédactions scientifiques. Afin de ne pas perdre de temps à la rédaction du rapport, nous avons appris à l utiliser en rédigeant quelques rapports intermédiaires dans le but de garder des informations sur ce que nous avons fait. La prise en main ne fut pas difficile pour la saisie de texte. Nous avons commencé à avoir des difficultés lors de l ajout d images. En effet, nous avons découvert comment L A TEX positionne tout cela de manière à ne pas perdre de place sur les pages. Il existe tout de même des moyens pour remédier à ça, pour cela nous avons recherché sur différentes sources expliquant le fonctionnement de L A TEX (voir webographie et bibliographie). Nous sommes très satisfaits d avoir découvert ce logiciel et épaté par tout ce qu il propose. 2.2 Structures de données Les structures de base Automate décrit un automate contenant une liste d Etat et implémente les méthodes de traitement de celui-ci Etat décrit un état d un automate et est composé d un ensemble de transitions Transition décrit les transitions par une étiquette pour un état vers une liste de cible Pour constituer les structures de données de base (c est à dire des structures qui servent de fondation à notre application), nous nous sommes inspiré de nos Travaux Pratiques en Théorie des Langages où nous avons traité des automates avec le langage C. À partir de la structure d automate précédente, nous avons défini une structure orientée objet puisque nous utilisons le langage Java pour notre application. Un automate est un ensemble d états reliés entre eux par des transitions qui permettent de passer d un état vers un autre état. Ces transitions se caractérisent par une étiquette. Pour notre application, qui a pour but d aider des étudiants en Théorie des Langages, nous utilisons une lettre de transition comme étiquette. Cette dernière peut se faire vers plusieurs états avec une même étiquette lorsque l automate n est pas déterministe. 8

10 Fig. 2.1 Structures basiques Pour travailler sur un automate nous avons défini 3 classes (voir 2.1). Automate Cet objet est défini par les attributs suivant : name : Nom, de type String, de l automate. listetat : Ensemble des états, de type TreeSet<Etat>, composant l automate. Etat Cet objet est défini par les attributs suivants : codeetat : Codification, de type entier, de l état. name : Nom, de type String, de l état. isinitial : Booléen permettant de savoir si l état est initial. isfinal : Booléen permettant de savoir si l état est final. listtrans : Ensemble des transitions, de type TreeSet<Transition>, partant de l état. Transition Cet objet est défini par les attributs suivants : etiquette : Etiquette, de type String, de la transition. listcible : Ensemble des états cibles, de type TreeSet<Integer>. Tous les ensembles sont des collections de type TreeSet. Nous avons choisi cette collection car elle nous permet des ajouts d éléments très rapides ainsi que la possibilité de ne pas créer de doublons. 9

11 2.2.2 Le lien entre les structures basiques et l affichage EtapeAlgorithme qui fait le lien entre la déterminisation d un Automate et la création du DeroulementGraphe correspondant GenerationGraphe qui redéfinit un Graph plus adapté à notre utilisation DeroulementGraphe qui rassemble une liste de GenerationGraphe composant un déroulement d algorithme EtapeAlgorithme Le but de notre projet étant d animer des algorithmes sur les automates d états finis, il nous fallait donc trouver un moyen de faire le lien entre les algorithmes et l affichage graphique. Pour cela nous avons eu l idée de créer un objet qui permet de décrire une étape dans un algorithme. Nous avons donc créé la classe EtapeAlgorithme qui contient les attributs suivants : description : Chaîne de caractères qui décrit l étape. codedot : Chaîne de caractères contenant le code DOT pour afficher l automate à cette étape. Ainsi, nous construisons une liste d objet EtapeAlgorithme pour décrire une suite d étapes. Cette liste est retournée par les algorithmes sur les automates d états finis. Par la suite, l affichage graphique récupère cette liste pour créer les affichages nécessaires à l animation. GenerationGraphe GenerationGraphe est une classe importante dans notre projet. Elle représente graphiquement un Automate. C est cette classe qui nous permet de passer d un objet Automate, à un objet affichable dans une fenêtre. C est également dans cette classe qu on va utiliser Grappa. En effet un des attributs de GenerationGraphe est graphe de type Graph. Grâce à la méthode GenerationGraphe automatetogenerationgraphe(automate a), on récupère un graphe correspondant au code DOT de Automate. Mais comme expliqué en 2.6.1, il faut positionner notre graphe. C est la méthode filtragegraphe() qui va modifier notre graphe. Ainsi, le booléen position nous indique si le Graph, il est à true si il a été filtré. Pour effectuer un filtrage, il est nécessaire d utiliser un programme spécifique, dans notre cas, dot. C est pourquoi nous avons nomprogramme qui indique le chemin du programme à utiliser et nomfichier qui indique le chemin du fichier source contenant le code DOT. Le chemin du programme pose un problème non résolu car on a une dépendance vis à vis du systeme d exploitation. Voir Enfin, description est un String qui contient la description correspondante au GenerationGraphe, surtout utile à l affichage des étapes d un déroulement d algorithme. DeroulementGraphe Cette classe est très simple et s utilise dans la continuité directe de GenerationGraphe. L animation réelle d un algorithme n étant pas réalisable simplement et dans le temps dont nous disposions, nous avons opté pour un affichage image par image. DeroulementGraphe possède peu d attributs : nomliste qui va permettre de décrire la liste contenue dans l objet. Elle permet, par exemple de décrire le type d algorithme qui est représenté. L attribut le plus important, liste, est une liste chainée de GenerationGraphe qui correspondent chacun à une étape du déroulement de l algorithme. A noter un constructeur très particulier dans cette classe. DeroulementGraphe(String nom, LinkedList EtapeAlgorithme ListEtape) qui prend en paramètre directement la liste des étapes. Nous avons fait comme ça pour simplifier la création automatique des DeroulementGraphe à partir des EtapeAlgorithme. Cela va servir au moment de l ouverture d un déroulement précedement enregistré. La difficulté a été que nous n utilisions le programme dot que sur un fichier de code DOT. Il nous fallait donc passer par un fichier temporaire. Par chance c est très facile en Java. On écrit un à un le code DOT de chaque étape dans un fichier temporaire qui va nous permettre de générer le GenerationGraphe correspondant. Il est intéressant de noter qu on modifie le nom du fichier source en Temporaire pour éviter les erreurs possibles si on tente des traitements qui utiliseraient le fichier source. Celui n existant naturellement plus (temporaire...). 10

12 2.2.3 L IHM FenetrePrincipale qui rassemble toute la partie affichage graphique du projet ExitEcouteur est l écouteur qui permet de gerer la fermeture de l application. ExempleEcouteur est l écouteur qui permet regénérer les exemples prédéfinis dans Exemple. FenetrePrincipale Cette classe regroupe tous les élements permettant de faire l affichage graphique. Il s agit d une classe héritée de JFrame qui comporte une barre de menu et trois zones distinctes qui ont un rôle spécifique lors de l affichage. FenetrePrincipale possède un très grand nombre d attributs. Cet état de fait est clairement dû à notre manque d expérience en programmation évenementielle. Il est surement possible de faire un nettoyage dans ces attributs. Egalement, il doit être possible d optimiser et simplifier la gestion des écouteurs. Il faut mettre ca sur le compte du manque de temps et voir ca comme notre premier essai d interface. Bon nombre des attributs de cette classe vont servir à la mise en forme ou au remplissage de la fenêtre, on trouve ainsi des JPanel, une TextArea, un JLabel, des Font, des JButton et des JMenuItem. Mais on a également quelques attributs utilisés pour l animation ou l ouverture des fichiers. Par exemple, chemindefault est une variable qui indique le chemin d ouverture par défaut lors de l enregistrement et l ouverture d automates ou de déroulements. On va mettre automate à null si on charge un déroulement et inversement. Ca permet de solidifier le code. droite est un booleen qui indique, lors du parcours d un DeroulementGraphe, le sens du parcours. C est à dire de savoir si on avance dans la liste ou on recule. En fait c est utile lors d un changement de direction. En effet la structure des Iterator oblige de faire deux fois le déplacement lorsque l on change de sens. Ce problème est expliqué en 2.6.1, au paragraphe concernant les iterators. ExitEcouteur Dans cette classe, on utilise l interface ActionListener. Elle permet de redéfinir un écouteur d évenement spécifique en indiquant l action à effectuer. On a écrit cet écouteur pour la gestion de la fermeture de l application. On affiche ainsi une petite fenêtre de confirmation. ExempleEcouteur Cette classe qui utilise également l interface ActionListener fonctionne comme ExitEcouteur. C est un écouteur qui va permettre de générer les exemple prédéfinis dans la classe Exemple (voir Algorithme de déterminisation Notre projet a pour but d animer des algorithmes sur les automates d états finis. L un des plus important est celui de la déterminisation d un automate. En effet, un automate qui contient des transitions avec la même étiquette depuis un état vers plusieurs états est dit non déterministe puisque il est impossible de demander à une machine de choisir une transition. Il faut donc utiliser cet algorithme sur cet automate. En plus de déterminiser un automate, notre algorithme de déterminisation va nous retourner une liste d étapes de l algorithme, des objets de type EtapeAlgorithme. Cette liste va nous permettre de faire l animation dans l interface graphique. Tout d abord, nous allons expliquer l utilité de trois variables, deux tableaux dynamiques et une liste chaînée. listeetats est un tableau dynamique qui va contenir les nouveaux états créés issus de la déterminisation, nous n utilisons pas l ensemble des états de l automate car nous en avons besoin. Nous avons choisi un tableau dynamique afin de le parcourir avec un entier en faisant des accès par indice car il n était pas possible de parcourir un ensemble qui se rempli au fur et à mesure avec un Iterator. 11

13 listensbletats est un tableau dynamique qui contient des chaînes de caractères représentant les ensembles d états correspondant. Nous avons choisi ce type de collection car nous utilisons les indices pour représenter les codes des nouveaux états. listetape est une liste chaînée qui va contenir des objets EtapeAlgorithme. Les principales étapes de l algorithme de déterminisation sont les ajouts des états et leurs transitions. Pour commencer la déterminisation, nous recherchons l ensemble des états initiaux. Nous parcourons donc simplement l ensemble des états de l automates en repérant les états initiaux. Pour enregistrer la correpondance entre le nouvel état et l ensemble des états qui le composent, nous utilisons le tableau listensbletats. Les indices de celui-ci représentent les codes des nouveaux états constitués qui sont créés dans un tableau dynamique d états. Ce dernier va remplacer l ensemble d états listetat de l ancien automate. Par exemple, pour un nouvel état 0 représenté par l ensemble des anciens états {1 ;2 ;3}, on a à l indice 0 la valeur {1 ;2 ;3} et le nouvel objet Etat a pour code 0. Ensuite, nous allons parcourir le tableau dynamique des nouveaux états jusqu à ce qu il n y ait plus d états créés. Pour chaque nouvel état, nous cherchons, pour une etiquette de transition donnée, l ensemble des cibles de tous les états, constituant le nouvel état étudié. Ensuite nous ajoutons l ensemble dans le tableau dynamique listensbletats si cet ensemble n existe pas encore. En même temps, nous ajoutons une étape dans la liste chaînée listetape en précisant si l état est créé ou non et les nouvelles transitions trouvées. 2.4 Affichage graphique La fenêtre principale La partie graphique de l application est regroupée en une seule fenêtre. Il s agit d une instance de FenetrePrincipale qui permet d accèder à toutes les fonctionnalités de l application. Toutes les actions se font à partir de la barre de menu : Ouverture d un déroulement d algorithme (la sauvegarde n est pas gérée) Saisie, ouverture et sauvegarde d un automate Modifier le répertoire d ouverture par défaut, quitter l application (proprement, avec une fenêtre de confirmation). Il y a également les boutons Suivant et Précedent qui permettent de naviguer entre les différentes étapes d un déroulement d algorithme. La gestion des erreurs est effectuée avec de belles fenêtres également. Ainsi en cas de tentative de lecture, si aucun déroulement n a été seléctionné, on a une erreur. Les écouteurs sont tous integrés dans cette classe mise à part celui qui permet de quitter l application qui est ExitEcouteur et celui de génération des exemples ExempleEcouteur. On trouve ensuite deux zones différentes : une zone de texte et une zone où l on affichera les graphes. Ces zones seront décrites dans la sous-section suivante. Quant à la possibilité de modifier le répertoire par défaut, il s agit simplement de pouvoir selectionner un chemin qui sera ouvert par défaut lors des ouvertures et enregistrements L affichage des graphes L affichage promprement dit se fait dans les deux zones principales : La zone de droite permet d afficher l image du graphe, elle se dimensionne en fonction de la taille de l image (donc du graphe). La zone de gauche va permettre un affichage texte correspondant à l image, on affiche par exemple une description de l étape lors du déroulement d un algorithme (le scroll vers le bas se fait automatiquement pour suivre le déroulement des expliquations). Comment ca marche? Le principe est le même pour un automate simple ou un déroulement d algorithme. On va afficher le Graph (classe de Grappa) contenu dans le GenerationGraphe. Notons ici un fonctionnement un peu particulier : l évenement part de FenetrePrincipale, qui fait alors un appel à une méthode de GenerationGraphe qui elle même fait de nouveau appel à FenetrePrincipale. Ca 12

14 pourrait être amélioré, ca sert ici maladroitement à factoriser les tests de validité etc... La différence entre la gestion d un automate et d un déroulement est simple. Pour un automate, on affiche juste le GenerationGraphe correspondant. Pour un déroulement, on va associer un DeroulementGraphe à la fenêtre. C est lui qu on va parcourir avec les boutons Suivant et Précedent. A chaque pas, on va enlever l image précedente, afficher la nouvelle et écrire dans la zone de texte la description de cette image. 2.5 Stockage Le stockage persistant Nous avons créé un systeme de stockage persistant. En effet il est possible de sauvegarder ou d ouvrir un automate que l on aurait créé. Il est très facile de le faire depuis le menu Automate. Il est également possible de faire la même chose avec un déroulement d algorithme, depuis le menu Déroulement. Nous avons utilisé l interface Serializable : la sérialisation consiste à écrire des données présentes en mémoire vers un flux de données binaires, ce procédé va donc nous permettre de rendre nos objets persistants. Donc, c est un système qui permet de stocker des objets dans un fichier pour les recharger plus tard. Si un objet est Serializable (i.e. il implémente l interface du même nom), il pourra être enregistré sur le disque et chargé à l identique lors du démarrage suivant. Le gros avantage étant que ces sauvegardes sont indépendantes du système d exploitation. Mais nous avons eu un sérieux problème au départ. En effet comme expliqué plus précisement en les classes que nous aurions aimé enregistrer, GenerationGraphe et DeroulementGraphe, étaient composées d un ou plusieurs Graph, classe de Grappa. Celle-ci n étant pas Serializable... Par contre nous ne sommes pas parvenu à choisir l emplacement du dossier destination pour la sauvegarde (voir 2.6.1). Nous avons déja enregistré quelques exemples qui sont lisibles depuis l application. Ces exemples sont gérés depuis la classe Exemple. Nous avons choisi une écriture pour les extensions des fichiers destinés à notre application : Pour les automates simples, nous écrirons *.aga, pour AnimalGoAutomate Pour les déroulement d algorithme, nous écrirons *.agd pour AnimalGoDeroulement La classe Exemple La classe Exemple permet de définir les automates et déroulements d algorithme qu on veut générer comme exemples. Ces exemples seront enregistrer sur le disque de façon persistante. Dans un premier temps il faut créer l exemple en dur dans une nouvelle méthode de cette classe. Ensuite, il suffit d integrer cette méthode à la méthode statique d appel generationexemple(). Pour connaître les exemples déja créés, voir Problèmes rencontrés Les problèmes rencontrés Problèmes résolus L affichage avec Grappa, GraphViz Nous avons rencontré un problème lors de l utilisation de Grappa pour afficher un automate. Nous proposons de décrire plus précisement celui-ci et les étapes qui nous ont permis de résoudre ce souci dans la partie dédiée, en Le stockage d exemples Comme expliqué en 2.5.1, nous avons implémenté la possibilité d enregistrer de manière persistante et d ouvrir des exemples d automates ou de déroulements d algorithme préenregistrés. La difficulté est survenue lorsque nous nous sommes rendu compte que Graph, classe de Grappa, n était pas Serializable. Les classes intéressantes à sauvegarder, c est à dire GenerationGraphe et 13

15 DeroulementGraphe, sont composées d un ou plusieurs Graph. Il ne nous était pas possible de modifier le package Grappa (trop complexe a priori, même si la licence ne posait pas de problème). Nous avons trouvé un compromis : Pour les automates, nous enregistrons des Automate, classe Serializable. La transformation en GenerationGraphe se fait directement à l ouverture et est invisible pour l utilisateur. L automate étant stocké dynamiquement dans FenetrePrincipale, on peut l enregistrer sans problème tant que l utilisateur n a pas chargé autre chose. Pour les déroulements d algorithmes, c est un peu moins bien conçu : en effet, on enregistre en fait une liste chaînée d EtapeAlgorithme. C est optimisable car le code DOT est non positionné dans cette liste. Du coup, pour génerer un DeroulementGraphe, on applique le filtrage (positionnement des élements) sur chaque élement, et ce, à chaque fois qu on va ouvrir un déroulement. Iterator dans l animation d algorithme Voici un problème qui, malgré que nous l ayons résolu, nous laisse une interrogation. Il s agit d utiliser un ListIterator sur une la liste chainée des étapes d un DeroulementGraphe pour effectuer le parcours en utilisant les boutons Suivant et Précedent. Cet iterator permet un parcours dans les deux directions. Pourtant, de part le fonctionnement d un iterator cela pose un problème. En effet, le traitement (dans notre cas l affichage) d une case amène l iterator un pas après celle-ci. Si on souhaite changer de sens, on réaffiche donc la même case. Il faut donc détecter le sens courant pour effectuer deux déplacements de suite si on change de sens. C est assez facile à régler avec un booleen indiquant la direction courante mais c est étonnant dans le sens où les iterator de Java sont des outils de parcours assez puissants. Disons que ca nous a étonné de devoir utiliser une technique un peu bricolage comme ça, on aurait pu supposer que ce cas de figure assez basique soit prévu par Java. Utilisation de la fenêtre principale dans les écouteurs. Il s agit en fait d un des soucis qui nous a obligé à compliquer la classe FenetrePrincipale. En effet, il se trouve que pour la plupart des actions à effectuer, nous avons besoins de le la fenêtre hôte elle même. Par exemple, pour ouvrir un automate sauvegardé, on ouvre une fenêtre de selection de fichier : new JFileChooser(cheminDefault).showOpenDialog(this); Le this se rapporte à la FenetrePrincipale d où part l évènement. Il aurait été judicieux d avoir une méthode qui retourne la fenêtre d où provient l évènement pour pouvoir créer ainsi un écouteur dédié et alléger ainsi grandement le code de la classe fenêtre hôte. Cela n a été possible qu avec l écouteur ExitEcouteur, qui permet de quitter l application, et avec l écouteur ExempleEcouteur, pour lesquels il n y a pas besoin de la fenêtre. Peut être est ce possible, ou peut être que notre manière de coder n est pas idéale. En tout cas nous avons fait comme nous avons pu, c est à dire en redéfinissant nos écouteurs directement dans FenetrePrincipale. On pourrait imaginer une autre solution qui consiste à passer en paramètre au constructeur de l écouteur la fenêtre d où provient l évènement pour la mettre comme attribut de la classe de l écouteur : c est la seule solution que nous voyons. Problèmes non résolus Broken pipe sous linux Lors de nos tests sur l affichage des automates avec Grappa nous avons rencontré des exceptions de type Broken Pipe. Cette erreur, lors de nos tests, n apparait que sous le système d exploitation Linux car nous n en avons pas rencontré sous Windows. Malheureusement pour nous, cette exception vient de Grappa lorsqu il fait appel à GraphViz pour pouvoir faire la mise en forme du graphe. Nous conseillons, lorsque l on rencontre cette erreur, de recharger le déroulement ou la déterminisation de l automate puisque nous avons constaté que cette erreur surgit de manière aléatoire. Nous prévoyons par la suite de rapporter ce problème à John Mocenigo, le créateur de Grappa, afin de déterminer d où provient réellement l erreur et si possible de la résoudre. Détection de l OS Un des problèmes recontré par l utilisation de GraphViz est la limite de portabilité engendré par celuici. En effet, GraphViz étant écrit en C, il a été créer différemment pour différents systèmes d exploitation. Dans le but de diffuser notre application à des étudiants à distance, il y a de forte probabilité que ceux-ci 14

16 n aient pas tous le même sytème. Notre application ne cherche pas à savoir où se trouve le programme dot de GraphViz bien que nous ayons pensé à créer une petite fenêtre pour que l utilisateur indique où se trouve le dossier dans lequel se trouve les excécutables de GraphViz. Pour palier indirectement à ce problème, nous recommandons d ajouter le chemin du dossier des exécutables de GraphViz dans la variable d environnement système path. Particulièrement sous Windows, les logiciels installés ne figurent pas tous dans cette variable. Choix de l emplacement de la sauvegarde Comme expliqué en 2.5.1, nous avons introduit dans notre projet des possibilités de stockage persistant. Nous utilisons un chemin par défaut modifiable. Ce chemin est utilisé par les fenêtres de sélection de fichiers pour s ouvrir à l endroit voulu. Lors de la sauvegarde, la fenêtre s ouvre bien sur le dossier par défaut, on peut naviguer etc, mais lorsque l on enregistre, le fichier est toujours placé au même endroit. Cela doit probablement venir de l enregistrement par la classe Stockage. Nous n avons malheureusement pas le temps de nous en occuper La résolution du problème d affichage Nous décrirons dans cette partie un problème que nous avons rencontré lors de l utilisation de Grappa pour afficher des automates. Tout d abord, il nous a fallu faire des recherches sur ce qui pouvait exister comme solution d affichage de graphe. Nous avons découvert GraphViz mais également Grappa. Grappa est un package Java, il était donc très interessant. Grappa est Open Source, sous license CPL 1. Nous pouvions donc tout à fait l utiliser pour notre projet. Mais qu est ce qu un package Java? En gros, un package est un regroupement de plusieurs classes crées pour fonctionner ensembles. Cela permet une organisation accrue des composants des programmes. Par contre, nous ignorions comment utiliser un package. Et Eclipse nous a rendu un fier service et a réglé ce problème en très peu de temps. Il suffit de faire un clic droit sur notre projet propriétés Chemin de compilation Java Bibliothèques Ajouter des fichiers.jar externes (Grappa est sous forme d un fichier.jar) on cherche Grappa sur notre PC et on sélectionne le.jar c est fait en deux temps trois mouvements!. Pour afficher, c est assez simple (du moins on le pensait...). Grappa gère des Graph, mais en en associant un avec un code DOT directement généré par notre programme (voir le code en 2.1.4, nous avons découvert un petit soucis : Fig. 2.2 Exemple d automate sans positionnement (Empilement des éléments) En effet, Grappa ne gère pas la disposition des élements de l automate dans le GrappaPanel. Nous avons fait des recherches et nous avons découvert une autre version des fichiers DOT : les code DOT positionné. Il existe plusieurs programmes, dont fait partie dot, qui permettent l agencement des états, transitions etc. Mais dot est un programme qui fait partie de GraphViz. Et tout ce n est pas écrit en Java! Il nous a fallu trouver un moyen de faire appel à ces programmes depuis notre application. Pour faire ceci, nous avons exploré l utilisation des appels processus. En Java, on utilise des Process Voila le code utiliser, il permet l application de monprogramme sur monfichier. On utilisera monprogramme = dot et monfichier = l emplacement du fichier dot à positionner. Process pb = new ProcessBuilder(nomProgramme, nomfichier).start(); GrappaSupport.filterGraph(graph On effectue ce qu on appelle un filtrage sur le graphe : on applique sur ce Graph qui correspond au code DOT positionné par dot. 15

17 On arrive ainsi à ceci : Fig. 2.3 Exemple d affichage correct d un automate 16

18 Chapitre 3 Fonctionnement de l application et expérience 3.1 Utiliser l application L utilisation de l application est assez simple. Ce qu il faut savoir : on traite séparement les automates simples et les déroulements d algorithmes : Un automate possède une unique représentation, on ne peut pas le parcourir. On peut le sauvegarder et en ouvrir ou en saisir un autre. Un déroulement d algorithme est une suite d automates. On peut donc l explorer, dans les deux sens. On peut le sauvegarder et en ouvrir un autre. La barre de menu Toutes les actions se déclenchent à partir de la barre de menu : Fichier : Regénérer les exemples : permet de regénérer les exemples prévus par défaut Modifier le chemin par défaut : permet de modifier le chemin par défaut d ouverture des fenêtres de selection des fichiers Quitter : Permet de quitter l application Automate : Saisie manuelle d un automate : permet de saisir un automate personnel à travers la console Ouvrir un automate : ouvre une fenêtre de selection de fichier pour ouvrir un automate Enregistrer un automate : ouvre une fenêtre de selection de fichier pour enregistrer un automate Déterminiser un automate : effectue la déterminisation sur l automate courant et affiche le déroulement correspondant Déroulement : Ouvrir un déroulement d algorithme : ouvre une fenêtre de selection de fichier pour ouvrir un déroulement d algorithme Enregistrer un déroulement d algorithme : ouvre une fenêtre de selection de fichier pour enregistrer un déroulement d algorithme La saisie dans la console La seule partie délicate est la saisie dans la console. La première chose à savoir lorsque l on commence une saisie manuelle d automate est que toute la partie graphique de l application devient innaccessible. De plus, soit on finit correctement la saisie, soit on ferme (violemment!) l application. C est un point à améliorer. Eclaircissons un peu ca. La chose la plus spéciale dans cette saisie étant de devoir donner le nombre d étiquettes différentes il va y avoir pour les transitions à partir d un état. A part ca, reprenons en gros le déroulement de celle-ci : On donne un nom à notre automate 17

19 On indique le nombre total d états. On crée tous ces états (nom, final, initial) On reprend chaque état un par un et on indique leurs tansitions on indique le nombre total d étiquettes différentes pour l état (pour un état qui aurait 2 transitions par a, 1 par b et 3 par c et 0 par d, on indiquerait donc 3) pour chaque étiquette on va indiquer la ou les cibles : attention ici, on attribue un numéro à chaque état pour l indentifier en tant que cible. Voila, avec ça, ça ne devrait pas poser de problemes Avec ça, on notera que, malgré un semblant de choix de dossier de destination, les sauvegardes se font toujours au même endroit. Nous ne savons pas vraiment pourquoi, ou, du moins, pas comment régler ce problème (voir Les exemples Pour la génération des exemples, il suffit de sélectionner l action Regénérer les exemples dans le menu Fichier de la barre de menu. L exemple Automate1 correspond à l automate du TP de TL de la L3. C est un automate non déterministe assez simple. L exempel Automate2 est un exemple d automate de grande taille. C est à dire de taille qu on suppose plus ou moins maximum dans la pratique et l utilisation de notre application. 3.2 Expérience Nous n avons malheureusement pas eu le temps d établir un protocole de test très évolué. Nous n avons testé notre application que sur nos machines personnelles : Ubuntu 8.10 et Windows XP. Toutes les fonctions proposées par le programme ont été testées sur les exemples par défaut. 3.3 Ce qu il reste à faire... Ce projet étant très vaste et intéressant il y avait vraiment beaucoup à faire. Malheureusement nous n avons pas eu assez de temps pour mettre en place tout ce que nous aurions voulu sur ce projet. Si quelqu un reprend celui-ci un jour pour l améliorer, le continuer, nous écrivons cette partie afin de diriger ses premiers travaux. Optimisation de l ouverture des déroulements d algorithmes Comme expliqué en 2.6.1, l ouverture d un déroulement d algorithme est peu optimisé. En effet on va enregistrer une liste de code DOT qui n ont pas encore été positionné par le programme dot. Donc, à chaque ouverture du déroulement, on applique le filtrage (c est à dire l action de positionner le code DOT) sur chaque élément. L idéal serait de trouver un moyen de sauvegarder le code une fois modifié, soit en faisant en sorte qu il le soit dans EtapeAlgorithme avant la sauvegarde, soit en modifiant carrément le principe et sauver autre chose. Choix de la destination d une sauvegarde Nous avons vu que lors de la sauvegarde d un automate ou d un déroulement, le fichier ne s enregistre en réalité pas à l endroit choisi mais toujours à la même place. C est un problème que nous n avons pas vraiment étudié, nous ne savons donc pas grand chose à son propos. A priori le problème viendrait plutôt de la classe Stockage. C est un peu dommage de ne pouvoir enregistrer où l on veut, surtout après avoir bien cherché la destination dans un beau JFileChooser. Gestion des erreurs et des exceptions Il est possible d améliorer et solidifier le code de notre application. Il n est pas du tout sûr que toutes les exceptions soient bien captées ou encore, nous aurions pu lever nos propres exceptions à certain endroit. On pourrait également augmenter le nombre de tests de validité, par exemple à l ouverture d un automate dans la fênetre principale. 18

20 De plus, certaines exceptions qui sont levées pourraient être d avantage expliquées. Exemple : lors de l ouverture d un automate, si l on selectionne un fichier invalide, c est à dire qui ne correspond pas à un automate enregistré, un message sera écrit dans la fenêtre et une exception sera levée, visible dans la console : Erreur au chargement d un automate : java.lang.classcastexception : java.util.linkedlist cannot be cast to Automate. Mais ce message est peu explicite pour un néophyte, il décrit le moment où il y a eu le problème et indique le type de problème. On pourrait tenter d améliorer ceci, par exemple en faisant un test de type sur l exception, en déduire que l utilisateur à choisit un mauvais fichier et lui dire dans un beau message! C est un petit détail qui pourrait être sympathique. Notons que pour les tests de validité des fichiers, on pourrait même tester en plus le format du fichier, c est à dire en fait, regarder si il y a bien écrit *.aga ou *.agd. Systeme de saisie et de modification d automate Nous pensons qu il serait plus convivial de créer une saisie graphique d un automate et en même temps la modification de celui-ci. En effet, la saisie en console d un automate est assez fastidieuse et il est assez fréquent de se perdre dans la saisie. Une idée pour cette interface de saisie serais d afficher au fur et à mesure l automate en construction, de plus il serait bien de rajouter des méthodes pour permettre le retrait d éléments contenu dans les ensembles constituant un automate. Par ailleurs, la saisie graphique permettrait un contrôle interactif des manipulations de l utilisateur. Par manque de temps pour ce projet, nous n avons pu faire cette interface de saisie. D un autre côté, notre saisie console d un automate ne permet pas d ajouter dynamiquement des éléments. Par exemple, si nous oublions un état il est obligatoire de devoir resaisir l automate en entier. De nouveaux algorithmes... Il est judicieux bien sûr de réutiliser notre application afin d y ajouter de nouveaux algorithmes exécutables sur des automates d états finis. On pense par exemple à la minimisation... 19