Commit f209d477ba55abd2390b234accda8361e78fb33e

Authored by [mandjemb]
2 parents ec2d281d d2c86fc1

d

Showing 4 changed files with 162 additions and 145 deletions   Show diff stats
.gitignore
1 1 /.idea
2 2 *.iml
3 3 /out
4   -/bin/
  4 +/bin
  5 +/.metadata
... ...
rapport.md
... ... @@ -10,6 +10,7 @@ extensible, l'application sera divisée en 2 parties :
10 10 Le noyau s'occupera de toutes les opérations de notre grille, les cases
11 11 ne pourront contenir que des réels ou des formules(opération binaire ou
12 12 des fonctions acceptant des plages de cases).
  13 +
13 14 ### SCHEMA UML
14 15  
15 16 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 /
24 25 affichage de plusieurs types de case :
25 26  
26 27 ```java
27   -Grille g= new Grille();
28   -
29   -g.addCase("b",1); //Ajout case vide
30   -g.addCase("a",1,100.0); //Ajout case avec valeur
31   -g.addCase("a",2,50.0); //Ajout case avec valeur
32   -g.addCase("a",3,new Addition(g.get("a2"),g.get("a1"))); //Ajout case avec operation binaire
33   -
34   -List<Case> plageCase1 = new ArrayList<Case>(); // Crée une liste de case
35   -plageCase1.add(g.get("a1"));
36   -plageCase1.add(g.get("a2"));
37   -plageCase1.add(g.get("a3"));
38   -
39   -g.addCase("a",4,new Somme(plageCase1)); //Ajout case avec fonctions
40   -
41   -g.setValeur("b",1,100); //Met la valeur de b1 à 100
42   -
43   -List<Case> plageCase2 = new ArrayList<Case>(); // Crée une liste de case
44   -plageCase1.add(g.get("a4"));
45   -plageCase1.add(g.get("a2"));
46   -plageCase1.add(g.get("a3"));
47   -
48   -g.setFormule("b",2,new Moyenne(plageCase2)); //Met la formule dans b2
49   -
50   -g.getValeur("a",1); //Affichera 100.0
51   -g.getValeur("a",4); //Affichera (100+50+150)=100
52   -g.getFormule("b",2) //Affichera MOYENNE(a4,a2,a3)
53   -g.getFormuleDeveloppe("b",2) //Affichera MOYENNE(Somme(a1,a2,a3),a2,(a1+a2))
54   -
  28 +class Application {
  29 +
  30 + public static void main(String[] args) {
  31 + Grille g = new Grille();
  32 +
  33 + g.createCase("b",1); //Ajout case vide
  34 + g.createCase("a",1,100.0); //Ajout case avec valeur
  35 + g.createCase("a",2,50.0); //Ajout case avec valeur
  36 + g.createCase("a",3,new Addition(g.getCase("a",2),g.getCase("a",1))); //Ajout case avec operation binaire
  37 +
  38 + List<Case> plageCase1 = new ArrayList<Case>(); // Crée une liste de case
  39 + plageCase1.add(g.getCase("a",1));
  40 + plageCase1.add(g.getCase("a",2));
  41 + plageCase1.add(g.getCase("a",3));
  42 +
  43 + g.createCase("a",4,new Somme(plageCase1)); //Ajout case avec fonctions
  44 +
  45 + g.setValeur("b",1,100); //Met la valeur de b1 à 100
  46 +
  47 + List<Case> plageCase2 = new ArrayList<Case>(); // Crée une liste de case
  48 + plageCase1.add(g.getCase("a",4));
  49 + plageCase1.add(g.getCase("a",2));
  50 + plageCase1.add(g.getCase("a",3));
  51 +
  52 + g.setFormule("b",2,new Moyenne(plageCase2)); //Met la formule dans b2
  53 +
  54 + g.getValeur("a",1); //Affichera 100.0
  55 + g.getValeur("a",4); //Affichera (100+50+150)=100
  56 + g.getFormuleAsString("b",2); //Affichera MOYENNE(a4,a2,a3)
  57 + g.getFormuleDeveloppe("b",2); //Affichera MOYENNE(Somme(a1,a2,a3),a2,(a1+a2))
  58 + }
  59 +}
55 60 ```
56 61  
57 62 ### CHOIX STRUCTURE DE DONNÉES
... ... @@ -59,10 +64,10 @@ g.getFormuleDeveloppe(&quot;b&quot;,2) //Affichera MOYENNE(Somme(a1,a2,a3),a2,(a1+a2))
59 64 Nous devons choisir une structure de donnée pour stocker les cases dans
60 65 notre grille, nous savons déjà que nous allons utiliser ne collection
61 66 pour les stocker,voici celles que nous connaissons:
62   -* des tableaux
63   -* des listes
64   -* des maps
65   -* des sets
  67 +- des tableaux
  68 +- des listes
  69 +- des maps
  70 +- des sets
