Update rapport

mandjemb
1 parent 4fce272e
Showing 1 changed file with 126 additions and 81 deletions Show diff stats
rapport_finale.md
@@ -31,7 +31,7 @@ affichage de plusieurs types de case :
 class Application {
     public static void main(String[] args) {
-        Grille g = new Grille();
+        Grid g = new Grid();
         g.createCase("b",1); //Ajout case vide
         g.createCase("a",1,100.0); //Ajout case avec valeur
@@ -45,19 +45,19 @@ class Application {
         g.createCase("a",4,new Somme(plageCase1)); //Ajout case avec fonctions
-        g.setValeur("b",1,100); //Met la valeur de b1 à 100
+        g.setValue("b",1,100); //Met la valeur de b1 à 100
         List<Case> plageCase2 = new ArrayList<Case>(); // 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.setFormula("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); 
+        g.getValue("a",1); //Affichera 100.0
+        g.getValue("a",4); //Affichera (100+50+150)=100
+        g.getFormulaAsString("b",2); //Affichera MOYENNE(a4,a2,a3)
+        g.getDevelopedFormula("b",2); 
     }
 }
 ```
@@ -90,13 +90,15 @@ nous allons également une `ArrayList` de `Case`.
 #### 1. Methode getValeur
+Cette méthode retourne la valeur d'une case se trouvant dans une grille grâce aux coordonnées de la case.
+Elle utilise la méthode getCell qui permet d'accet à une case qui existe et dans le contraire lève une exeption.
 ```java
 class Grid {
-  Map<String, Case> cases  = new HashMap<>();
+  Map<String, Cell> cells  = new HashMap<>();
   double getValue(String column, int line){
-    return cases.getCell(column, line).getValue();
+    return this.getCell(column, line).getValue();
   }
 }
@@ -116,10 +118,13 @@ class Cell {
 #### 2. Methode getFormuleAsString (acceder au contenu)
+Cette méthode permet de retourner le contenu d'une case. Si elle contient une formule, on retourne la formule simple et dans le cas contraire son nom
+pou dire qu'elle ne contient pas de formule mais une valeur.
+
 ```java
 class Grid {
-  Map<String, Case> cases = new HashMap<>();
+  Map<String, Cell> cells  = new HashMap<>();
   String getFormuleAsString(String column, int line) {
     return this.getCell(column, line).toString();
@@ -140,15 +145,24 @@ class Cell {
           return toString();
   }
 }
+```
+**Exemple pour Addition** (Opération Binaire)
-// Exemple pour Addition
-class Addition {
+La classe BinaryOperation implémente la methode toString() en, récuperant l'opérateur qui est définit dans la méthode getOperator() de chaque classe qui hérite d'elle.
+```java
+class BinaryOperation {
     Cell leftCell;
     Cell rightCell;
-    String toString() {
-        return leftCell.toString() + "+" + rightCell.toString();
-    }
+	public String toString() {
+		return "(" + this.leftCell.getId() + this.getOperator() + this.rightCell.getId() + ")";
+	}
+}
+class Addition {
+    	
+	public String getOperator() {
+		return "+";
+	}
 }
 ```
@@ -156,16 +170,17 @@ class Addition {
 #### 3. Methode getDevelopedFormula
+Cette méthode renvoie la formule dévéloppée d'une case.
 ```java
 class Grid{
-  Map<String, Case> cases  = new HashMap<>();
+  Map<String, Cell> cells  = new HashMap<>();
   String getDevelopedFormula(String column, int line) {
     return this.getCell(column,line).getFormuleDeveloppe();
   }
 }
-class Case{
+class Cell{
   String column;
   int line;
   double value;
@@ -174,13 +189,16 @@ class Case{
   String getDevelopedFormula() {
       if (formula != null)
-          return formula.getFormuleDeveoppe();
+          return formula.getDevelopedFormula();
       else
           return toString();
   }
 }
+```
+
+**Exemple de la méthode getDevelopedFormula() pour la class Average** (moyenne)
-Average
+```java
 class Average {
     List<Cell> listCases = new ArrayList<Cell>();
@@ -194,15 +212,24 @@ class Average {
 #### 4. Methode eval()
+Cette méthode permet de retourner le résultat d'un calacul avec des opérations binaires ou des fonctions.
+
+##### Opération binaires 
+
+class BinaryOperation {
+    Cell leftCell;
+    Cell rightCell;
+    
+}
+Les classes Addition,Multiplication,Substraction et Division héritent de la classe BinaryOpération et utilisent donc ses attributs leftCell et rightCell.
+
 - Dans Addition :
 ```java
 class Addition {
-  Case gauche;
-  Case droite;
   double eval() {
-      return gauche.getValeur() + droite.getValeur();
+      return leftCell.getValue() + rightCell.getValue();
   }
 }
@@ -212,11 +239,10 @@ class Addition {
 ```java
 class Multiplication {
-  Cell gauche;
-  Cell droite;
+
   double eval() {
-      return gauche.getValeur() * droite.getValeur();
+      return leftCell.getValue() * rightCell.getValue();
   }
 }
 ```
@@ -225,12 +251,10 @@ class Multiplication {
 - Dans Soustraction :
 ```java
-class Soustraction {
-  Cell gauche;
-  Cell droite;
+class Substraction {
   double eval() {
-      return gauche.getValeur() - droite.getValeur();
+      return leftCell.getValue() - rightCell.getValue();
   }
 }
@@ -240,32 +264,38 @@ class Soustraction {
 ```java
 class Division {
-  Cell gauche;
-  Cell droite;
+
   double eval() {
-    if (droite.getValeur() != 0)
-        return gauche.getValeur() / droite.getValeur();
+    if (droite.getValue() != 0)
+        return gauche.getValue() / droite.getValue();
     else
         lève une exception
   }
 }
 ```
+##### Fonctions
+
+class Function {
+    List<Cell> listCells;
+    
+}
+Les classes Average et Sum héritent de la classe BinaryOpération et utilisent donc son attribut listCells. 
+
 - Dans Moyenne :
 ```java
 class Average {
-  List<Cell> listCases = new ArrayList<Cell>(); 
   double eval() {
     double val=0;
     if (listCases.size() != 0)
-      for(int i=0; i<listCases.size(); i++)
-            val += listCases.get(i).getValeur();
-      return val / listCases.size();
+      for(int i=0; i<listCells.size(); i++)
+            val += listCells.get(i).getValue();
+      return val / listCells.size();
     else
       lève une exception
   }
@@ -276,13 +306,12 @@ class Average {
 ```java
 class Sum {
-  List<Cell> listCases = new ArrayList<Cell>(); 
   double eval() {
     double val=0;
     if (listCases.size() != 0)
-      for(int i=0; i<listCases.size(); i++)
-            val += listCases.get(i).getValeur();
+      for(int i=0; i<listCells.size(); i++)
+            val += listCells.get(i).getValue();
       return val;
     else
         lève une exception
@@ -291,77 +320,86 @@ class Sum {
 ```
-#### 5. Methode setValeur
+#### 5. Methode setValue
+
+Lorsque l'on modifie une valeur d'une case, on met à jour la valeur des cases qui utilisent la case.
 ```java
 class Grid {
-  Map<String, Case> cases  = new HashMap<>();
+  Map<String, Cell> cells  = new HashMap<>();
-  void setValeur(String colonne, int ligne, double value) {
-    String code = colonne + ligne;
-    return cases.get(code).setValeur(value);
-  }
+  void setValue(String column, int line, double value)  {
+		this.getCell(column, line).setValue(value);
+	}
 }
 class Cell {
-  String colonne;
-  int ligne;
-  double valeur;
-  Formule formule;
-  List<Cell> utiliseDans = new ArrayList<Cell>(); 
+  String column;
+  int line;
+  double value;
+  Formula formula;
+  List<Cell> usedIn = new ArrayList<Cell>(); 
-  void setValeur(double value) {
-    valeur = value;
-    for(int i=0; i<utiliseDans.size(); i++)
-       utiliseDans.get(i).updateValeur();
+  void setValue(double valeur) {
+    value = valeur;
+    for(int i=0; i<usedIn.size(); i++)
+       usedIn.get(i).updateValue();
   }
 }
 ```
-#### 5. Methode setFormule
+#### 5. Methode setFormula
+
+Cette méthode assigne une formule à une case en étant sûre qu'un cycle n'est pas créée.
 ```java
 class Grid {
   Map<String, Cell> cases  = new HashMap<>();
-  void setFormule(String colonne, int ligne, Formule formule) {
+  void setFormula(String column, int line, Formula formula) {
     String code = colonne + ligne;
-    return cases.get(code).setFormule(formula);
+    	this.getCell(column, line).setFormula(formula);
   }
 }
 class Cell {
-  String colonne;
-  int ligne;
-  double valeur;
-  Formule formule;
-  List<Cell> utiliseDans = new ArrayList<Cell>();
+  String column;
+  int line;
+  double value;
+  Formula formula;
+  List<Cell> usedIn = new ArrayList<Cell>(); 
-  void updateValeur() {
-      valeur = formule.eval();
+  void updateValue() {
+      valeur = formula.eval();
   }
-  void setFormule(Formule formula) {
-    if (!formula.creerCycle(this))
+  void setFormula(Formula formula) {
+    if (!formula.createCycle(this))
       formule = formula;
-      updateValeur();
-      for(int i=0; i<utiliseDans.size(); i++)
-        utiliseDans.get(i).updateValeur();
+      updateValue();
+      for(int i=0; i<usedIn.size(); i++)
+        usedIn.get(i).updateValue();
     else
       lève une exception
   }
 }
+```
+#### 5. Methode createCycle
+
+Cette méthode vérifie si on créée un cycle direct ou indirece.La façon de la définir est differente si on a une opération binaire ou une focntion.
+
+#####   Opération binaire
-BinaryOperation
-class OperationBinaire {
-    Cell gauche;
-    Cell droite;
+```java
+class BinaryOperation {
+    Cell leftCell;
+    Cell rightCell;
-    boolean creerCycle(Case case) {
+    boolean createCycle(Cell cell) {
         Si la case gauche ne contient pas de formule et la case de droite contient une
-          rechercher si la case est dans la formule de la case de droite
+          rechercher si la case est dans la formule de la case de droite 
         Si la case gauche contient une  formule et la case de droite n'en contient pas
           rechercher si la case est dans la formule de la case de gauche
@@ -374,11 +412,15 @@ class OperationBinaire {
     }
 }
-Function
-class Fonction {
+```
+
+#####   Fonction
+
+```java
+class Function {
     List<Cell> listCells;
-    boolean creerCycle(Case case) {
+    boolean creerCycle(Cell cell) {
         Si la case n'est pas dans listCells
           Pour toute les cases dans listCells qui contiennent des formules, regarder si la case est dans la formule
@@ -418,12 +460,15 @@ Le schéma ci-dessus nous montre que, l&#39;implémentation est composé de 5 packag
 ### MODES D'UTILISATION
+Concernant les commandes de compilation et d'exécution, sous des logiciels comme Eclipse ou IntelliJ par exemple, juste un clique bouton suffit.
+
+Par contre, dans le cas contraire, il faut se placer dans à la raicne du repertoire contenant les fichiers et lancer les commandes suivantes : 
-** Commande de compilation**: 
+**Commande de compilation**: 
 find src -not \( -path src/kernel/test -prune \) -name \*.java |xargs -i javac -d bin {} -cp src/ 
-** Commande d'exécution**: 
+**Commande d'exécution**: 
 java bin/app/Main