rapport.md

---
title: "rapport_analyse_andjembe_taniel"
author: "ANDJEMBE_TANIEL"
date: "5 juin 2019"
output: html_document
---
> # ** RAPPORT ANALYSE ET CONCEPTION **
> ANDJEMBE Maksoudath, TANIEL Rémi
# SCHEMA UML
![UML](uml.png)
# PSEUDO-JAVA CREATION GRILLE,CASES
Pour créer une grille avec des cases on fera :
```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
ArrayList<Case> plageCase1 = new ArrayList<Case>(); // 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
ArrayList<Case> plageCase2 = new ArrayList<Case>(); // 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))
```
# CHOIX STRUCTURE DE DONNÉES
Une collection peut etre:
  * des tableaux,
  * des listes,
  * des maps
  * ou des Sets.
  
D'après le schéma UML ci-dessus:
* Une grille peut contenir plusieurs cases,nous avons effectuer le choix des Maps car, pour rechercher une case et, effectuer des opérations dessus ce sera plus   facile (son nom c'est-à-dire concaténation du nom de ligne et colonne sera la clé de notre map).
* Une case peut etre utilisée dans plusieurs cases, on ne sait pas le nombre d'autres cases où il sera utilisé, il n'y a pas necessité d'avoir un indice, on le stockera dans une liste.
* Une fonction est utilisé à partir de plusieurs cases aussi, en utilisant la meme raison ci-dessus, on stockera dans une liste de cases.
# METHODES ESSENTIELLES EN PSEUDO-JAVA
#### 1. Methode getValeur
```java
Class Grille{
  Map<String, Case> cases  = new HashMap<>();
  
  double getValeur( String colonne, int ligne){
    String code=colonne+ligne;
    return cases.get(code).getValeur();
  }
}
Class Case{
  String colonne;
  int ligne;
  double valeur;
  
  double getValeur(){
    
    return valeur;
  }
}
```
#### 2. Methode getFormule
```java
Class Grille{
  Map<String, Case> cases  = new HashMap<>();
  
  String getFormule( String colonne, int ligne){
    String code=colonne+ligne;
      return cases.get(code).getFormule();
  }
}
Class Case{
  String colonne;
  int ligne;
  double valeur;
  Formule formule;
  
  String getFormule(){
    
    return this.formule.toString();
  }
}
```
#### 3. Methode getFormuleDeveloppe
```java
Class Grille{
  Map<String, Case> cases  = new HashMap<>();
  
  String getFormuleDeveloppe( String colonne, int ligne){
    String code=colonne+ligne;
      return cases.get(code).getFormuleDeveloppe();
  }
}
Class Case{
  String colonne;
  int ligne;
  double valeur;
  Formule formule;
  ArrayList<Case> utiliseDans = new ArrayList<Case>(); 
  
  String getFormuleDeveloppe(){
    
    return this.formule.getFormuleDeveloppe();
  }
}
```
#### 4. Methode eval()
- Dans Addition :
```java
Class Addition{
  Case gauche;
  Case droite;
  double eval(){
    if (!creerCycle)
      return gauche + droite ;
    else
     lève une exception
  }
}
```
- Dans Multiplication :
```java
Class Multiplication{
  Case gauche;
  Case droite;
  double eval(){
    if (!creerCycle)
      return gauche * droite ;
    else
     lève une exception
  }
}
```
- Dans Soustraction :
```java
Class Soustraction{
  Case gauche;
  Case droite;
  double eval(){
    if (!creerCycle)
      return gauche - droite ;
    else
     lève une exception
  }
}
```
- Dans Division :
```java
Class Division{
  Case gauche;
  Case droite;
  double eval(){
    if (!creerCycle && droite!=0)
      return gauche *+* droite ;
    else
     lève une exception
  }
}
```
- Dans Moyenne :
```java
Class Moyenne{
  ArrayList<Case> listePlage = new ArrayList<Case>(); 
  double eval(){
  double val=0;
  
    if (!creerCycle && listePlage.size()!=0 )
      for(int i=0; i<listePlage.size(); i++)
            val=listePlage.get(i).getValeur()+val;
      return val/listePlage.size();
    else
     lève une exception
  }
}
```
- Dans Somme :
```java
Class Somme{
  ArrayList<Case> listePlage = new ArrayList<Case>(); 
  double eval(){
  double val=0;
  
    if (!creerCycle )
      for(int i=0; i<listePlage.size(); i++)
            val=listePlage.get(i).getValeur()+val;
      return val;
    else
     lève une exception
  }
}
```
#### 5. Methode setValeur(fixerValeur)
```java
Class Grille{
  Map<String, Case> cases  = new HashMap<>();
  
  void setValeur( String colonne, int ligne,double value){
    String code=colonne+ligne;
      return cases.get(code).setValeur(double);
  }
}
Class Case{
  String colonne;
  int ligne;
  double valeur;
  Formule formule;
  ArrayList<Case> utiliseDans = new ArrayList<Case>(); 
  
  void setValeur(double value){
    
    valeur=value;
    for(int i=0; i<utiliseDans.size(); i++)
            utiliseDans.get(i).updateValeur();
    
  }
}
```
#### 5. Methode setFormule
```java
Class Grille{
  Map<String, Case> cases  = new HashMap<>();
  
  void setFormule( String colonne, int ligne,Formule formule){
    String code=colonne+ligne;
      return cases.get(code).setFormule(formula);
  }
}
Class Case{
  String colonne;
  int ligne;
  double valeur;
  Formule formule;
  ArrayList<Case> utiliseDans = new ArrayList<Case>(); 
  
  void setFormule(Formule formula){
    
    if (!formula.creerCycle())
      formule=formula
      this.updateValeur();
      for(int i=0; i<utiliseDans.size(); i++)
        utiliseDans.get(i).updateValeur();
    else
      lève une exception
    
  }
}
```
# LISTE DE TESTS