decoder bit flipping (hard decision)

Code/ldpc/src/construction/random.rs

@@ -33,3 +33,21 @@ pub fn generate_random_h(rows: usize, cols: usize, wc: usize, wr: usize) -> Matr
         }
     }
 }
+
+pub fn generate_random_h_for_k(k: usize, wc: usize, wr: usize) -> MatrixGF2 {
+    assert!(wr > wc, "wr < wc ...");
+    assert!((k * wr) % (wr - wc) == 0, "Colonnes non entieres");
+
+    let n = (k * wr) / (wr - wc);
+    let m = n - k;
+
+    // On garde que les matrice de rang m
+    loop {
+        let h_matrix = generate_random_h(m, n, wc, wr);
+        let mut h_test = h_matrix.clone();
+        let (rank, _) = h_test.gauss_jordan_swap_cols();
+        if rank == m {
+            return h_matrix;
+        }
+    }
+}

Code/ldpc/src/decoder/bit_flip.rs

@@ -9,8 +9,64 @@ impl<'a> BitFlipDecoder<'a> {
         Self { code }
     }
 
+    // TODO paraléliser (le calcul de chaque check-node)
     pub fn decode(&self, received: &[u8], max_iter: usize) -> Option<Vec<u8>> {
-        let graph = &self.code.tanner_graph;
-        unimplemented!("Algo de bit-flipp");
+        let n = self.code.n;
+        let m = self.code.h_matrix.rows;
+
+        let mut curr_bits = received.to_vec();
+
+        for iter in 0..max_iter {
+            // Syndrome s = v * H^T
+            let mut s = vec![0; m];
+            let mut s_w = 0;
+
+            for (cnid, cb) in self.code.tanner_graph.check.iter().enumerate() {
+                let mut sum = 0;
+                // Calcul des equation de parité
+                for &bid in cb {
+                    sum ^= cb[bid];
+                }
+                s[cnid] = sum;
+
+                // Equation non vérifiée
+                if sum == 1 {
+                    s_w += 1;
+                }
+            }
+
+            // Aucune erreurs
+            if s_w == 0 {
+                return Some(curr_bits);
+            }
+
+            // Calcul du nombre d'équations fausses le bit fait partie
+            let mut cpt = vec![0; n];
+            let mut max_cpt = 0;
+
+            for (cid, &sb) in s.iter().enumerate() {
+                if sb == 1 {
+                    for &bid in &self.code.tanner_graph.check[cid] {
+                        cpt[bid] += 1;
+                        if cpt[bid] > max_cpt {
+                            max_cpt = cpt[bid];
+                        }
+                    }
+                }
+            }
+
+            if max_cpt == 0 {
+                break;
+            }
+
+            // Flip des bit qui causent le plus d'équations fausses
+            for i in 0..n {
+                if cpt[i] == max_cpt {
+                    curr_bits[i] ^= 1; // Bit flip
+                }
+            }
+        }
+
+        return Some(curr_bits);
     }
 }

Code/ldpc/src/encoder/dense.rs

@@ -41,6 +41,7 @@ impl DenseEncoder {
         // 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 {

Code/ldpc/src/tanner.rs

@@ -11,14 +11,15 @@ impl TannerGraph {
         let mut check = vec![vec![]; matrix.rows];
         let mut bits = vec![vec![]; matrix.cols];
 
-        for i in 0..matrix.rows {
-            for j in 0..matrix.cols {
+        for (i, row_check) in check.iter_mut().enumerate() {
+            for (j, col_bits) in bits.iter_mut().enumerate() {
                 if matrix.get(i, j) == 0 {
-                    check[i].push(j);
-                    bits[j].push(i);
+                    row_check.push(j);
+                    col_bits.push(i);
                 }
             }
         }
+
         Self { check, bits }
     }
 }