66 71  
67 72 D'après le schéma UML ci-dessus, nous allons donc utiliser une `HashMap`
68 73 pour stocker les cases de notre grille :
... ... @@ -80,28 +85,26 @@ nous allons également une `ArrayList` de `Case`.
80 85  
81 86 ### METHODES ESSENTIELLES EN PSEUDO-JAVA
82 87  
83   -
84 88 #### 1. Methode getValeur
85 89  
86 90 ```java
87 91  
88   -Class Grille{
  92 +class Grille {
89 93 Map<String, Case> cases = new HashMap<>();
90 94  
91   - double getValeur( String colonne, int ligne){
  95 + double getValeur(String colonne, int ligne){
92 96 String code=colonne+ligne;
93 97 return cases.get(code).getValeur();
94 98 }
95 99 }
96 100  
97 101  
98   -Class Case{
  102 +class Case {
99 103 String colonne;
100 104 int ligne;
101 105 double valeur;
102 106  
103   - double getValeur(){
104   -
  107 + double getValeur() {
105 108 return valeur;
106 109 }
107 110 }
... ... @@ -109,62 +112,83 @@ Class Case{
109 112 ```
110 113  
111 114  
112   -#### 2. Methode getFormule
  115 +#### 2. Methode getFormuleAsString
113 116  
114 117 ```java
115 118  
116   -Class Grille{
117   - Map<String, Case> cases = new HashMap<>();
  119 +class Grille {
  120 + Map<String, Case> cases = new HashMap<>();
118 121  
119   - String getFormule( String colonne, int ligne){
  122 + String getFormule(String colonne, int ligne) {
120 123 String code=colonne+ligne;
121   - return cases.get(code).getFormule();
  124 + return cases.get(code).getFormuleAsString();
122 125 }
123 126 }
124 127  
125 128  
126   -Class Case{
  129 +class Case {
127 130 String colonne;
128 131 int ligne;
129 132 double valeur;
130 133 Formule formule;
131 134  
132   - String getFormule(){
133   -
134   - return this.formule.toString();
  135 + String getFormuleAsString() {
  136 + if (formule != null)
  137 + return formule.toString();
  138 + else
  139 + return toString();
135 140 }
136 141 }
137 142  
  143 +// Exemple pour Addition
  144 +class Addition {
  145 + Case gauche;
  146 + Case droite;
  147 +
  148 + String toString() {
  149 + return gauche.toString() + "+" + droite.toString();
  150 + }
  151 +}
  152 +
138 153 ```
139 154  
140 155  
141 156 #### 3. Methode getFormuleDeveloppe
142 157  
143 158 ```java
144   -
145   -Class Grille{
  159 +class Grille{
146 160 Map<String, Case> cases = new HashMap<>();
147 161  
148   - String getFormuleDeveloppe( String colonne, int ligne){
  162 + String getFormuleDeveloppe(String colonne, int ligne) {
149 163 String code=colonne+ligne;
150   - return cases.get(code).getFormuleDeveloppe();
  164 + return cases.get(code).getFormuleDeveloppe();
151 165 }
152 166 }
153 167  
154   -
155   -Class Case{
  168 +class Case{
156 169 String colonne;
157 170 int ligne;
158 171 double valeur;
159 172 Formule formule;
160 173 ArrayList<Case> utiliseDans = new ArrayList<Case>();
161 174  
162   - String getFormuleDeveloppe(){
163   -
164   - return this.formule.getFormuleDeveloppe();
  175 + String getFormuleDeveloppe() {
  176 + if (formule != null)
  177 + return formule.getFormuleDeveoppe();
  178 + else
  179 + return toString();
165 180 }
166 181 }
167 182  
  183 +// Exemple pour Moyenne
  184 +class Moyenne {
  185 + List<Case> listCases = new ArrayList<Case>();
  186 +
  187 + String getFormuleDeveloppe() {
  188 + return "Moyenne(" + listCases.stream().map(c -> c.getFormuleDeveloppe()).collect((Collectors).joining(", ")) + ")";
  189 + }
  190 +}
  191 +
168 192 ```
169 193  
170 194  
... ... @@ -173,17 +197,12 @@ Class Case{
173 197 - Dans Addition :
174 198  
175 199 ```java
176   -
177   -
178   -Class Addition{
  200 +class Addition {
179 201 Case gauche;
180 202 Case droite;
181 203  
182   - double eval(){
183   - if (!creerCycle)
184   - return gauche + droite ;
185   - else
186   - lève une exception
  204 + double eval() {
  205 + return gauche.getValeur() + droite.getValeur();
187 206 }
188 207 }
189 208  
... ... @@ -192,17 +211,12 @@ Class Addition{
192 211 - Dans Multiplication :
193 212  
194 213 ```java
195   -
196   -
197   -Class Multiplication{
  214 +class Multiplication {
198 215 Case gauche;
199 216 Case droite;
200 217  
201   - double eval(){
202   - if (!creerCycle)
203   - return gauche * droite ;
204   - else
205   - lève une exception
  218 + double eval() {
  219 + return gauche.getValeur() * droite.getValeur();
206 220 }
207 221 }
208 222 ```
... ... @@ -211,17 +225,12 @@ Class Multiplication{
211 225 - Dans Soustraction :
212 226  
213 227 ```java
214   -
215   -
216   -Class Soustraction{
  228 +class Soustraction {
217 229 Case gauche;
218 230 Case droite;
219 231  
220   - double eval(){
221   - if (!creerCycle)
222   - return gauche - droite ;
223   - else
224   - lève une exception
  232 + double eval() {
  233 + return gauche.getValeur() - droite.getValeur();
225 234 }
226 235 }
227 236  
... ... @@ -230,17 +239,15 @@ Class Soustraction{
230 239 - Dans Division :
231 240  
232 241 ```java
233   -
234   -
235   -Class Division{
  242 +class Division {
236 243 Case gauche;
237 244 Case droite;
238 245  
239   - double eval(){
240   - if (!creerCycle && droite!=0)
241   - return gauche / droite ;
  246 + double eval() {
  247 + if (droite.getValeur() != 0)
  248 + return gauche.getValeur() / droite.getValeur();
242 249 else
243   - lève une exception
  250 + lève une exception
244 251 }
245 252 }
246 253  
... ... @@ -249,20 +256,18 @@ Class Division{
249 256 - Dans Moyenne :
250 257  
251 258 ```java
  259 +class Moyenne {
  260 + List<Case> listCases = new ArrayList<Case>();
252 261  
253   -
254   -Class Moyenne{
255   - ArrayList<Case> listePlage = new ArrayList<Case>();
256   -
257   - double eval(){
258   - double val=0;
  262 + double eval() {
  263 + double val=0;
259 264  
260   - if (!creerCycle && listePlage.size()!=0 )
261   - for(int i=0; i<listePlage.size(); i++)
262   - val=listePlage.get(i).getValeur()+val;
263   - return val/listePlage.size();
  265 + if (listCases.size() != 0)
  266 + for(int i=0; i<listCases.size(); i++)
  267 + val += listCases.get(i).getValeur();
  268 + return val / listCases.size();
264 269 else
265   - lève une exception
  270 + lève une exception
266 271 }
267 272 }
268 273  
... ... @@ -270,52 +275,45 @@ Class Moyenne{
270 275 - Dans Somme :
271 276  
272 277 ```java
273   -
274   -
275   -Class Somme{
276   - ArrayList<Case> listePlage = new ArrayList<Case>();
277   -
278   - double eval(){
279   - double val=0;
280   -
281   - if (!creerCycle )
282   - for(int i=0; i<listePlage.size(); i++)
283   - val=listePlage.get(i).getValeur()+val;
  278 +class Somme {
  279 + List<Case> listCases = new ArrayList<Case>();
  280 +
  281 + double eval() {
  282 + double val=0;
  283 + if (listCases.size() != 0)
  284 + for(int i=0; i<listCases.size(); i++)
  285 + val += listCases.get(i).getValeur();
284 286 return val;
285 287 else
286   - lève une exception
  288 + lève une exception
287 289 }
288 290 }
289 291  
290 292 ```
291 293  
292   -#### 5. Methode setValeur(fixerValeur)
  294 +#### 5. Methode setValeur
293 295  
294 296 ```java
295   -
296   -Class Grille{
  297 +class Grille {
297 298 Map<String, Case> cases = new HashMap<>();
298 299  
299   - void setValeur( String colonne, int ligne,double value){
300   - String code=colonne+ligne;
301   - return cases.get(code).setValeur(double);
  300 + void setValeur(String colonne, int ligne, double value) {
  301 + String code = colonne + ligne;
  302 + return cases.get(code).setValeur(value);
302 303 }
303 304 }
304 305  
305   -
306   -Class Case{
  306 +class Case {
307 307 String colonne;
308 308 int ligne;
309 309 double valeur;
310 310 Formule formule;
311   - ArrayList<Case> utiliseDans = new ArrayList<Case>();
  311 + List<Case> utiliseDans = new ArrayList<Case>();
312 312  
313   - void setValeur(double value){
314   -
315   - valeur=value;
  313 + void setValeur(double value) {
  314 + valeur = value;
316 315 for(int i=0; i<utiliseDans.size(); i++)
317   - utiliseDans.get(i).updateValeur();
318   -
  316 + utiliseDans.get(i).updateValeur();
319 317 }
320 318 }
321 319  
... ... @@ -324,39 +322,56 @@ Class Case{
324 322 #### 5. Methode setFormule
325 323  
326 324 ```java
327   -
328   -Class Grille{
  325 +class Grille {
329 326 Map<String, Case> cases = new HashMap<>();
330 327  
331   - void setFormule( String colonne, int ligne,Formule formule){
332   - String code=colonne+ligne;
333   - return cases.get(code).setFormule(formula);
  328 + void setFormule(String colonne, int ligne, Formule formule) {
  329 + String code = colonne + ligne;
  330 + return cases.get(code).setFormule(formula);
334 331 }
335 332 }
336 333  
337 334  
338   -Class Case{
  335 +class Case {
339 336 String colonne;
340 337 int ligne;
341 338 double valeur;
342 339 Formule formule;
343   - ArrayList<Case> utiliseDans = new ArrayList<Case>();
  340 + List<Case> utiliseDans = new ArrayList<Case>();
344 341  
345   - void setFormule(Formule formula){
346   -
347   - if (!formula.creerCycle())
348   - formule=formula
349   - this.updateValeur(); // equivaut à valeur=formula.eval();
  342 + void updateValeur() {
  343 + valeur = formule.eval();
  344 + }
  345 +
  346 + void setFormule(Formule formula) {
  347 + if (!formula.creerCycle(this))
  348 + formule = formula;
  349 + updateValeur();
350 350 for(int i=0; i<utiliseDans.size(); i++)
351 351 utiliseDans.get(i).updateValeur();
352 352 else
353 353 lève une exception
354   -
355 354 }
356 355 }
357 356  
358   -```
  357 +// Exemple pour OperationBinaire
  358 +class OperationBinaire {
  359 + Case gauche;
  360 + Case droite;
  361 +
  362 + boolean creerCycle(Case case) {
  363 + if (gauche != case && droite != case) {
  364 + if (gauche.isFormula() && droite.isFormula())
  365 + return gauche.getFormule().creerCycle(case) && droite.getFormule().creerCycle(case);
  366 + else
  367 + return false;
  368 + }
  369 +
  370 + return true;
  371 + }
  372 +}
359 373  
  374 +```
360 375  
361 376 ### LISTE DE TESTS
362 377  
... ... @@ -364,12 +379,13 @@ Afin de s&#39;assurer de la maintenabilité de notre code et de la qualité de
364 379 celui-ci, nous allons réaliser plusieurs tests sur les différentes méthodes
365 380 que nous allons programmé dans notre application, voici quelques
366 381 exemples :
367   -* Création d'une case avec une valeur fixe
368   -* Création d'une case avec une formule d' `Opération binaire` et une
  382 +
  383 +- Création d'une case avec une valeur fixe
  384 +- Création d'une case avec une formule d' `Opération binaire` et une
369 385 fonction comme `Moyenne`
370   -* Modification d'une case avec une valeur sans qu'elle soit utilisée dans
  386 +- Modification d'une case avec une valeur sans qu'elle soit utilisée dans
371 387 une autre case
372   -* Modification d'une case avec une valeur utilisée dans une autre case
373   -* Vérification qu'une erreur se lève lors de la création des 2 types
  388 +- Modification d'une case avec une valeur utilisée dans une autre case
  389 +- Vérification qu'une erreur se lève lors de la création des 2 types
374 390 de cycles (direct et indirect)
375   -* Renvoie de la formule dévéloppée d'une case avec une formule assez compliqué
376 391 \ No newline at end of file
  392 +- Renvoie de la formule dévéloppée d'une case avec une formule assez compliqué
... ...
rapport.pdf 0 → 100644
No preview for this file type

142 KB | W: | H:

151 KB | W: | H:

  • 2-up
  • Swipe
  • Onion skin