simulation séparé du main

Code/ldpc/src/simulation.rs

@@ -0,0 +1,83 @@
+use core::panic::PanicMessage;
+use std::sync::mpsc::Receiver;
+
+use crate::channel::Channel;
+use crate::code::{self, LdpcCode};
+use crate::construction::random::{generate_random_h, generate_random_h_for_k};
+use crate::decoder::bit_flip::BitFlipDecoder;
+use crate::encoder::dense::DenseEncoder;
+use rand::{Rng, RngExt};
+
+pub fn run_simulation(k: usize, wc: usize, wr: usize, error_prob: f64) {
+    println!(
+        "Simulation LDPC : k = {} bits, wc = {}, wr = {}, p = {:.2}",
+        k, wc, wr, error_prob
+    );
+
+    println!("Construction");
+
+    let h_matrix = generate_random_h_for_k(k, wc, wr);
+    let ldpc = LdpcCode::new(h_matrix);
+
+    let encoder = DenseEncoder::new(&ldpc);
+
+    if encoder.k != k {
+        println!("Erreur: la matrice donne k = {} != {}", encoder.k, k);
+    }
+
+    println!(
+        "  -> Code généré : n = {}, k = {}, k/n = {}",
+        encoder.n,
+        encoder.k,
+        (encoder.k as f64 / encoder.n as f64)
+    );
+
+    println!("Encodage");
+
+    let mut rng = rand::rng();
+    let message: Vec<u8> = (0..k).map(|_| rng.random_range(0..2)).collect();
+
+    let codeword = encoder.encode(&message);
+
+    println!("  -> Message  u ({:02} bits) : {:?}", k, message);
+    println!("  -> Codeword s ({:02} bits) : {:?}", encoder.n, codeword);
+
+    println!("\nCanal bruité (p = {})", error_prob);
+
+    let channel = Channel::new(error_prob);
+    let received = channel.add_noise(&codeword);
+
+    let nb_errors = Channel::count_errors(&codeword, &received);
+    if nb_errors == 0 {
+        println!("   -> Aucune erreur.")
+    } else {
+        println!("  -> {} erreurs !", nb_errors);
+        println!("  -> Recu r ({:02} bits) : {:?}", received.len(), received);
+    }
+
+    println!("\n Décodage (bit-flipping)");
+
+    if nb_errors == 0 {
+        println!("  -> Pas besoin de correction");
+        return;
+    }
+
+    let decoder = BitFlipDecoder::new(&ldpc);
+    let max_iter = 50;
+
+    match decoder.decode(&received, max_iter) {
+        Some(decoded) => {
+            if decoded == codeword {
+                println!("  -> Réussite");
+            } else {
+                println!("  -> Echec : le decoder a convergé vers un mauvais codeword");
+            }
+        }
+        None => {
+            println!(
+                "  -> Echec : impossible decorriger après {} itérations",
+                max_iter
+            );
+        }
+    }
+}