From 7c71f31c4c9971697c647a30dcccc70e743ea676 Mon Sep 17 00:00:00 2001
From: Sihamais <sihamais98@gmail.com>
Date: Fri, 30 Apr 2021 19:16:03 +0200
Subject: [PATCH] work

---
 .gitignore |  1 +
 cce.c      | 12 ++++++++++++
 main.c     | 15 ++++++++++++++-
 rapport.md | 41 ++++++++++++++++++++++++++++++++++++-----
 4 files changed, 63 insertions(+), 6 deletions(-)

diff --git a/.gitignore b/.gitignore
index 140837f..17b0558 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 rapport.html
+rapport.pdf
 Projet_RLI_21.pdf
 *.o
 code
\ No newline at end of file
diff --git a/cce.c b/cce.c
index 57e181b..788152a 100644
--- a/cce.c
+++ b/cce.c
@@ -249,3 +249,15 @@ char *error_correction(char *codeword)
 
     return corrected;
 }
+
+char * p2_encode(char *msg)
+{
+    char* encoded;
+    return encoded;
+}
+
+char* p2_decode(char* msg)
+{
+    char* syndrome;
+    return syndrome;
+}
diff --git a/main.c b/main.c
index 7ec7828..c01c3c6 100644
--- a/main.c
+++ b/main.c
@@ -13,6 +13,7 @@ int main(void)
     printf("-- Q4 --\n");
     char *c1 = "10011000", *c2 = "10001011";
     printf("La distance de Hamming entre les codewords %s et %s est : %d\n\n", c1, c2, hamming_distance(c1, c2));
+    printf("La distance de Hamming du code C est : %d\n\n", hamming_distance(c1, c2));
 
     printf("----- IV. Restaurez la gloire matricielle de P -----\n\n");
 
@@ -22,7 +23,7 @@ int main(void)
     printf("Message encodé (avec une erreur) : %s\nSyndrome : %s\n\n", set_error(polynomial_encode(msg), 0), polynomial_decode(set_error(polynomial_encode(msg), 0))); // Le syndrome doit être 1011
 
     printf("-- Q2 --\n");
-    printf("Codeword : %s\t\tCodeword avec une erreur à la position %d : %s\n\n", encode(msg), 2, set_error(encode(msg), 2));
+    printf("Codeword : %s\nCodeword avec une erreur à la position %d : %s\n\n", encode(msg), 2, set_error(encode(msg), 2));
 
     printf("-- Q3 --\n");
     char *codeword = polynomial_encode(msg);
@@ -58,5 +59,17 @@ int main(void)
     false_codeword = set_error(codeword, 1);
     printf("Message : %s\nMessage encodé (sans erreur) : %s\nMessage encodé (avec erreur) : %s\nMessage corrigé : %s\n%s\n\n", msg, codeword, false_codeword, error_correction(false_codeword), strcmp(codeword, error_correction(false_codeword)) == 0 ? "Bon résultat" : "Mauvais résultat");
 
+    printf("----- VI. Étendre P, mais à quel prix ? -----\n\n");
+    printf("-- Q1 --\n");
+    printf("Message : %s\nMessage encodé (sans erreur) : %s\nMessage encodé (avec une erreur) : %s\nSyndrome (une erreur) : %s\n",msg, codeword, false_codeword, polynomial_decode(false_codeword));
+    false_codeword = set_error(false_codeword, 2);
+    printf("Message encodé (avec deux erreurs) : %s\nSyndrome (deux erreurs): %s\n\n", false_codeword, polynomial_decode(false_codeword));
+
+    printf("-- Q2 --\n");
+    c1 = "00110101";
+    c2 = "01011111";
+    printf("La distance de Hamming entre les codewords %s et %s est : %d\n", c1, c2, hamming_distance(c1, c2));
+    printf("La distance de Hamming de P2 est : %d\n\n", hamming_distance(c1, c2));
+
     free(false_codeword);
 }
