From d2c86fc11ea8b0abe796b13d746d2625c2ad76b0 Mon Sep 17 00:00:00 2001 From: Remi Date: Thu, 6 Jun 2019 15:19:46 +0200 Subject: [PATCH] finish rapport --- .gitignore | 1 + rapport.md | 304 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------------------------------------------------------------------------------------------------------------------ rapport.pdf | Bin 0 -> 291052 bytes uml.png | Bin 145900 -> 0 bytes 4 files changed, 161 insertions(+), 144 deletions(-) create mode 100644 rapport.pdf diff --git a/.gitignore b/.gitignore index 868c8b9..ccb026f 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ /.idea *.iml /out +/.metadata diff --git a/rapport.md b/rapport.md index f89b9f8..4718218 100644 --- a/rapport.md +++ b/rapport.md @@ -10,6 +10,7 @@ extensible, l'application sera divisée en 2 parties : Le noyau s'occupera de toutes les opérations de notre grille, les cases ne pourront contenir que des réels ou des formules(opération binaire ou des fonctions acceptant des plages de cases). + ### SCHEMA UML Voici le schéma UML de notre application, les classes et méthodes @@ -24,34 +25,38 @@ Voici un exemple de création d'une grille et de l'ajout / modification / affichage de plusieurs types de case : ```java -Grille g= new Grille(); - -g.addCase("b",1); //Ajout case vide -g.addCase("a",1,100.0); //Ajout case avec valeur -g.addCase("a",2,50.0); //Ajout case avec valeur -g.addCase("a",3,new Addition(g.get("a2"),g.get("a1"))); //Ajout case avec operation binaire - -List plageCase1 = new ArrayList(); // Crée une liste de case -plageCase1.add(g.get("a1")); -plageCase1.add(g.get("a2")); -plageCase1.add(g.get("a3")); - -g.addCase("a",4,new Somme(plageCase1)); //Ajout case avec fonctions - -g.setValeur("b",1,100); //Met la valeur de b1 à 100 - -List plageCase2 = new ArrayList(); // Crée une liste de case -plageCase1.add(g.get("a4")); -plageCase1.add(g.get("a2")); -plageCase1.add(g.get("a3")); - -g.setFormule("b",2,new Moyenne(plageCase2)); //Met la formule dans b2 - -g.getValeur("a",1); //Affichera 100.0 -g.getValeur("a",4); //Affichera (100+50+150)=100 -g.getFormule("b",2) //Affichera MOYENNE(a4,a2,a3) -g.getFormuleDeveloppe("b",2) //Affichera MOYENNE(Somme(a1,a2,a3),a2,(a1+a2)) - +class Application { + + public static void main(String[] args) { + Grille g = new Grille(); + + g.createCase("b",1); //Ajout case vide + g.createCase("a",1,100.0); //Ajout case avec valeur + g.createCase("a",2,50.0); //Ajout case avec valeur + g.createCase("a",3,new Addition(g.getCase("a",2),g.getCase("a",1))); //Ajout case avec operation binaire + + List plageCase1 = new ArrayList(); // Crée une liste de case + plageCase1.add(g.getCase("a",1)); + plageCase1.add(g.getCase("a",2)); + plageCase1.add(g.getCase("a",3)); + + g.createCase("a",4,new Somme(plageCase1)); //Ajout case avec fonctions + + g.setValeur("b",1,100); //Met la valeur de b1 à 100 + + List plageCase2 = new ArrayList(); // Crée une liste de case + plageCase1.add(g.getCase("a",4)); + plageCase1.add(g.getCase("a",2)); + plageCase1.add(g.getCase("a",3)); + + g.setFormule("b",2,new Moyenne(plageCase2)); //Met la formule dans b2 + + g.getValeur("a",1); //Affichera 100.0 + g.getValeur("a",4); //Affichera (100+50+150)=100 + g.getFormuleAsString("b",2); //Affichera MOYENNE(a4,a2,a3) + g.getFormuleDeveloppe("b",2); //Affichera MOYENNE(Somme(a1,a2,a3),a2,(a1+a2)) + } +} ``` ### CHOIX STRUCTURE DE DONNÉES @@ -59,10 +64,10 @@ g.getFormuleDeveloppe("b",2) //Affichera MOYENNE(Somme(a1,a2,a3),a2,(a1+a2)) Nous devons choisir une structure de donnée pour stocker les cases dans notre grille, nous savons déjà que nous allons utiliser ne collection pour les stocker,voici celles que nous connaissons: -* des tableaux -* des listes -* des maps -* des sets +- des tableaux +- des listes +- des maps +- des sets D'après le schéma UML ci-dessus, nous allons donc utiliser une `HashMap` pour stocker les cases de notre grille : @@ -80,28 +85,26 @@ nous allons également une `ArrayList` de `Case`. ### METHODES ESSENTIELLES EN PSEUDO-JAVA - #### 1. Methode getValeur ```java -Class Grille{ +class Grille { Map cases = new HashMap<>(); - double getValeur( String colonne, int ligne){ + double getValeur(String colonne, int ligne){ String code=colonne+ligne; return cases.get(code).getValeur(); } } -Class Case{ +class Case { String colonne; int ligne; double valeur; - double getValeur(){ - + double getValeur() { return valeur; } } @@ -109,62 +112,83 @@ Class Case{ ``` -#### 2. Methode getFormule +#### 2. Methode getFormuleAsString ```java -Class Grille{ - Map cases = new HashMap<>(); +class Grille { + Map cases = new HashMap<>(); - String getFormule( String colonne, int ligne){ + String getFormule(String colonne, int ligne) { String code=colonne+ligne; - return cases.get(code).getFormule(); + return cases.get(code).getFormuleAsString(); } } -Class Case{ +class Case { String colonne; int ligne; double valeur; Formule formule; - String getFormule(){ - - return this.formule.toString(); + String getFormuleAsString() { + if (formule != null) + return formule.toString(); + else + return toString(); } } +// Exemple pour Addition +class Addition { + Case gauche; + Case droite; + + String toString() { + return gauche.toString() + "+" + droite.toString(); + } +} + ``` #### 3. Methode getFormuleDeveloppe ```java - -Class Grille{ +class Grille{ Map cases = new HashMap<>(); - String getFormuleDeveloppe( String colonne, int ligne){ + String getFormuleDeveloppe(String colonne, int ligne) { String code=colonne+ligne; - return cases.get(code).getFormuleDeveloppe(); + return cases.get(code).getFormuleDeveloppe(); } } - -Class Case{ +class Case{ String colonne; int ligne; double valeur; Formule formule; ArrayList utiliseDans = new ArrayList(); - String getFormuleDeveloppe(){ - - return this.formule.getFormuleDeveloppe(); + String getFormuleDeveloppe() { + if (formule != null) + return formule.getFormuleDeveoppe(); + else + return toString(); } } +// Exemple pour Moyenne +class Moyenne { + List listCases = new ArrayList(); + + String getFormuleDeveloppe() { + return "Moyenne(" + listCases.stream().map(c -> c.getFormuleDeveloppe()).collect((Collectors).joining(", ")) + ")"; + } +} + ``` @@ -173,17 +197,12 @@ Class Case{ - Dans Addition : ```java - - -Class Addition{ +class Addition { Case gauche; Case droite; - double eval(){ - if (!creerCycle) - return gauche + droite ; - else - lève une exception + double eval() { + return gauche.getValeur() + droite.getValeur(); } } @@ -192,17 +211,12 @@ Class Addition{ - Dans Multiplication : ```java - - -Class Multiplication{ +class Multiplication { Case gauche; Case droite; - double eval(){ - if (!creerCycle) - return gauche * droite ; - else - lève une exception + double eval() { + return gauche.getValeur() * droite.getValeur(); } } ``` @@ -211,17 +225,12 @@ Class Multiplication{ - Dans Soustraction : ```java - - -Class Soustraction{ +class Soustraction { Case gauche; Case droite; - double eval(){ - if (!creerCycle) - return gauche - droite ; - else - lève une exception + double eval() { + return gauche.getValeur() - droite.getValeur(); } } @@ -230,17 +239,15 @@ Class Soustraction{ - Dans Division : ```java - - -Class Division{ +class Division { Case gauche; Case droite; - double eval(){ - if (!creerCycle && droite!=0) - return gauche / droite ; + double eval() { + if (droite.getValeur() != 0) + return gauche.getValeur() / droite.getValeur(); else - lève une exception + lève une exception } } @@ -249,20 +256,18 @@ Class Division{ - Dans Moyenne : ```java +class Moyenne { + List listCases = new ArrayList(); - -Class Moyenne{ - ArrayList listePlage = new ArrayList(); - - double eval(){ - double val=0; + double eval() { + double val=0; - if (!creerCycle && listePlage.size()!=0 ) - for(int i=0; i listePlage = new ArrayList(); - - double eval(){ - double val=0; - - if (!creerCycle ) - for(int i=0; i listCases = new ArrayList(); + + double eval() { + double val=0; + if (listCases.size() != 0) + for(int i=0; i cases = new HashMap<>(); - void setValeur( String colonne, int ligne,double value){ - String code=colonne+ligne; - return cases.get(code).setValeur(double); + void setValeur(String colonne, int ligne, double value) { + String code = colonne + ligne; + return cases.get(code).setValeur(value); } } - -Class Case{ +class Case { String colonne; int ligne; double valeur; Formule formule; - ArrayList utiliseDans = new ArrayList(); + List utiliseDans = new ArrayList(); - void setValeur(double value){ - - valeur=value; + void setValeur(double value) { + valeur = value; for(int i=0; i cases = new HashMap<>(); - void setFormule( String colonne, int ligne,Formule formule){ - String code=colonne+ligne; - return cases.get(code).setFormule(formula); + void setFormule(String colonne, int ligne, Formule formule) { + String code = colonne + ligne; + return cases.get(code).setFormule(formula); } } -Class Case{ +class Case { String colonne; int ligne; double valeur; Formule formule; - ArrayList utiliseDans = new ArrayList(); + List utiliseDans = new ArrayList(); - void setFormule(Formule formula){ - - if (!formula.creerCycle()) - formule=formula - this.updateValeur(); // equivaut à valeur=formula.eval(); + void updateValeur() { + valeur = formule.eval(); + } + + void setFormule(Formule formula) { + if (!formula.creerCycle(this)) + formule = formula; + updateValeur(); for(int i=0; i