README.md

 # Numeric
 
+## Changelog
+
+- 19.11.2019: Rendu itération 2 (voir ci-dessous)
+  
+## Délais
+
+- Rendu de la version 2 de votre TP (`tag v2.0`)
+  - mercredi 8 janv. 17h00 (groupe soir) 
+  - vendredi 10 janv. 8h30 (groupe jour) 
+  - Le tag n'est pas nécessaire. Seul le dernier push sera pris en compte
+  - En cas de retard (pénalité) veuillez nous l'annoncer au plus vite pour qu'on puisse refaire un pull
+
 
 Ce repository contient l'énoncé du TP "numeric" et un squelette maven.
 Nous vous conseillons de vous abonner aux notifications (watch) pour ne pas manquer des annonces ou des changements.
@@ -10,9 +22,11 @@ Après avoir choisi votre binôme, vous devrez **impérativement** :
 - Ajouter Joel Cavat (@joel.cavat), Jeremy Gobet (@jeremy.gobet) et Steven Liatti (@steven.liatti) en tant que *Reporter* de votre repository.
 - Lire attentivement l'énoncé.
 
-## Fonctionnalités à réaliser sur les vecteurs (itération 1)
+# Itération 1 (tag `v1.0` - 17 novembre à 22h00)
 
-Le projet contient déjà un ensemble de tests unitaires. Faites-en sorte que le projet compile et que les tests passsent.
+## Fonctionnalités à réaliser sur les vecteurs
+
+Le projet contient déjà un ensemble de tests unitaires. Faites-en sorte que le projet compile et que les tests passent.
 
 Vous devez réaliser des fonctionnalités sur les calculs vectoriels (dans un premier temps). Utilisez le package `ch.hepia.numeric` pour mettre vos classes.
 
