Repository files navigation

Une calculatrice simple avec interface graphique développée enJavaFX etFXML + CSS.Comme spécifié ci-dessous, elle ne gère pas les nombres à virgule, ni les parenthèses niautres fonctions mathématiques complexes à part l'addition, la soustration, la multiplicationet la division.

Vous pouvez utiliser les boutons présents sur l'interface utilisateurou utiliser le pavé numérique de votre clavier pour interagir avec le logiciel.

• Le projet de l'application avec interface graphique se trouve dans le dossierSuko.
• Le projet de l'application avec interface console se trouve dans le dossierSukoConsole.

• Appuyez sur[ENTER] de votre clavier ou= de la calculatrice pour avoir le résultat;
• Appuyez sur[C] de votre clavier ou le boutonC de la calculatricepour reinitialiser la calculatrice;
• Appuyez sur[DELETE] de votre clavier ou le boutonCE de la calculatrice pour effacerle champs de saisi inférieur.
• Appuyez sur[BACK SPACE] de votre clavier ou le boutonDEL de la calculatrice poureffacer chiffre par chiffre le nombre saisi sur la champs de saisi inférieur.
• Vous avez la possibilité de changer l'opérateur précédement saisi en appuyant sur une destouche des opérateurs ( + - * /), ceci même si vous aviez déjà saisi un nombre dans champsde saisi inférieur.

Développez une calculatrice dotée d’une interface qui reçoit les informations entrées par l’utilisateur. Ces informations permettront de calculer le résultat des opérations.

• Etape 0 : La calculatrice attend la saisie du premier terme.
• Etape 1 : D’abord le premier terme est entré par la fourniture successive du (ou des) chiffre(s) le composant.
• Etape 2 : Ensuite, un symbole est fourni par l’entrée d’un des signes des opérations acceptés par la calculatrice (+ - DIV *).
• Etape 3 : Et enfin le deuxième terme qui sera composé de 1 ou plusieurs chiffres aussi sera entré.
• Etape 4 : Apres cette étape, l’utilisateur devra taper le signe = et le résultat définitif de l’opération lui sera affiché et la calculatrice reviendra à l’étape 1.A l’entrée de « C », l’opération est remise à zéro, et on revient à l’étape 0.

NOTE : l’application pourra ne gérer que les nombres entiers dans un premier temps. Ensuite, elle ne devra gérer que les cas normaux de fonctionnement. Ainsi, les cas exceptionnels d’erreur (cas anormaux) ne seront pas pris en compte (Exemple : appui sur = après saisie de la première opérande)

Dans une expression, nous avons des opérations et des termes. Les différentes opérations possiblesque nous pouvons avoir sont des additions, multiplications, soustrations et divisions. Les termesne sont uniquement que des nombres entiers. Donc, il n'y aura aucune implémentation pour gérerdes nombres réels. Vooici un exemple d'expression :

$$97 \times 985 + 109 - 229$$

L'expression à calculer sera représentée sous forme arborescente, dans un premier temps. C'est cearbre de calcul qui sera évalué pour obtenir le résultat final. Dans l'exemplesuivant, les noeuds en forme de carré représentent les termes et les noeuds en forme circulairereprésentent les opérations ($+, -, \times \div$).

Figure 01 : Exemple d'un arbre de calcul.

• Les noeuds en forme de carré représentent les noeuds terminaux.
• Les noeuds en forme circulaire représentent les noeuds non-terminaux.

Pour parvenir à obtenir ce modèle d'arbre, nous allons utiliser le design patterninterpreter.Voici donc le diagramme des classes modélisant cet arbre :

Figure 02 : Diagramme des classes du modèle interpreter.

• Les noeuds terminaux seront représentés par les instances de la classeTerminalNode;
• Les noeuds non-terminaux sont représentés par les instances de la classeNonTerminalNode;
• Le contexteContext encapsule la liste des variables de l'équation mappées leurs valeursrespectives;

Le modèle interpreter permet de définir une équation en fonction des variables qu'on peutrenseigner avec leurs valeurs respectives. Ces variables sont représentées par des noeudsterminaux.

Par contre, ce modèle ne permet pas d'implémenter l'analyseur qui permettra de construirel'arbre de calcul. Ce qui fera l'objet de la sous-section suivante.

