c'est la merde

Code/ldpc/src/construction/random.rs

@@ -12,7 +12,9 @@ pub fn generate_random_h(rows: usize, cols: usize, wc: usize, wr: usize) -> Matr
 
         for c in 0..cols {
             let mut ones_placed = 0;
-            let mut avail_rows: Vec<usize> = (0..rows).filter(|&r| row_w[r] < wr).collect();
+            let mut avail_rows: Vec<usize> = (0..rows)
+                .filter(|&r| row_w[r] < wr && !creates_cycle_4(rows, cols, &data, r, c))
+                .collect();
 
             if avail_rows.len() < wc {
                 // Les problèmes...
@@ -60,3 +62,16 @@ pub fn generate_random_h_for_k(k: usize, wc: usize, wr: usize) -> MatrixGF2 {
     }
     best_h
 }
+
+fn creates_cycle_4(rows: usize, cols: usize, data: &[u8], row: usize, col: usize) -> bool {
+    for r2 in 0..rows {
+        if r2 != row && data[r2 * cols + col] == 1 {
+            for c2 in 0..col {
+                if data[row * cols + c2] == 1 && data[r2 * cols + c2] == 1 {
+                    return true;
+                }
+            }
+        }
+    }
+    false
+}

Code/ldpc/src/decoder/bit_flip.rs

@@ -35,6 +35,7 @@ impl<'a> BitFlipDecoder<'a> {
                 }
             }
 
+            println!("poid syndome: {s_w}");
             // Aucune erreurs
             if s_w == 0 {
                 return Some(curr_bits);
@@ -65,8 +66,21 @@ impl<'a> BitFlipDecoder<'a> {
                     curr_bits[i] ^= 1; // Bit flip
                 }
             }
+            // Seuil de 3
+            // if max_cpt >= 3 {
+            //     for i in 0..n {
+            //         if cpt[i] == max_cpt {
+            //             curr_bits[i] ^= 1;
+            //         }
+            //     }
+            // } else if max_cpt > 0 {
+            //     if let Some(idx) = cpt.iter().position(|&x| x == max_cpt) {
+            //         curr_bits[idx] ^= 1;
+            //     }
+            // } else {
+            //     break;
+            // }
         }
-
+        None
-        return Some(curr_bits);
     }
 }

Code/ldpc/src/main.rs

@@ -11,21 +11,22 @@ mod tanner;
 use analysis::{AnalysisConfig, Analyzer, DecoderAlgorithm};
 
 fn main() {
-    println!("Analyse des performences");
+    // println!("Analyse des performences");
 
-    let config = AnalysisConfig {
+    // let config = AnalysisConfig {
-        k_values: vec![50, 200, 400, 800, 1000],
+    //     k_values: vec![50, 200, 400, 800, 1000],
-        wc_values: vec![3, 4, 5],
+    //     wc_values: vec![3, 4, 5],
-        wr_values: vec![6, 8, 9, 12, 15, 16],
+    //     wr_values: vec![6, 8, 9, 12, 15, 16],
-        min_error_prob: 0.00,
+    //     min_error_prob: 0.00,
-        max_error_prob: 0.12,
+    //     max_error_prob: 0.12,
-        steps: 15,
+    //     steps: 15,
-        frames_per_step: 1000,
+    //     frames_per_step: 1000,
-        max_iter: 50,
+    //     max_iter: 50,
-        algorithm: DecoderAlgorithm::BitFlipping,
+    //     algorithm: DecoderAlgorithm::BitFlipping,
-    };
+    // };
+    //
+    // let res = Analyzer::run_batch(config);
+    // Analyzer::save_csv(&res, "ldpc_analysis_results.csv");
 
-    let res = Analyzer::run_batch(config);
+    simulation::run_simulation(300, 3, 6, 0.012);
-    Analyzer::save_csv(&res, "ldpc_analysis_results.csv");
-    // simulation::run_simulation(1000, 3, 6, 0.005);
 }

Code/ldpc/src/simulation.rs

@@ -64,7 +64,7 @@ pub fn run_simulation(k: usize, wc: usize, wr: usize, error_prob: f64) {
     }
 
     let decoder = BitFlipDecoder::new(&ldpc);
-    let max_iter = 50;
+    let max_iter = 100;
 
     match decoder.decode(&received, max_iter) {
         Some(decoded) => {