fix: typos

report/report.qmd

@@ -87,8 +87,8 @@ def dct(padded_img: Img, kernel_size: int) -> Img:
 La fonction `dct` va utiliser une _helper function_ (fonction d'aide) qui va
 permettre de sélectionner une sous-section de l'image en fonction des indices
 de départs fournis pour la ligne et la colonne. Cette fonction retournera
-le bloc 8x8 sur lequel la transformation sera appliqué puis insérer dans l'image
-résultante à la bonne position.
+le bloc 8x8 sur lequel la transformation sera appliquée puis insérée dans
+l'image résultante à la bonne position.
 
 ```python
 def sliding_window(img: Img, x_pos: int, y_pos: int, n: int):
@@ -148,8 +148,8 @@ faire il nous est nécessaire de calculer en premier lieu la matrice de
 quantification en fonction d'un facteur de qualité $q$ fourni. Plus ce facteur est
 élevé, plus la dégradation de la qualité de l'image sera grande. Du fait que
 nous travaillons toujours sur des blocs 8x8, la matrice de quantification
-$\mathbf{Q}$ possédera donc ces dimensions. La valeur de chaque entrée de cette
-matrice est calculée de la manière suivante :
+$\mathbf{Q}$ possédera donc les mêmes dimensions. La valeur de chaque entrée de
+cette matrice est calculée de la manière suivante :
 
 $$
 \mathbf{Q}_{ij} = 1 + q(i + j + 1)
@@ -170,16 +170,16 @@ def quantized(kernel_size: int, quality: int) -> Img:
 ```
 
 Ayant obtenu cette matrice, il est à présent possible quantifier la DCT de
-l'image obtenue au préalable. Pour ce faire, nous allons à nouveau séléctionner
+l'image obtenue au préalable. Pour ce faire, nous allons à nouveau sélectionner
 des sous-sections de taille 8x8 de la DCT et allons diviser ce bloc par la
 matrice de quantification $\mathbf{Q}$. Du fait que nous travaillons avec des
 tableaux `numpy`, il nous est possible de diviser un tableau par un autre du
 fait que l'opérateur **`/`** est surchargé. En l'occurrence, celui-ci
 effectuera une division entrée par entrée entre les deux matrices à partir du
-moment qu'elles possèdent les mêmes dimensions. Les résultats de division seront
-arrondis à l'entier le plus proche à travers la fonction `np.round`. La matrice
-résultante $\mathbf{Q}_{\text{DCT}}$ de cette opération encodera la dégradation
-supplémentaire ajoutée à la DCT.
+moment qu'elles possèdent les mêmes dimensions. Les résultats des divisions
+seront arrondis à l'entier le plus proche à travers la fonction `np.round`. La
+matrice résultante $\mathbf{Q}_{\text{DCT}}$ de cette opération encodera la
+dégradation supplémentaire ajoutée à la DCT.
 
 ```python
 def quantize_dct(dct_img: Img, kernel_size: int, quality: int) -> Img:
@@ -236,7 +236,7 @@ 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
+de la chaîne originale et les 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.
@@ -268,8 +268,9 @@ $(k - r - 1)$ sur $e$ bits.
 ```python
 def compute_k(char: str) -> int:
     return DICT_ALPHABET[char]
+```
 
-
+```python
 def compute_code(char: str):
     e, r = compute_vitter_params(len(LIST_ALPHABET))
     k_char = compute_k(char)