From d0557710dda0cdec58b9895fe1f91f4486edf21e Mon Sep 17 00:00:00 2001
From: "iliya.saroukha" <iliya.saroukhanian@etu.hesge.ch>
Date: Fri, 18 Apr 2025 18:59:30 +0200
Subject: [PATCH] feat: added part about vitter params
---
report/report.qmd | 60 +++++++++++++++++++++++++++++++++++++++++++----
1 file changed, 56 insertions(+), 4 deletions(-)
diff --git a/report/report.qmd b/report/report.qmd
index 3b704f9..82a8050 100644
--- a/report/report.qmd
+++ b/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
--
GitLab