\ No newline at end of file
diff --git a/rapport.md b/rapport.md
index 40e585f..60e8b65 100644
--- a/rapport.md
+++ b/rapport.md
@@ -1,7 +1,7 @@
 <div style="display:grid;grid-template-columns:1fr 1fr 1fr;margin:auto;margin-bottom:0px;text-align:center;">
 <h3>AISSAOUI Siham</h3>
 <h3>KLEITZ Paco</h3>
-<h3>SENSEBRENNER Amaury</h3>
+<h3>SENSENBRENNER Amaury</h3>
 </div>
 <center>
 <h1><b>Rapport de projet – Code Polynomial Correcteur d’Erreur</b></h1>
@@ -39,7 +39,25 @@ Pour un Hamming code de distance d, on peut détecter $d-1$ erreurs et corriger
 
 1. *Montrez que le polynôme générateur associé à la matrice G est $x^4 + x + 1$.*
 
-Si C est de forme [n,k] alors degré(x) = n-k.
+G est une matrice (4 × 8).
+Pour les données d'entrée à 4 bits i, le mot de code à 8 bits correspondant est donné par C = iG.
+Une matrice génératrice appropriée (4 x 8) peut être construite en écrivant le polynôme générateur 10011 décalé d'un bit vers la droite pour chaque ligne successive. Il y a 4 lignes correspondant au choix de 4 bits de données d'entrée. Les 4 lignes sont étiquetées (0 à 3) pour référence. Bien qu'il s'agisse d'un polynôme générateur valide, il ne génère pas de code systématique.
+$$\begin{array}{ccc}
+0:&1&0&0&1&1&0&0&0\\
+1:&0& 1& 0& 0& 1& 1& 0& 0\\
+2:&0& 0& 1& 0& 0& 1& 1& 0\\
+3:& 0& 0& 0& 1& 0& 0& 1& 1
+\end{array}$$
+Chaque ligne de cette matrice de générateur est également un mot de code valide de 8 bits, divisible par P(x).
+Une matrice génératrice systématique G se distingue par une matrice d'identité (k × k), souvent sur le côté gauche comme G = [Ik | P] de telle sorte que chaque mot de code comprend (k) bits de données suivis de (n-k) bits de parité. Alternativement, le format G = [P | Ik] place la matrice d'identité sur le côté droit.
+Pour ajuster la matrice de générateur ci-dessus pour un code systématique (8,4), les colonnes les plus à gauche seront manipulées pour former une matrice d'identité (4 × 4). La nouvelle ligne 0 est formée par la somme des lignes (3,0) faisant référence aux étiquettes ci-dessus.
+$$\begin{array}{ccc}
+1 &0& 0& 0& 1& 0& 1& 1& =& LIGNE(3 + 0)\\
+0& 1& 0& 0& 1& 1& 0& 0& =& RANG (1)\\
+0& 0& 1& 0& 0& 1& 1& 0& =& RANG (2)\\
+0& 0& 0& 1& 0& 0& 1& 1& =& RANG (3)
+\end{array}$$
+Chaque ligne de la matrice du générateur est un mot de code valide de 8 bits.
 
 2. *Regardez de plus près la matrice G. Voyez-vous un autre moyen d’en extraire le polynôme générateur associé ? Montrez les opérations nécessaires.*
 
@@ -104,7 +122,7 @@ On remarque le même motif qui se répéte en décalant à droite d'un bit sur c
 
 On remarque que le résultat de C mod P est le même pour une postion i peu importe le message de base. Donc C mod P renvoit le syndrome et donc la position de l'erreur dans le codeword C.
 
