feat: added part about vitter params

report/report.qmd

@@ -232,10 +232,56 @@ l'inverse quantifiée.
 # Huffman Adaptatif
 
 Dans ce travail pratique nous allons implémenter l'algorithme de compression
-Huffman Adaptatif. Celui-ci aura pour but de construire un arbre binaire où
-chaque noeud **externe** représentera un caractère dans la chaîne fournie pour
-l'encodage et la valeur des noeuds **internes** correspondra à la somme des
-poids de ses enfants (i.e. nombre d'occurrence du caractère).
+Huffman Adaptatif. L'intérêt de cet algorithme est de pouvoir maximiser la
+compression d'une chaîne de caractères en combinant le codage fixe (e.g. ASCII)
+et variable (e.g. Huffman). L'arbre résultant aura deux types de noeuds
+différents. Les noeuds dit **externes** représenteront les caractères rencontrés
+de la chaîne original et les des noeuds **internes** correspondront à la somme
+des poids de ses enfants (i.e. nombre d'occurrence des caractères). Par
+conséquent le poids de la racine de l'arbre doit être égal à la longueur de la
+chaîne de caractère initiale.
+
+## Calcul des codes fixes
+
+Initialement, afin de calculer les codes fixes de chaque caractère nous devons
+calculer les paramètres de Vitter $e$ et $r$. La valeur de ceux-ci dépendent
+de la longueur de l'alphabet utilisé pour l'encodage.
+
+```python
+def compute_vitter_params(m: int) -> tuple[int, int]:
+    e = math.floor(np.log2(m))
+    r = m - (2 ** e)
+    return (e, r)
+```
+
+Étant donné que la longueur de notre alphabet est de 36, la valeur de $e$ est
+égale à 5 et celle de $r$ est de 4. Sur la base de ses valeurs nous pouvons
+donc calculer les codes fixes des divers caractères sur la base des règle
+suivantes :
+
+- Si $0 \leq k \leq 2r$, alors le symbole $S_{k}$ est encodé par la
+représentation binaire de $(k - 1)$ sur $(e + 1)$
+    - où $k$ est la position du symbole dans l'alphabet trié
+- Sinon, le symbole $S_{k}$ est encodé par la représentation binaire de
+$(k - r - 1)$ sur $e$ bits.
+
+```python
+def compute_k(char: str) -> int:
+    return DICT_ALPHABET[char]
+
+
+def compute_code(char: str):
+    e, r = compute_vitter_params(len(LIST_ALPHABET))
+    k_char = compute_k(char)
+
+    if k_char <= 2*r:
+        bin_val = k_char - 1
+        n_bits = e + 1
+        return bin(bin_val)[2:].zfill(n_bits)
+    else:
+        bin_val = k_char - r - 1
+        return bin(bin_val)[2:].zfill(e)
+```
 
 ## Structure de l'arbre
 
@@ -369,3 +415,9 @@ Node(weight=9,
                                                             value='v',
                                                             left=None,
 ```
+
+## Décodage
+ 
+Pour le décodage, nous allons appliquer l'algorithme présenté dans le cours
+n°5. Celui-ci stripule qu'il est nécessaire de parcourir l'arbre au fur et à
+mésure jusqu'à retrouver la feuille NYT. À ce moment il est