note edit

Code/ldpc/src/decoder/bit_flip.rs

@@ -25,7 +25,7 @@ impl<'a> BitFlipDecoder<'a> {
                 let mut sum = 0;
                 // Calcul des equation de parité
                 for &bid in cb {
-                    sum ^= cb[bid];
+                    sum ^= curr_bits[bid];
                 }
                 s[cnid] = sum;
 

Code/ldpc/src/encoder/dense.rs

@@ -38,17 +38,6 @@ impl DenseEncoder {
 
     pub fn encode(&self, message: &[u8]) -> Vec<u8> {
         assert_eq!(message.len(), self.k, "Taille du message non valide");
-        // let mut codeword = vec![0; self.n];
-
-        // s = u * G
-
-        // for c in 0..self.n {
-        //     let mut sum = 0;
-        //     for r in 0..self.k {
-        //         sum ^= message[r] & self.g_matrix.get(r, c);
-        //     }
-        //     codeword[c] = sum;
-        // }
 
         let mut codeword: Vec<u8> = (0..self.n)
             .map(|c| {

Code/ldpc/src/main.rs

@@ -8,6 +8,7 @@ mod tanner;
 
 use code::LdpcCode;
 use construction::random::generate_random_h;
+use decoder::bit_flip::BitFlipDecoder;
 use encoder::dense::DenseEncoder;
 
 fn main() {
@@ -30,7 +31,7 @@ fn main() {
     println!("Extraction de G");
     let encoder = DenseEncoder::new(&ldpc);
 
-    println!("\n    -> Matrcie H après Gauss-Jordan avec inversion de colonne de la forme [I | A]");
+    println!("\n-> Matrcie H après Gauss-Jordan avec inversion de colonne de la forme [I | A]");
     encoder.h_reduced.print();
 
     println!("G {}x{}", encoder.k, encoder.n);
@@ -40,19 +41,7 @@ fn main() {
     let codeword = encoder.encode(&message);
 
     println!("\nMessage u : {:?}", message);
-    println!("\n Codeword s : {:?}", codeword);
+    println!("\nCodeword s : {:?}", codeword);
-
-    // let mut is_valid = true;
-    // for r in 0..m {
-    //     let mut sum = 0;
-    //     for c in 0..n {
-    //         sum ^= codeword[c] & h_matrix.get(r, c);
-    //     }
-    //     if sum != 0 {
-    //         is_valid = false;
-    //         break;
-    //     }
-    // }
 
     let is_valid = (0..m).all(|r| {
         let sum = codeword
@@ -64,7 +53,22 @@ fn main() {
 
     println!("\n{}", if is_valid { "Vrai" } else { "Faux" });
 
-    // println!("\nGauss-Jordan sur H :");
+    println!("\nCorrection (bit-flipping)");
-    // h_matrix.gauss_jordan();
+
-    // h_matrix.print();
+    let decoder = BitFlipDecoder::new(&ldpc);
+    let max_iter = 50;
+    let receiver_codeword = codeword.clone();
+
+    match decoder.decode(&receiver_codeword, max_iter) {
+        Some(corrected_codeword) => {
+            if corrected_codeword == codeword {
+                println!("Code reconstrui");
+            } else {
+                println!("Convergence mais mauvais codeword")
+            }
+            println!("Message original : {:?}", codeword);
+            println!("Message original : {:?}", corrected_codeword);
+        }
+        None => println!("Pas de convergence..."),
+    }
 }