-4. *Soit le vecteur vi à 9 bits tel que seul le i eme bit est à 1. Pour tout $vi|i ∈$ {0,9}, calculez vi mod P. Que constatez-vous ? Que pouvez-vous en conclure ?*
+4. *Soit le vecteur vi à 9 bits tel que seul le i eme bit est à 1. Pour tout $v_i|$ i $∈$ {0,9}, calculez $v_i$ mod P. Que constatez-vous ? Que pouvez-vous en conclure ?*
 
 <div style="display:grid;grid-template-columns:1fr 1fr;">
 <table style="margin:auto;text-align:center;">
@@ -121,7 +139,7 @@ On remarque que le résultat de C mod P est le même pour une postion i peu impo
   <tr><td>100000000</td><td>0 1 0 1</td></tr>
   </tbody>
 </table>
-<p style="margin:auto;">On constate ...</p>
+<p style="margin:auto;">On constate que le syndrome est le même pour les 8 bits de poids faible du vecteur à 9 bits et du vecteur à 8 bits. On peut en conclure que l'on peut détecter une erreur présente dans les 8 bits de poids faible d'un codeword à 9 bits.</p>
 </div>
 
 5. *À l’aide de vos observations, implémentez un mécanisme efficace permettant de corriger des erreurs uniques. Justifier vos choix d’implémentation et tester votre implémentation.*
@@ -133,5 +151,18 @@ On remarque que le résultat de C mod P est le même pour une postion i peu impo
 ## VI - Étendre P, mais à quel prix ?
 
 1. *À l’aide de vos fonctions précédentes, simulez maintenant l’effet de deux erreurs simultanées sur les modulos. En particulier, comparez les modulos obtenus aux modulos précédemment observés lorsqu’une unique erreur se produisait. Que constatez-vous ? Était-ce prédictible ? Peut-on étendre la solution précédente simplement ? Pourquoi ?*
-2. *Notre polynôme est un polynôme particulier (primitif). Il peut être facilement amélioré : Soit P2 = P × (x + 1). Nous utiliserons ce polynôme pour encoder des messages de taille 3. Quelle est la taille des codewords de P2 ? Quel est son rendement ? Sa représentation binaire? Implémentez une fonction permettant de calculer sa distance de Hamming. Qu’observez-vous ?*
+
+On peut constater que le syndrome obtenu avec une erreur est différent du syndrome obtenu avec deux erreurs dans le codeword. Les fonctions précédentes permettent donc de détecter plus d'une seule erreur. C'était prédictible puisque le code C a une capacité de detection de deux erreurs dans le même codeword. Cependant, nous ne pouvons pas étendre la solution précedente afin qu'elle corrige plus d'une erreur puisque la distance de Hamming du code est de 3, et donc la solution peut reconnaître le codeword correcte lorsqu'il n'y a qu'une erreur, mais peut se tromper entre deux codewords lorsqu'il y en a plus.
+
+2. *Notre polynôme est un polynôme particulier (primitif). Il peut être facilement amélioré : Soit P2 = P × (x + 1). Nous utiliserons ce polynôme pour encoder des messages de taille 3. Quelle est la taille des codewords de P2 ? Quel est son rendement ? Sa représentation binaire ? Implémentez une fonction permettant de calculer sa distance de Hamming. Qu’observez-vous ?*
+   
+$P2 = P \times (x+1)$  
+$P2 = (x+1)(x^4+x+1)$  
+$P2 = x^5+x^4+x^2+2x+1$
+
+La taille des codewords de P2 est de 8 : 3 bits de données et 5 bits de contrôle.  
+Son rendement est de $\frac{5}{8}$ (62.5%).  
+La représentation binaire de P2 est $110101$.  
+La distance de Hamming pour P2 est de 4. Donc P2 peut détecter 3 erreurs et en corriger 1.
+
 3. *Répétez la question 4.1 (Regardez les modulo obtenu pour tous les mots possibles, pour une erreur et deux erreurs simultanées) avec P2. Qu’observez vous? Qu’est ce que P2 offre en plus comparé à P ?*
\ No newline at end of file
-- 
GitLab