Dans cette étape de conception, nous allons mettre en place l'analyseur qui va nous permettrede construire l'arbre du modèle interpreter à partir de l'équation reçue sous forme chaine decaractères.

L'équation reçue étant sous forme de chaine de caractères, on aura besoin de faire une chainede traitement à effectuer sur ce dernier celle-ci afin d'obtenir l'arbre de calcul résultant.C'est cette chaine de traitement qui constitue l'analyseur. Voici la chaine de traitementproposée :

Figure 03 : Pipeline de l'analyse et construction de l'arbre de calcul.

Il y a juste deux étapes de traitement.

Pour élaborer cette chaine de traitement, nous allons utiliser le design patternPipeline.Ce modèle de conception permet de définir une chaine de responsabilité (processus)destinée à s'exécuter de façon séquentielle : l'une après l'autre. Voici donc le diagrammedes classes modélisant cette chaine de traitement :

Figure 04 : Diagramme des classes de l'analyseur.

Après l'implémentation, on pourra écrire le code suivant pour initialiser l'analyseur.

Pipeline<String,Expression>analyser =null;analyser =newPipeline<>(newPreprocess(...)).addHandler(newTreeBuilder(...));

• Preprocess a besoin de la liste de tous les opérateurs mappés avec leur niveau deriorité (de 1 à$+\infty$).

{"+": 1};{"-": 1};{"/": 2};{"*": 2};

Plus ce nombre augment pour un opérateur plus ce opérateur a plus de priorié.

• TreeBuilder a besoin de la liste des opérateurs mappés avec leur instance de noeudnon-terminal respectives.

{"+": (l, r) -> new AddNode(l, r)}{"-": (l, r) -> new SubtractNode(l, r)};{"*": (l, r) -> new MultiplyNode(l, r)};{"/": (l, r) -> new DivisionNode(l, r)};

Et pour une équation bien définit sous forme chaine de caractères, on pourra faire comme suit :

NodetreeRoot =analyser.execute("a * b + c - d");

treeRoot sera donc le noeud racine de l'arbre de calcul résultant de l'équationa * b + c - d.

Ici, il s'agira de "builder" une instance de la calculatrice (Calculator) muni de son analyseur.Pour cela nous allons utiliser le patternBuilder pour élaboler le programme qui va nouspermettre de construire une instance de notre calculatrice. Voici le diagramme des classesde l'analyseur :

Figure 04 : Diagramme des classes du buildeur d'un objetCalculator.

Je ne vais pas détailler l'implémentation de toutes les classes énoncées dans la partie,mais je peux vous montrer le résultat d'implémentation sur un exemple d'équation. Je feraila démonstraction sur exemple suivant :

$$\alpha + x_2 \times x_3 - x_4 \times x_4 + x_4 \times (x_1 + \alpha) + \frac{x_5}{x_3 \times x_2}$$

Dans une première étape, on doit construire une instance de la calculatriceCalculator.

Builder<Calculator>b =newCalculatorBuilder();Directordirector =newDirector(b);director.makeBuild();Calculatorcalc =b.getResult();

On définit une instance d'un context qui encapsulera toutes les variables de l'équationassociées à leur valeur.

// instantiate the contextContextctx =newContext();ctx.assign("alpha",8);ctx.assign("x1",0);ctx.assign("x2",12);ctx.assign("x3",10);ctx.assign("x4",65);ctx.assign("x5",32);ctx.assign("x6",10);

On définit ensuite l'équation en fonction de ces variables définies précédement.

calc.setEquation("alpha + x2 * x3 - x4 * x4 + x4 * (x1 + alpha) + x5 / (x3 * x2)");calc.setContext(ctx);System.out.println(ctx);System.out.println("Equation = " +calc.getEquation());

Maintenant, on peut évaluer l'équation en appelant la fonctionevaluate() de l'objetcalc.

try {Doubleresult =calc.evaluate();// On convertie le resultat en entier avant de l'afficher.System.out.println("Result = " +result.intValue());}catch (SemanticErrore) {System.out.println("SemanticError:\t" +e);}catch (Exceptione) {e.printStackTrace();}

Le programme a tout simplement remplacé les valeurs du contexte par leur variable dans l'équationavant d'éffectuer le calcul.