93 lines
2.8 KiB
Rust
93 lines
2.8 KiB
Rust
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 crate::utils;
|
|
use rand::{Rng, RngExt};
|
|
|
|
pub fn run_simulation(text: &str, wc: usize, wr: usize, error_prob: f64) {
|
|
let mut message_bits = utils::string_to_bits(text);
|
|
let k = message_bits.len();
|
|
println!(
|
|
"\nSimulation LDPC : k = {} bits, wc = {}, wr = {}, p = {:.2}, text : {}",
|
|
k, wc, wr, error_prob, text
|
|
);
|
|
|
|
println!("Construction");
|
|
|
|
let h_matrix = generate_random_h_for_k(k, wc, wr);
|
|
let ldpc = LdpcCode::new(h_matrix);
|
|
|
|
let encoder = DenseEncoder::new(&ldpc);
|
|
|
|
let k = encoder.k;
|
|
// if encoder.k != k {
|
|
// println!("Erreur: la matrice donne k = {} != {}", encoder.k, k);
|
|
// }
|
|
|
|
println!(
|
|
" -> Code généré : n = {}, k = {}, k/n = {:.2}",
|
|
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 = 100;
|
|
|
|
match decoder.decode(&received, max_iter) {
|
|
Some(decoded) => {
|
|
let decoded_message = &decoded[0..encoder.k];
|
|
let res_text = utils::bits_to_string(decoded_message);
|
|
if decoded == codeword {
|
|
println!(" -> Réussite");
|
|
} else {
|
|
println!(" -> Echec : le decoder a convergé vers un mauvais codeword");
|
|
}
|
|
println!(" -> Texte recu : {}", res_text);
|
|
}
|
|
None => {
|
|
let failed_text = utils::bits_to_string(&received[0..encoder.k]);
|
|
println!(
|
|
" -> Echec : impossible decorriger après {} itérations",
|
|
max_iter
|
|
);
|
|
println!(" -> Texte recu : {}", failed_text);
|
|
}
|
|
}
|
|
}
|