@@ -35,7 +49,7 @@ Vous devez réaliser des fonctionnalités sur les calculs vectoriels (dans un pr
 - [ ] Toutes ces fonctionnalités doivent exister sur un **vecteur transposé**.
 - [ ] Retourne RuntimeException() avec un message approprié en cas d'erreurs
 
-##### Vecteur
+### Vecteur
 
 ```math
 \vec{x} = \begin{bmatrix}
@@ -44,7 +58,7 @@ Vous devez réaliser des fonctionnalités sur les calculs vectoriels (dans un pr
 ```
 
 
-##### Transposée
+### Transposée
 
 ```math
 \vec{x}^t = \begin{bmatrix}
@@ -52,7 +66,7 @@ Vous devez réaliser des fonctionnalités sur les calculs vectoriels (dans un pr
 \end{bmatrix}
 ```
 
-##### Produit scalaire en notation matricielle
+### Produit scalaire en notation matricielle
 
 ```math
 \vec{x}^t \cdot \vec{y} = \begin{bmatrix}
@@ -62,7 +76,7 @@ Vous devez réaliser des fonctionnalités sur les calculs vectoriels (dans un pr
 \end{bmatrix} = \sum_{i=1}^n x_i \cdot y_i
 ```
 
-##### Norme d'un vecteur
+### Norme d'un vecteur
 
 ```math
 \vec{v} \begin{pmatrix}
@@ -73,7 +87,7 @@ Vous devez réaliser des fonctionnalités sur les calculs vectoriels (dans un pr
 \end{pmatrix} = \lVert \vec{v} \rVert = \sqrt{v_1^2 + v_2^2 + ...  + v_n^2}
 ```
 
-##### Map
+### Map
 
 ```math
 map(\vec{x}, f) = \begin{bmatrix}
@@ -99,43 +113,248 @@ map(\vec{x}, f) = \begin{bmatrix}
 
 Les constructeurs doivent être non publiques. Pour créer un élément, vous devez utilisez une fabrique (méthode statique) tel que `of()` ou `empty()`
 
-## Fonctionnalités à réaliser sur les matrices (prochaine itération)
 
-TBD
 
-# Maven
+## Fonctionnalités à réaliser sur les tas binaires (*binary heap*)
+
+Nous vous demandons d'implémenter un tas d'entiers binaire de priorité maximale. Un tas binaire est une structure 
+de données pouvant être représentée comme un arbre binaire. Chaque noeud a au maximum deux noeuds 
+enfants (gauche et droit). La valeur de la donnée contenue dans un noeud (dans notre cas un nombre entier) doit 
+être supérieure ou égale à celles contenues dans ses éventuels enfants. La racine de cet arbre contient ainsi la valeur 
+la plus grande du tas (et ceci en permanence). Tous les niveaux de cet arbre doivent être pleins, à l'exception du 
+dernier. Si ce dernier niveau n'est pas entièrement rempli, il doit l'être de gauche à droite, comme sur la figure ci-dessous.
+
+<p><a href="https://commons.wikimedia.org/wiki/File:Max-Heap.svg#/media/Fichier:Max-Heap.svg"><img src="https://upload.wikimedia.org/wikipedia/commons/thumb/3/38/Max-Heap.svg/1200px-Max-Heap.svg.png" alt="Max-Heap.svg" width="500"><br></a>Un tas-max. Par <a href="//commons.wikimedia.org/w/index.php?title=User:Ermishin&amp;action=edit&amp;redlink=1" class="new" title="User:Ermishin (page does not exist)">Ermishin</a> — <span class="int-own-work" lang="fr">Travail personnel</span>, <a href="https://creativecommons.org/licenses/by-sa/3.0" title="Creative Commons Attribution-Share Alike 3.0">CC BY-SA 3.0</a>, <a href="https://commons.wikimedia.org/w/index.php?curid=12251273">Lien</a></p>
+
+Nous souhaitons une abstraction d'un tas binaire ainsi qu'une implémentation à l'aide d'un tableau statique ou d'une liste.
+
+Vous devrez également implémenter une méthode `populate()`, prenant en argument un tas binaire et un nombre de valeurs, peuplant ce tas binaire avec le bon nombre de valeurs aléatoires. Cette méthode dépend évidemment d'une abstraction.
+
+Votre code devra être placé dans le package `ch.hepia.structure`.
+
+### Implémentation avec une liste ou un tableau
+
+- La racine se situe à l'index 0.
+- Étant donné un noeud à l'index `i`, son enfant gauche est à l'index `2i+1` et son enfant droit à `2i+2`.
+- Étant donné un noeud à l'index i > 0, son parent est à l'index `(i-1) / 2` (arrondi à l'entier inférieur).
+
+<p><a href="https://commons.wikimedia.org/wiki/File:Binary_tree_in_array.svg#/media/Fichier:Binary_tree_in_array.svg"><img src="https://upload.wikimedia.org/wikipedia/commons/thumb/8/86/Binary_tree_in_array.svg/1200px-Binary_tree_in_array.svg.png" alt="Binary tree in array.svg" width="500"><br></a>Un tas binaire implémenté avec un tableau, domaine public, <a href="https://commons.wikimedia.org/w/index.php?curid=488485">Lien</a></p>
+
+### Méthodes à implémenter
+
+Un tas binaire doit fournir ces méthodes :
+
+- `push()` : ajoute un entier au tas et rétablit l'ordre du tas si nécessaire
+- `pop()` : retourne et retire la racine du tas et rétablit l'ordre du tas
+- `peek()` : retourne (sans retirer) la racine du tas
+- `addAll(list)` : ajoute tous les éléments de la liste `list` au tas
+- `isEmpty()` : indique si le tas est vide ou non
+- `exists(k)` : indique si l'entier `k` est présent dans le tas
+- `size()` : retourne le nombre d'éléments contenus dans le tas
+- `depth()` : retourne la profondeur (*id est* le nombre de niveaux) du tas
+
+Réalisez au moins deux méthodes dans l'abstraction d'un tas binaire.
+
+### Exemple d'utilisation
+
+Voici un exemple d'utilisation en pseudo-code Java :
+
+```java
+public class App {
+    public static void populate(???) {
+        ...
+    }
+    public static void main(String[] args) {
+        IntBinaryHeap heap = new ArrayIntBinaryHeap();
+        populate( heap, 42 );
+        while( !heap.isEmpty() ) {
+            System.out.println( heap.pop() );
+        }
+    }
+}
+```
+
+### Tests unitaires
+
+Vous devrez fournir également des tests unitaires, à mettre dans le package `ch.hepia.structure` du répertoire `test`, qui valident votre implémentation.
+
+
+## Fonctionnalités à réalsier sur le jeu du pendu
+
+- package `ch.hepia.hangman`
+- le main doit se trouver dans le fichier `Hangman.java`
+- les fonctionnalités peuvent éventuellement se trouver dans un fichier `HangmanHelper.java` ou en tant que méthode
+statique de `Hangman.java`
+
+### Cahier des charges (itération 1)
+
+Réalisez deux fonctionnalités pour le jeu du pendu (`Hangman.java`)
 
-Maven est un gestionnaire de projets et d'automatisation de production pour l'écosystème Java.
+- une méthode de vérification `check(String currentWord, String guessWord, char letter)`
 
-Le fichier `pom.xml` décrit le projet avec ses dépendances.
+Exemple d'utilisation
 
-### Exécutez votre projet
+- `check("_____", "amies", 'm')` retourne `"_m___"`
+- `check("_______", "caramba", 'a')` retourne `"_a_a__a"`
+- `check("_____", "frite", 'a')` retourne `"_____"`
 
-- compilation et téléchargement des dépendances. Produit un `jar` dans le dossier `target`.
+Réalisez une fonctionnalité d'affichage `print(int attempts)` du pendu en fonction du nombre d'essais manqués:
 
+- Première erreur, affichage d'une potence
 ```
-mvn package
+----------
+|/
+|
+|
+|
+|
+|
+|
 ```
 
-- exécutez à l'aide de java et du classpath:
+- Exemple de 5e erreur
+```
+----------
+|/       |
+|       (_)
+|       /| 
+|         
+|
+|
+|
+```
 
+- Exemple à la 9e et dernière erreur
 ```
-java -cp target/my-app-0.1.jar ch.hepia.my_app.App
+----------
+|/       |
+|       (_)
+|       /|\
+|        |
+|       / \
+|
+|
 ```
 
-- ou, à l'aide du plugin `exec-maven-plugin` (plus simple):
+
+
+# Itération 2 (`tag v2.0` - mercredi 8 janv. 17h00 (groupe soir) / vendredi 10 janv. 8h30 (groupe jour)  )
+
+## Fonctionnalités à réaliser sur les vecteurs
+
+Amélioration de la librairie pour fournir une DSL pour les fonctionnalités `fill` et `linspace`. Gardez les anciennes méthodes.
+
+Ajoutez l'équivalent de `fill` sous la forme :
 
 ```
-mvn exec:java
+Vector.fill(10).withValue(4.0)
 ```
 
-### Exécutez les tests uniquement
+qui sera une alternative de `Vector.fill(10, 4.0)`.
+
+Ajoutez l'équivalent du `linspace` sous la forme :
+
+```
+Vector.from(0.0).to(5.0).repeat(20);
+```
 
+qui sera une alternative de `Vector.linespace(0.0, 5.0, 20)`.
+
+## Fonctionnalités à réaliser sur les matrices 
+
+- méthode `adjugate`: solution donnée (mais vous pouvez vous référer à [wiki](https://en.wikipedia.org/wiki/Adjugate_matrix))
+- méthode `inv`: inverse d'une matrice : $`A^{-1} = \frac{adjugate(A)}{|A|}`$ où $`|A|`$ est le déterminant d'une matrice
+- méthode `solve`: solution d'un problème de type $`A \cdot \vec{x} + \vec{b} = \vec{0}`$
+  - $`\vec{x} = A^{-1} \cdot \vec{b}`$
+- méthode `det`: partiellement écrite. Référez-vous à votre cours de math.
+
+
+## Fonctionnalités à réaliser sur le pendu
+
+Modifiez le jeux pour une utilisation suivante :
+
+```java
+Hangman h = Hangman.withSecretWord("mystere");
+/*
+ * variante: Hangman h = Hangman.randomWord();
+ * (choisit aléatoirement un mot dans une liste)
+ * doit être implémenté !
+ */
+
+String currentWord = h.currentWord(); // currentWord = "_______";
+h = h.tryWith('h');
+int attempts = h.attempts(); // attempts = 1
+int failedAttempts = h.failedAttempts(); // attempts = 1
+currentWord = h.currentWord(); // currentWord = "_______";
+h.printGallowIfError(); // affiche la potence uniquement si le dernier essai est mauvais
+
+h = h.tryWith('s');
+attempts = h.attempts(); // attempts = 2
+failedAttempts = h.failedAttempts(); // attempts = 1
+currentWord = h.currentWord(); // currentWord = "____e_e";
+h.printGallowIfError();
+h.printGallow(); // affiche la potence même si aucune erreur
+
+// Utilisation finale
+while ( !h.isFinished() ) {
+    char letter = askLetter(); // demande une lettre à l'utilisateur
+    h = h.tryWith( letter );
+    h.printCurrentWord();
+    h.printGallowIfError();
+}
+if( h.hasWon() ) {
+    System.out.println("Bravo");
+} else {
+    System.out.println("Failed");
+}
 ```
-mvn test
+
+Réalisez ensuite le jeu complet dans une méthode `runGame()`. Exemple d'utilisation:
+
+```java
+Entrez une lettre: m
+Current word: m______
+Entrez une lettre: t
+Current word: m__t___
+Entrez une lettre: r
+Current word: m__t_r_
+Entrez une lettre: u
+Current word: m__t_r_
+**********************
+Erreur(s): 1
+---------
+|/
+|
+|
+|
+|
+|
+|
+
+Entrez une lettre: y
+Current word: my_t_r_
+Entrez une lettre: s
+Current word: myst_r_
+Entrez une lettre: e
+Current word: mystere
+finished
+Congrats
 ```
 
-### Notes
+## Fonctionnalités à réaliser sur les structures
+
+- `IntBinaryHeap` et `ArrayIntBinaryHeap` doivent être itérables
+- Réalisez votre propre itérateur, n'utilisez pas celui de votre structure
+- Modifiez-les pour qu'elles soient génériques
+  - `IntBinaryHeap` devient `BinaryHeap<T>` 
+  - `ArrayIntBinaryHeap` devient `ArrayBinaryHeap<T>` 
+- Leurs éléments (le paramètre `T`) doivent être comparables
+- Ajoutez les méthodes:
+  - `popOption()` qui permet de retourner optionnellement la valeur de tête
+  - `peekIfPresent(Consumer<T> comsumer)`
+
+
+## De manière générale
 
-Le plugin `maven-assembly-plugin` est configuré et permet d'embarquer les dépendances dans un seul `jar`.
+- Retourner des exceptions explicites (plus de `RuntimeException` ou `Exception`) en cas d'anomalies.
 

src/main/java/ch/hepia/numeric/Matrix.java

+package ch.hepia.numeric;
+
+import java.util.function.BiFunction;
+import java.util.function.DoubleFunction;
+
+public class Matrix {
+
+    public int nbRows() {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public int nbCols() {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public List<Vector> cols() {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public List<Transposed> rows() {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public Transposed getRow(int i) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public Vector getCol(int i) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public double get(int i, int j) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    void set(int row, int col, double value) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public Matrix map(DoubleFunction<Double> f) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public Matrix add(Matrix that) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public Matrix mul(double d) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public Matrix mul(Matrix that) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public Matrix sub(Matrix that) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public boolean isSquare() {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public Matrix t() {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public Matrix rowRemoved(int i){
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public Matrix colRemoved(int i){
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public Matrix removed(int i, int j) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+
+    public Matrix adjugate() {
+        Matrix res = Matrix.tabulate(nbRows(), nbCols(), (i, j) -> {
+            if ((i + j) % 2 == 0) {
+                return removed(i, j).det();
+            } else {
+                return -removed(i, j).det();
+            }
+        });
+        return res;
+    }
+
+    public Matrix inv() {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+
+    public double det() {
+        if (!isSquare()) {
+            /* do something smart */
+        }
+
+        if( nbCols() == 1) {
+            return get(0,0);
+        } else if( nbCols() == 2 ){
+            return get(0,0)*get(1,1) - get(1,0)*get(0,1);
+        } else {
+            /* A vous de jouer */
+
+
+
+            throw new UnsupportedOperationException("This feature isn't implemented yet");
+        }
+    }
+
+    public Matrix copy() {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+
+    @Override
+    public String toString() {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+
+    public static Matrix of(List<Transposed> ts) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public static Matrix of(Transposed... ts) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public static Matrix empty() {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public static Matrix fill(int rows, int cols, double value) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public static Matrix zeros(int rows, int cols) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public static Matrix ones(int rows, int cols) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet"); 
+    }
+    public static Matrix tabulate(int rows, int cols, BiFunction<Integer, Integer, Double> f) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public static Matrix diag(double... ds) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public static Matrix identity(int nb) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+    public static Vector solve(Matrix m, Vector b) {
+        throw new UnsupportedOperationException("This feature isn't implemented yet");
+    }
+}
+
+
+
+
+
+
+
+
+
+