avancée+
This commit is contained in:
363
<
Normal file
363
<
Normal file
@ -0,0 +1,363 @@
|
||||
#import "composants.typ": *
|
||||
|
||||
#set page(
|
||||
paper: "presentation-4-3",
|
||||
margin: 0cm,
|
||||
)
|
||||
|
||||
// Font
|
||||
#set text(
|
||||
font: "New Computer Modern",
|
||||
size: 20pt,
|
||||
fill: black,
|
||||
)
|
||||
#set math.mat(delim: "[")
|
||||
|
||||
// Page de garde
|
||||
#slide[
|
||||
#place(center + horizon)[
|
||||
#graphe_tanner_fond(1cm, 1.5)
|
||||
]
|
||||
#v(1fr)
|
||||
#align(center + horizon)[
|
||||
#pad(x: 2cm)[
|
||||
#text(size: 3em, weight: "bold", fill: black)[#titre]
|
||||
|
||||
#text(size: 1.2em, weight: "bold", fill: black)[#auteur]
|
||||
|
||||
#h(0.5em)
|
||||
|
||||
#text(size: 1.2em, fill: black)[n°#numero]
|
||||
|
||||
#text(size: 0.95em, fill: black)[#annee]
|
||||
]
|
||||
]
|
||||
#v(1fr)
|
||||
]
|
||||
|
||||
#myslide("Plan")[
|
||||
#design_plan((
|
||||
[Introduction],
|
||||
[Codes linéaires],
|
||||
[LDPC],
|
||||
[Codage],
|
||||
[Décodage],
|
||||
[Analyse],
|
||||
))
|
||||
]
|
||||
|
||||
#myslide("Introduction : Communication Numérique")[
|
||||
#place(center + horizon)[
|
||||
#canal_shannon_intro()
|
||||
]
|
||||
]
|
||||
|
||||
#myslide("Introduction : Utilisation")[
|
||||
#align(center + horizon)[
|
||||
#grid(
|
||||
columns: (1.5fr, 1.5fr),
|
||||
gutter: 1.5cm,
|
||||
align: center + horizon,
|
||||
[
|
||||
#box(width: 80%)[
|
||||
#stack(
|
||||
dir: ttb,
|
||||
spacing: -0.5em,
|
||||
image("src/athena_fidus_no_text.jpg", width: 100%),
|
||||
align(left)[
|
||||
#box(
|
||||
inset: (x: 5pt, y: 0pt),
|
||||
text(size: 0.45em, fill: white)[* https://gallery.ariane.group *],
|
||||
)
|
||||
],
|
||||
)
|
||||
]
|
||||
#v(0.5em)
|
||||
Athena-Fidus
|
||||
],
|
||||
[
|
||||
#box(width: 80%)[
|
||||
#stack(
|
||||
dir: ttb,
|
||||
spacing: -0.5em,
|
||||
image("src/runcamfpv2.png", width: 100%),
|
||||
align(left)[
|
||||
#box(
|
||||
inset: (x: 5pt, y: 0pt),
|
||||
text(size: 0.45em, fill: white)[* https://www.runcam.com/ *],
|
||||
)
|
||||
],
|
||||
)
|
||||
]
|
||||
#v(0.5em)
|
||||
Module OpenIPC
|
||||
],
|
||||
)
|
||||
]
|
||||
]
|
||||
|
||||
#myslide("Problématique")[
|
||||
#place(center + horizon, dy: 8.1cm)[#graphe_tanner_fond(0.9cm, 1.75)]
|
||||
#place(center + horizon, dy: 7.7cm)[
|
||||
#block(width: 100%)[
|
||||
#text(size: 1.2em, weight: "bold", fill: black)[
|
||||
Comment utiliser les codes LDPC pour garantir la fiabilité d'une transmission en présence de bruit ?
|
||||
]
|
||||
]
|
||||
]
|
||||
]
|
||||
|
||||
#myslide("Définition : Codes Linéaires en Bloc")[
|
||||
#definition(titre: [Code $display((n,k) in NN^2)$])[
|
||||
$cal(C)$ sous-espace vectoriel de dimension $k$ de $FF_2^n$
|
||||
]
|
||||
|
||||
#[
|
||||
#set text(size: 1.1em)
|
||||
- $k$ : longueur du message original
|
||||
- $n$ : longueur du mot de code
|
||||
- $m = n - k$ : nombre de bits de parités
|
||||
]
|
||||
|
||||
#definition(titre: "Encodage")[
|
||||
$Phi : FF_2^k & -> FF_2^n in cal(L)(FF_2^k, FF_2^n)$
|
||||
]
|
||||
|
||||
#v(-1.3em)
|
||||
|
||||
#uncover(2)[
|
||||
#align(center + horizon)[
|
||||
#plongement_schema()
|
||||
]
|
||||
]
|
||||
]
|
||||
|
||||
#myslide("Définition : Matrice Génératrice")[
|
||||
#definition(titre: "Matrice Génératrice")[
|
||||
$G in cal(M)_(k,n)(FF_2)$ dont les lignes sont une base de $cal(C)$
|
||||
]
|
||||
|
||||
#definition(titre: "Encodage")[
|
||||
Pour un message $u in FF_2^k$ le mot de code $c in cal(C)$ est :
|
||||
$
|
||||
c = Phi(u) = u dot.o G
|
||||
$
|
||||
]
|
||||
|
||||
#definition(titre: "Forme systématique")[
|
||||
$
|
||||
G = mat(
|
||||
I_k, P;
|
||||
augment: #1,
|
||||
delim: "[",
|
||||
)
|
||||
$
|
||||
]
|
||||
|
||||
#[
|
||||
#set text(size: 1.2em)
|
||||
- Pour $u in FF_2^k, space display(u dot.o G = mat(u, u dot.o P; augment: #1, delim: "[",))$
|
||||
|
||||
- $P in cal(M)_(k ,(n-k))(FF_2)$ matrice de parité\
|
||||
]
|
||||
]
|
||||
|
||||
#myslide("Définition : Matrice de Contrôle")[
|
||||
#definition(titre: "Matrice de Contrôle")[
|
||||
$
|
||||
H = mat(
|
||||
P^top, I_(n-k);
|
||||
augment: #1,
|
||||
delim: "[",
|
||||
)
|
||||
$
|
||||
]
|
||||
#[
|
||||
#set text(size: 1.2em)
|
||||
- $cal(C) = ker(H) = {v in FF_2^n | H dot.o v^top = 0}$
|
||||
|
||||
- $display(G dot.o H^top = 0)$
|
||||
]
|
||||
|
||||
#definition(titre: "Syndrome")[
|
||||
Pour un vecteur reçu $r = c + e, space s in FF_2^(n - k)$
|
||||
$
|
||||
s = H r^top = H c^top + H e^top = 0 + H e^top
|
||||
$
|
||||
]
|
||||
#[
|
||||
#set text(size: 1.2em)
|
||||
- Si $s = 0, space r$ est un mot de code valide
|
||||
- Sinon s donne la signature de l'erreur $e$
|
||||
]
|
||||
// Possible décodage par syndrome
|
||||
]
|
||||
|
||||
#myslide("Exemple d'un code linéaire")[
|
||||
#[
|
||||
#set text(size: 1.1em)
|
||||
#let col-u = blue
|
||||
#let col-p = orange
|
||||
|
||||
|
||||
#underline(offset: 3pt)[Exemple d'un code $(5,2)$]
|
||||
|
||||
|
||||
- On choisit la matrice de parité $P$ :
|
||||
$
|
||||
P = #math.mat(
|
||||
(text(fill: col-p)[1], text(fill: col-p)[1], text(fill: col-p)[0]),
|
||||
(text(fill: col-p)[0], text(fill: col-p)[1], text(fill: col-p)[1]),
|
||||
)
|
||||
$
|
||||
|
||||
- Alors la matrice génératrice $G$ est :
|
||||
$
|
||||
G = #math.mat(
|
||||
(text(fill: col-u)[1], text(fill: col-u)[0], text(fill: col-p)[1], text(fill: col-p)[1], text(fill: col-p)[0]),
|
||||
(text(fill: col-u)[0], text(fill: col-u)[1], text(fill: col-p)[0], text(fill: col-p)[1], text(fill: col-p)[1]),
|
||||
augment: 2,
|
||||
)
|
||||
$
|
||||
|
||||
- Message $display(u = #math.mat((text(fill: col-u)[1], text(fill: col-u)[1])))$
|
||||
|
||||
- Mot de code $c = u G$ :
|
||||
$
|
||||
c = #math.mat((text(fill: col-u)[1], text(fill: col-u)[1]))
|
||||
#math.mat(
|
||||
(text(fill: col-u)[1], text(fill: col-u)[0], text(fill: col-p)[1], text(fill: col-p)[1], text(fill: col-p)[0]),
|
||||
(text(fill: col-u)[0], text(fill: col-u)[1], text(fill: col-p)[0], text(fill: col-p)[1], text(fill: col-p)[1]),
|
||||
augment: 2,
|
||||
)
|
||||
=
|
||||
#math.mat((
|
||||
text(fill: col-u)[1],
|
||||
text(fill: col-u)[1],
|
||||
text(fill: col-p)[1],
|
||||
text(fill: col-p)[0],
|
||||
text(fill: col-p)[1],
|
||||
))
|
||||
$
|
||||
]
|
||||
]
|
||||
|
||||
#myslide("Exemple d'une code linéaire")[
|
||||
#[
|
||||
#set math.mat(delim: "[")
|
||||
#let colu = blue
|
||||
#let colp = orange
|
||||
|
||||
#v(0.5em)
|
||||
|
||||
#set text(size: 1.1em)
|
||||
Enfin
|
||||
|
||||
$
|
||||
H = #math.mat(
|
||||
(text(fill: colp)[1], text(fill: colp)[0], 1, 0, 0),
|
||||
(text(fill: colp)[1], text(fill: colp)[1], 0, 1, 0),
|
||||
(text(fill: colp)[0], text(fill: colp)[1], 0, 0, 1),
|
||||
augment: 2,
|
||||
)
|
||||
$
|
||||
|
||||
#v(0.8em)
|
||||
|
||||
Vérification du mot de code $display(c = mat(#text(fill: colu)[1], #text(fill: colu)[1], #text(fill: colp)[1], #text(fill: colp)[0], #text(fill: colp)[1]))$
|
||||
|
||||
#v(0.8em)
|
||||
|
||||
$
|
||||
H c^top = mat(
|
||||
1, 0, 1, 0, 0;
|
||||
1, 1, 0, 1, 0;
|
||||
0, 1, 0, 0, 1
|
||||
) mat(#text(fill: colu)[1], #text(fill: colu)[1], #text(fill: colp)[1], #text(fill: colp)[0], #text(fill: colp)[1])^top
|
||||
= mat(
|
||||
1 plus.o 0 plus.o 1 plus.o 0 plus.o 0;
|
||||
1 plus.o 1 plus.o 0 plus.o 0 plus.o 0;
|
||||
0 plus.o 1 plus.o 0 plus.o 0 plus.o 1
|
||||
)
|
||||
= mat(0; 0; 0)
|
||||
$
|
||||
]
|
||||
]
|
||||
|
||||
// A REMPLACER AVEC DE VRAI DONNE SUR DE VRAI CODE LDPC ET HAMMING PAR EXEMPLE
|
||||
#myslide("Approcher la Limite de Shannon")[
|
||||
#limite_shannon_graphique()
|
||||
|
||||
]
|
||||
|
||||
// #myslide("Redondance et limite théorique")[
|
||||
// Graphique waterfall avec n = 100 et n = 64800 avec limite de Shannon, $display(R = k /n) < 1$, $m = n - k$
|
||||
//
|
||||
// Bande passante...
|
||||
//
|
||||
// Il existe $C$ pour un canal tel que pour $R < C$ on peut atteindre une probabilité d'erreur nulle.
|
||||
// $=>$ gros bloc (moyenne du bruit aléatoire)
|
||||
// ]
|
||||
|
||||
#myslide("Décodage par Maximum de Vraisemblance")[
|
||||
Trouver le message envoyer le + probable sachant le message recu : NP-COMPLET (Max)
|
||||
Decodage par syndrome d'une code lin'aire général est NP-Complet
|
||||
Complexité $O(2^k)$
|
||||
]
|
||||
|
||||
#myslide("LDPC")[
|
||||
Matrice $H$ clairsemée(low density) donc complexité mointre, pas de produit de matrice mais algorithme itératif efficace quasi linéaire
|
||||
Graphique d'un H très grand clairesemée avec plein de 0, généré en rust par exemple où les 1 sont des points noir et le reste du blanc
|
||||
Défniition avec (w_r,w_c)
|
||||
]
|
||||
|
||||
#myslide("Graphe de Tanner")[
|
||||
Il existe un isomorphisme entre H et le Graphe de Tanner
|
||||
Graphe de tanner (cetz)
|
||||
Contrainte de somme nulle
|
||||
]
|
||||
|
||||
#myslide("Encodage")[
|
||||
]
|
||||
|
||||
#myslide("Décodage")[
|
||||
Canal d'étude (AWGN) analogique, tension etc, ce qui se passe en radio dans les cables etc
|
||||
]
|
||||
|
||||
#myslide("Hard decoding")[
|
||||
Nul (0 ou 1)
|
||||
transition perte d'information
|
||||
]
|
||||
|
||||
#myslide("Implementation")[
|
||||
|
||||
]
|
||||
|
||||
#myslide("Soft decoding")[
|
||||
belief propagation, log ou virgule fixe, explication resultat meilleur
|
||||
]
|
||||
|
||||
#myslide("Implementation")[
|
||||
|
||||
]
|
||||
|
||||
#myslide("Test")[
|
||||
Irl hackrf, test de diff de debit avec des paquets
|
||||
]
|
||||
|
||||
#myslide("Image")[
|
||||
Test de transmission d'image avec différent ldpc non opti et opti (le H)
|
||||
]
|
||||
|
||||
#myslide("Annexe")[
|
||||
#align(center + horizon)[
|
||||
Annexe
|
||||
]
|
||||
#align(center + horizon)[
|
||||
#image("src/construction.jpg", width: 80%)
|
||||
]
|
||||
]
|
||||
|
||||
#myslide("Théorie deriere la définition des codes linaires")[
|
||||
Poser les notations algebriques etc...
|
||||
]
|
||||
327
composants.typ
327
composants.typ
@ -174,44 +174,117 @@
|
||||
}
|
||||
|
||||
// Schema Shannon
|
||||
// #let canal_shannon_intro() = {
|
||||
// cetz.canvas({
|
||||
// import cetz.draw: *
|
||||
//
|
||||
// // Styles
|
||||
// let s = (stroke: 2pt + black)
|
||||
// let s_fleche = (stroke: 2pt + black)
|
||||
// let pointe_pleine = (end: "stealth", fill: black)
|
||||
//
|
||||
// let espacement = 5.5
|
||||
//
|
||||
// // Blocs
|
||||
// content((0, 0), [Source], name: "src", frame: "rect", ..s, padding: .3)
|
||||
// content((espacement, 0), [Emetteur], name: "em", frame: "rect", ..s, padding: .3)
|
||||
// content((espacement * 2, 0), [Canal], name: "chan", frame: "rect", ..s, padding: .3)
|
||||
// content((espacement * 3, 0), [Récepteur], name: "rec", frame: "rect", ..s, padding: .3)
|
||||
// content((espacement * 4, 0), [Destinataire], name: "dest", frame: "rect", ..s, padding: .3)
|
||||
//
|
||||
// // Bruit
|
||||
// content((rel: (0, 1.8), to: "chan"), [Bruit], name: "bruit", frame: "rect", ..s, padding: .3)
|
||||
//
|
||||
// // Codage / Décodage
|
||||
// content((rel: (0, 1), to: "em"), [*Codage*])
|
||||
// content((rel: (0, 1), to: "rec"), [*Décodage*])
|
||||
//
|
||||
// // Flèches (On utilise s_fleche et pointe_pleine)
|
||||
// line("src.east", "em.west", mark: pointe_pleine, ..s_fleche)
|
||||
// line("em.east", "chan.west", mark: pointe_pleine, ..s_fleche)
|
||||
// line("chan.east", "rec.west", mark: pointe_pleine, ..s_fleche)
|
||||
// line("rec.east", "dest.west", mark: pointe_pleine, ..s_fleche)
|
||||
// line("bruit.south", "chan.north", mark: pointe_pleine, ..s_fleche)
|
||||
//
|
||||
// // Annotation
|
||||
// let note-style = (size: 0.75em, style: "italic")
|
||||
// content((espacement * 0.5, -0.5), text(..note-style)[Message])
|
||||
// content((espacement * 1.5, -0.5), text(..note-style)[Signal])
|
||||
// content((espacement * 2.5, -0.5), text(..note-style)[Signal])
|
||||
// content((espacement * 3.5, -0.5), text(..note-style)[Message])
|
||||
// })
|
||||
// }
|
||||
|
||||
#let canal_shannon_intro() = {
|
||||
cetz.canvas({
|
||||
// Couleurs
|
||||
let col-u = blue // Signal propre
|
||||
let col-p = orange // Signal bruité
|
||||
let C_MAIN = black
|
||||
let C_BG = rgb("#f8f9fa") // Le gris très clair demandé
|
||||
let C_LABEL = black
|
||||
|
||||
cetz.canvas(length: 1cm, {
|
||||
import cetz.draw: *
|
||||
|
||||
// Styles
|
||||
let s = (stroke: 2pt + black)
|
||||
let s_fleche = (stroke: 2pt + black)
|
||||
let pointe_pleine = (end: "stealth", fill: black)
|
||||
let x_left = 4.0 ; let x_right = 16.0 ; let x_noise = 22.5
|
||||
let y_top = 14.5 ; let y_mid = 9.0 ; let y_bot = 3.5
|
||||
|
||||
let espacement = 5.5
|
||||
// Style des lignes avec flèches
|
||||
let s_ligne = (stroke: 1.5pt + C_MAIN, mark: (end: "stealth", fill: C_MAIN, size: 0.25))
|
||||
let s_bruit_fleche = (stroke: (paint: black, thickness: 1.5pt, dash: "dashed"), mark: (end: "stealth", fill: black, size: 0.25))
|
||||
|
||||
// Blocs
|
||||
content((0, 0), [Source], name: "src", frame: "rect", ..s, padding: .3)
|
||||
content((espacement, 0), [Emetteur], name: "em", frame: "rect", ..s, padding: .3)
|
||||
content((espacement * 2, 0), [Canal], name: "chan", frame: "rect", ..s, padding: .3)
|
||||
content((espacement * 3, 0), [Récepteur], name: "rec", frame: "rect", ..s, padding: .3)
|
||||
content((espacement * 4, 0), [Destinataire], name: "dest", frame: "rect", ..s, padding: .3)
|
||||
// Fonction de bloc avec le nouveau fond
|
||||
let bloc(pos, txt, stxt, n) = {
|
||||
content(pos, [#set align(center); #text(C_MAIN, weight: "bold", size: 1.2em)[#txt] \ #text(C_MAIN, size: 0.85em, style: "italic")[#stxt]],
|
||||
frame: "rect", fill: C_BG, stroke: C_MAIN + 1.5pt, padding: 0.7, radius: 0.3, name: n)
|
||||
}
|
||||
|
||||
// Bruit
|
||||
content((rel: (0, 1.8), to: "chan"), [Bruit], name: "bruit", frame: "rect", ..s, padding: .3)
|
||||
// --- ONDES (Bruit dosé : "tremblement" au lieu de "chaos") ---
|
||||
let wave_vert(x, y_start, y_end, is_noisy) = {
|
||||
let n_points = 200
|
||||
let color = if is_noisy { col-p } else { col-u }
|
||||
|
||||
// Codage / Décodage
|
||||
content((rel: (0, 1), to: "em"), [*Codage*])
|
||||
content((rel: (0, 1), to: "rec"), [*Décodage*])
|
||||
line(..range(n_points + 1).map(i => {
|
||||
let t = i / n_points
|
||||
let y = y_start + t * (y_end - y_start)
|
||||
|
||||
// Flèches (On utilise s_fleche et pointe_pleine)
|
||||
line("src.east", "em.west", mark: pointe_pleine, ..s_fleche)
|
||||
line("em.east", "chan.west", mark: pointe_pleine, ..s_fleche)
|
||||
line("chan.east", "rec.west", mark: pointe_pleine, ..s_fleche)
|
||||
line("rec.east", "dest.west", mark: pointe_pleine, ..s_fleche)
|
||||
line("bruit.south", "chan.north", mark: pointe_pleine, ..s_fleche)
|
||||
// Enveloppe pour raccord propre
|
||||
let env = if t < 0.05 { t/0.05 } else if t > 0.95 { (1-t)/0.05 } else { 1.0 }
|
||||
|
||||
// Annotation
|
||||
let note-style = (size: 0.75em, style: "italic")
|
||||
content((espacement * 0.5, -0.5), text(..note-style)[Message])
|
||||
content((espacement * 1.5, -0.5), text(..note-style)[Signal])
|
||||
content((espacement * 2.5, -0.5), text(..note-style)[Signal])
|
||||
content((espacement * 3.5, -0.5), text(..note-style)[Message])
|
||||
let signal = 0.35 * calc.sin(t * 6 * calc.pi)
|
||||
|
||||
// Bruit dosé : on a baissé les fréquences et l'amplitude
|
||||
let bruit = if is_noisy {
|
||||
(0.08 * calc.sin(t * 45 * calc.pi) + 0.05 * calc.cos(t * 97 * calc.pi))
|
||||
} else { 0 }
|
||||
|
||||
(x + (signal + bruit) * env, y)
|
||||
}), stroke: color + 1.6pt)
|
||||
}
|
||||
|
||||
wave_vert(x_right, y_top - 1.5, y_mid + 1, false) // Bleu
|
||||
wave_vert(x_right, y_mid - 1, y_bot + 1.5, true) // Orange
|
||||
|
||||
// --- BLOCS ---
|
||||
bloc((x_left, y_top), "Source", "Information", "src")
|
||||
bloc((x_right, y_top), "Émetteur", "Codage", "em")
|
||||
bloc((x_right, y_mid), "Canal", "", "canal")
|
||||
bloc((x_noise, y_mid), "Bruit", "", "bruit")
|
||||
bloc((x_right, y_bot), "Récepteur", "Décodage", "rec")
|
||||
bloc((x_left, y_bot), "Destinataire", "Information", "dest")
|
||||
|
||||
// --- CONNEXIONS ---
|
||||
line("src.east", "em.west", ..s_ligne)
|
||||
line("bruit.west", "canal.east", ..s_bruit_fleche)
|
||||
line("rec.west", "dest.east", ..s_ligne)
|
||||
|
||||
// --- ANNOTATIONS ---
|
||||
let lab(pos, body, color: C_LABEL, anchor: "center") = content(pos, text(size: 0.95em, fill: color, style: "italic", weight: "medium")[#body], anchor: anchor)
|
||||
|
||||
lab(((x_left + x_right)/2 - 0.3, y_top + 0.7), "Message")
|
||||
lab((x_right + 1.2, (y_top + y_mid)/2), "Signal", color: col-u, anchor: "west")
|
||||
lab((x_right + 1.2, (y_mid + y_bot)/2), "Signal + Bruit", color: col-p, anchor: "west")
|
||||
lab(((x_left + x_right)/2 + 0.3, y_bot - 0.7), "Message reçu")
|
||||
})
|
||||
}
|
||||
|
||||
@ -500,3 +573,199 @@
|
||||
]
|
||||
}
|
||||
|
||||
#let decor_matrice_etoilee() = {
|
||||
// Ajuste length (ex: 0.6mm ou 0.7mm) selon ta diapo
|
||||
cetz.canvas(length: 0.7mm, {
|
||||
import cetz.draw: *
|
||||
|
||||
// --- 1. Paramètres de la Matrice ---
|
||||
let nx = 430
|
||||
let ny = 265
|
||||
|
||||
// --- 2. Paramètres de la Loupe ---
|
||||
let loupe_x = nx * 0.70
|
||||
let loupe_y = -ny / 2.0
|
||||
let R = 50.0
|
||||
let zoom = 3.0
|
||||
|
||||
// --- 3. Paramètre d'Estompage (Gauche uniquement) ---
|
||||
let fade_left = 220.0
|
||||
|
||||
// Palette de couleurs
|
||||
let col_focus = rgb("#0284c7")
|
||||
let col_fade = rgb("#64748b")
|
||||
let col_grid = rgb("#e2e8f0")
|
||||
|
||||
// --- Fonction pseudo-aléatoire ---
|
||||
let pseudo_rand(x, y) = {
|
||||
let v = x * 7919 + y * 104729 + (x * x) * 313 + (y * y) * 991 + (x * y) * 101
|
||||
calc.rem(calc.abs(v), 100)
|
||||
}
|
||||
|
||||
// --- ÉTAPE A : Dessin de la matrice (Fade à gauche uniquement) ---
|
||||
for x in range(nx) {
|
||||
for y in range(ny) {
|
||||
let hash = pseudo_rand(x, y)
|
||||
let is_active = hash < 12
|
||||
|
||||
if is_active {
|
||||
// L'intensité ne dépend plus que de la position X
|
||||
let intensity = calc.min(1.0, x / fade_left)
|
||||
|
||||
if intensity > 0.05 {
|
||||
let radius = 0.20 + 0.15 * intensity
|
||||
let c = col_fade.lighten((1.0 - intensity) * 80%)
|
||||
circle((x, -y), radius: radius, fill: c, stroke: none)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// --- ÉTAPE B : Dessin de la Loupe ---
|
||||
circle((loupe_x, loupe_y), radius: R, fill: white, stroke: none)
|
||||
|
||||
// Grille zoomée
|
||||
let limit = 20
|
||||
for k in range(-limit, limit + 1) {
|
||||
let offset = k * zoom
|
||||
if calc.abs(offset) < R {
|
||||
let half_chord = calc.sqrt(R * R - offset * offset)
|
||||
line((loupe_x + offset, loupe_y + half_chord), (loupe_x + offset, loupe_y - half_chord), stroke: 0.5pt + col_grid)
|
||||
line((loupe_x - half_chord, loupe_y + offset), (loupe_x + half_chord, loupe_y + offset), stroke: 0.5pt + col_grid)
|
||||
}
|
||||
}
|
||||
|
||||
// Points zoomés
|
||||
let search_r = int(R / zoom) + 2
|
||||
let lx_int = int(loupe_x)
|
||||
let ly_idx = int(-loupe_y)
|
||||
|
||||
for x in range(lx_int - search_r, lx_int + search_r + 1) {
|
||||
for y in range(ly_idx - search_r, ly_idx + search_r + 1) {
|
||||
let hash = pseudo_rand(x, y)
|
||||
if hash < 12 {
|
||||
let dx = x - loupe_x
|
||||
let dy = -y - loupe_y
|
||||
let d_orig = calc.sqrt(dx * dx + dy * dy)
|
||||
let d_zoom = d_orig * zoom
|
||||
|
||||
if d_zoom <= R - 1.2 {
|
||||
circle((loupe_x + dx * zoom, loupe_y + dy * zoom), radius: 1.1, fill: col_focus, stroke: none)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Bordures de la Loupe
|
||||
circle((loupe_x, loupe_y), radius: R, stroke: 1.8pt + col_focus.lighten(20%))
|
||||
circle((loupe_x, loupe_y), radius: R + 1.5, stroke: 1.0pt + col_focus.lighten(50%))
|
||||
circle((loupe_x, loupe_y), radius: R + 3.5, stroke: 0.5pt + col_focus.lighten(80%))
|
||||
})
|
||||
}
|
||||
|
||||
#let hldpc() = {
|
||||
import cetz.draw: *
|
||||
|
||||
let points = (
|
||||
(7,0), (10,0), (15,0), (22,0), (24,0), (29,0), (3,1), (6,1), (18,1), (19,1), (25,1), (27,1),
|
||||
(5,2), (9,2), (13,2), (14,2), (17,2), (28,2), (0,3), (8,3), (11,3), (16,3), (20,3), (26,3),
|
||||
(1,4), (2,4), (4,4), (12,4), (21,4), (23,4), (5,5), (6,5), (8,5), (10,5), (21,5), (29,5),
|
||||
(14,6), (15,6), (16,6), (18,6), (22,6), (28,6), (0,7), (1,7), (4,7), (9,7), (20,7), (26,7),
|
||||
(2,8), (3,8), (11,8), (12,8), (17,8), (19,8), (7,9), (13,9), (23,9), (24,9), (25,9), (27,9),
|
||||
(0,10), (6,10), (15,10), (18,10), (21,10), (26,10), (2,11), (7,11), (10,11), (17,11), (22,11), (27,11),
|
||||
(8,12), (11,12), (14,12), (20,12), (23,12), (29,12), (4,13), (5,13), (9,13), (13,13), (16,13), (19,13),
|
||||
(1,14), (3,14), (12,14), (24,14), (25,14), (28,14)
|
||||
)
|
||||
|
||||
cetz.canvas(length: 0.45cm, {
|
||||
let nx = 30
|
||||
let ny = 15
|
||||
let cell_size = 1.0
|
||||
let h_width = nx * cell_size
|
||||
let h_height = ny * cell_size
|
||||
|
||||
// Palette unifiée
|
||||
let color_blue = blue
|
||||
let color_orange = orange
|
||||
let col_dot_base = gray.darken(30%)
|
||||
|
||||
// Définition des couleurs de fond (lighten)
|
||||
let col_row_bg = color_blue.lighten(90%)
|
||||
let col_col_bg = color_orange.lighten(90%)
|
||||
// Calcul du mélange pour l'intersection
|
||||
let col_mix_bg = col_row_bg.mix(col_col_bg)
|
||||
|
||||
// Label "H ="
|
||||
content((-3.4, -h_height / 2), text(size: 1.6em, weight: "bold")[$bold(H) = $])
|
||||
|
||||
// Sélection visuelle (Focus)
|
||||
let sel_row = 7
|
||||
let sel_col = 10
|
||||
|
||||
// Rectangles de fond
|
||||
rect((0, -sel_row), (h_width, -sel_row - 1), fill: col_row_bg, stroke: none)
|
||||
rect((sel_col, 0), (sel_col + 1, -h_height), fill: col_col_bg, stroke: none)
|
||||
rect((sel_col, -sel_row), (sel_col + 1, -sel_row - 1), fill: col_mix_bg, stroke: none)
|
||||
|
||||
// Grands crochets matriciels
|
||||
let b_w = 0.6
|
||||
set-style(stroke: (thickness: 1.5pt, cap: "round"))
|
||||
line((b_w, 0.3), (0, 0.3), (0, -h_height - 0.3), (b_w, -h_height - 0.3))
|
||||
line((h_width - b_w, 0.3), (h_width, 0.3), (h_width, -h_height - 0.3), (h_width - b_w, -h_height - 0.3))
|
||||
|
||||
// Dessin des points
|
||||
for (x, y) in points {
|
||||
let px = x + 0.5
|
||||
let py = -y - 0.5
|
||||
|
||||
let is_row = (y == sel_row)
|
||||
let is_col = (x == sel_col)
|
||||
|
||||
let d_col = col_dot_base
|
||||
let r = 0.16
|
||||
|
||||
if is_row {
|
||||
d_col = color_blue
|
||||
r = 0.24
|
||||
} else if is_col {
|
||||
d_col = color_orange
|
||||
r = 0.24
|
||||
}
|
||||
|
||||
circle((px, py), radius: r, fill: d_col, stroke: none)
|
||||
}
|
||||
|
||||
// 5. Légendes w_r et w_c
|
||||
content((h_width + 0.5, -sel_row - 0.5), anchor: "west", text(fill: color_blue, weight: "bold", size: 1.1em)[$w_r = 6$])
|
||||
content((sel_col + 0.5, 0.8), anchor: "south", text(fill: color_orange, weight: "bold", size: 1.1em)[$w_c = 3$])
|
||||
})
|
||||
}
|
||||
|
||||
#let hldpc_dual(row1: 0, row2: 14) = {
|
||||
import cetz.draw: *
|
||||
let points = ((7,0), (10,0), (15,0), (22,0), (24,0), (29,0), (3,1), (6,1), (18,1), (19,1), (25,1), (27,1), (5,2), (9,2), (13,2), (14,2), (17,2), (28,2), (0,3), (8,3), (11,3), (16,3), (20,3), (26,3), (1,4), (2,4), (4,4), (12,4), (21,4), (23,4), (5,5), (6,5), (8,5), (10,5), (21,5), (29,5), (14,6), (15,6), (16,6), (18,6), (22,6), (28,6), (0,7), (1,7), (4,7), (9,7), (20,7), (26,7), (2,8), (3,8), (11,8), (12,8), (17,8), (19,8), (7,9), (13,9), (23,9), (24,9), (25,9), (27,9), (0,10), (6,10), (15,10), (18,10), (21,10), (26,10), (2,11), (7,11), (10,11), (17,11), (22,11), (27,11), (8,12), (11,12), (14,12), (20,12), (23,12), (29,12), (4,13), (5,13), (9,13), (13,13), (16,13), (19,13), (1,14), (3,14), (12,14), (24,14), (25,14), (28,14))
|
||||
|
||||
cetz.canvas(length: 0.35cm, {
|
||||
let nx = 30; let ny = 15
|
||||
let col_1 = orange; let col_2 = blue
|
||||
|
||||
content((-3.4, -7.5), text(size: 1.6em )[$H = $])
|
||||
|
||||
// Fonds de lignes
|
||||
rect((0, -row1), (nx, -row1 - 1), fill: col_1.lighten(90%), stroke: none)
|
||||
if row2 != none { rect((0, -row2), (nx, -row2 - 1), fill: col_2.lighten(90%), stroke: none) }
|
||||
|
||||
// Crochets
|
||||
set-style(stroke: (thickness: 1.2pt))
|
||||
line((0.5, 0.3), (0, 0.3), (0, -ny - 0.3), (0.5, -ny - 0.3))
|
||||
line((nx - 0.5, 0.3), (nx, 0.3), (nx, -ny - 0.3), (nx - 0.5, -ny - 0.3))
|
||||
|
||||
for (x, y) in points {
|
||||
let d_col = gray.darken(30%)
|
||||
let r = 0.15
|
||||
if y == row1 { d_col = col_1; r = 0.22 }
|
||||
else if y == row2 { d_col = col_2; r = 0.22 }
|
||||
circle((x + 0.5, -y - 0.5), radius: r, fill: d_col, stroke: none)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
177
main.typ
177
main.typ
@ -36,18 +36,19 @@
|
||||
]
|
||||
|
||||
#myslide("Plan")[
|
||||
#design_plan((
|
||||
[Introduction],
|
||||
[Codes linéaires],
|
||||
[LDPC],
|
||||
[Codage],
|
||||
[Décodage],
|
||||
[Analyse],
|
||||
))
|
||||
#grid(
|
||||
columns: (auto, 1fr),
|
||||
align: horizon,
|
||||
place(center + horizon, dx: 11.8cm, dy: 0.7cm)[#decor_matrice_etoilee()],
|
||||
design_plan((
|
||||
[Introduction], [Codes linéaires], [LDPC],
|
||||
[Codage], [Décodage], [Analyse],
|
||||
))
|
||||
)
|
||||
]
|
||||
|
||||
#myslide("Introduction : Transmission Numérique")[
|
||||
#align(center + horizon)[
|
||||
#myslide("Introduction : Communication Numérique")[
|
||||
#place(center + horizon, dy: 8cm)[
|
||||
#canal_shannon_intro()
|
||||
]
|
||||
]
|
||||
@ -132,7 +133,7 @@
|
||||
]
|
||||
]
|
||||
|
||||
#myslide("Définition: Matrice Génératrice")[
|
||||
#myslide("Définition : Matrice Génératrice")[
|
||||
#definition(titre: "Matrice Génératrice")[
|
||||
$G in cal(M)_(k,n)(FF_2)$ dont les lignes sont une base de $cal(C)$
|
||||
]
|
||||
@ -162,7 +163,7 @@
|
||||
]
|
||||
]
|
||||
|
||||
#myslide("Défniition: Matrice de Contrôle")[
|
||||
#myslide("Définition : Matrice de Contrôle")[
|
||||
#definition(titre: "Matrice de Contrôle")[
|
||||
$
|
||||
H = mat(
|
||||
@ -199,7 +200,6 @@
|
||||
#let col-u = blue
|
||||
#let col-p = orange
|
||||
|
||||
|
||||
#underline(offset: 3pt)[Exemple d'un code $(5,2)$]
|
||||
|
||||
|
||||
@ -248,8 +248,7 @@
|
||||
#let colu = blue
|
||||
#let colp = orange
|
||||
|
||||
#v(0.5em)
|
||||
|
||||
#place(dx: 0cm, dy: 2.0cm)[
|
||||
#set text(size: 1.1em)
|
||||
Enfin
|
||||
|
||||
@ -283,11 +282,11 @@
|
||||
$
|
||||
]
|
||||
]
|
||||
]
|
||||
|
||||
// A REMPLACER AVEC DE VRAI DONNE SUR DE VRAI CODE LDPC ET HAMMING PAR EXEMPLE
|
||||
#myslide("Approcher la Limite de Shannon")[
|
||||
#limite_shannon_graphique()
|
||||
|
||||
]
|
||||
|
||||
// #myslide("Redondance et limite théorique")[
|
||||
@ -299,16 +298,136 @@
|
||||
// $=>$ gros bloc (moyenne du bruit aléatoire)
|
||||
// ]
|
||||
|
||||
#myslide("Décodage par Maximum de Vraisemblance")[
|
||||
Trouver le message envoyer le + probable sachant le message recu : NP-COMPLET (Max)
|
||||
Decodage par syndrome d'une code lin'aire général est NP-Complet
|
||||
Complexité $O(2^k)$
|
||||
#myslide("Le Mur de la Complexité")[
|
||||
#set text(size: 19pt)
|
||||
#definition(titre: [Décodage par Maximum de Vraisemblance (MDL)], accent: black)[
|
||||
Chercher le mot de code $bold(c) in cal(C)$ le plus probable sachant $bold(r)$ reçu :
|
||||
$ hat(bold(c)) = arg min_(bold(c) in cal(C)) d_H (bold(r), bold(c)) $
|
||||
]
|
||||
|
||||
- Équivalent à chercher l'erreur $bold(e)$ de poids minimal tel que $bold(H) bold(e)^top = bold(s)$.
|
||||
|
||||
#v(0.5em)
|
||||
|
||||
#definition(titre: "Le Problème du décodage par Syndrome")[
|
||||
NP-Difficile et pour $H$ quelconque : $cal(O)(2^k)$
|
||||
]
|
||||
|
||||
- Pour $k=100$ bits, $2^100 approx 10^30$ opérations nécessaires.
|
||||
]
|
||||
|
||||
#myslide("LDPC")[
|
||||
Matrice $H$ clairsemée(low density) donc complexité mointre, pas de produit de matrice mais algorithme itératif efficace quasi linéaire
|
||||
Graphique d'un H très grand clairesemée avec plein de 0, généré en rust par exemple où les 1 sont des points noir et le reste du blanc
|
||||
Défniition avec (w_r,w_c)
|
||||
#myslide("Définition des Codes LDPC")[
|
||||
#definition(titre: [Formalisation des Codes LDPC Réguliers])[
|
||||
Code linéaire en bloc avec une matrice de contrôle $bold(H)$ est *clairsemée*.
|
||||
]
|
||||
|
||||
- *Poids de Colonne $w_c$*
|
||||
|
||||
- *Poids de Ligne $w_r$*
|
||||
|
||||
#v(0.5em)
|
||||
|
||||
#definition(titre: "Conditions de Faible Densité", accent: black)[
|
||||
#set align(center)
|
||||
$w_c << n - k $ #h(2cm) $w_r << n$
|
||||
]
|
||||
|
||||
#definition(titre : "Rendement")[
|
||||
$ display(R = (n - op("rg")(H)) / n >= 1 - m / n) $
|
||||
]
|
||||
]
|
||||
|
||||
#myslide([Matrice de contrôle])[
|
||||
#definition(titre : [Code LDPC $(6, 3)$])[
|
||||
$m w_r = n w_c$ donc $H in cal(M)_(15, 30)(FF_2)$ et $display(R = 1 - m / n = 1/2)$
|
||||
]
|
||||
|
||||
#v(2cm)
|
||||
|
||||
#place(center + horizon, dx: 0cm, dy: 7.3cm)[
|
||||
#scale(140%)[#hldpc()]
|
||||
]
|
||||
]
|
||||
|
||||
#myslide("De la Matrice aux Équations de Parité")[
|
||||
#set text(size: 17pt)
|
||||
|
||||
#let v_space = 2.83cm
|
||||
|
||||
#align(center)[
|
||||
#scale(115%)[
|
||||
#grid(
|
||||
columns: (auto, auto),
|
||||
gutter: -15pt,
|
||||
align: horizon,
|
||||
[#hldpc_dual(row1: 0, row2: none)],
|
||||
[
|
||||
// #set math.mat(gap: 24.5pt)
|
||||
#move(dy: 13.8pt)[
|
||||
$ underbrace(
|
||||
mat(r_0; r_1;#v(v_space);dots.v; r_29; delim: "["),
|
||||
#text()[Mot reçu] r space in space FF_2^30
|
||||
) $
|
||||
]
|
||||
]
|
||||
)
|
||||
]
|
||||
]
|
||||
|
||||
#v(0.5cm)
|
||||
|
||||
#set text(size: 1.1em)
|
||||
|
||||
- Chaque ligne $j$ de $H$ définit une équation de parité $f_j$.
|
||||
- Pour $r$, on vérifie le syndrome : $H r^top = 0$.
|
||||
|
||||
#v(0.2cm)
|
||||
|
||||
#definition(titre: [Équations de Parité], accent: orange)[
|
||||
#set text(size: 1em)
|
||||
#text(fill: orange)[$ f_0 : r_7 plus.o r_10 plus.o r_15 plus.o r_22 plus.o r_24 plus.o r_29 = 0 $]
|
||||
]
|
||||
|
||||
#v(0.3cm)
|
||||
#text(size: 1.1em)[- Si $f_j = 1$, un nombre impair de bits a été inversé par le canal.]
|
||||
]
|
||||
|
||||
#myslide("L'Entrelacement des Contraintes")[
|
||||
#set text(size: 17pt)
|
||||
|
||||
#align(center)[
|
||||
#move(dx: -1.2cm)[
|
||||
#scale(115%)[#hldpc_dual(row1: 0, row2: 14)]
|
||||
]
|
||||
]
|
||||
|
||||
#v(1cm)
|
||||
|
||||
#set text(size: 1.1em)
|
||||
- Chaque bit $r_i$ participe à $w_c = 3$ équations distinctes
|
||||
|
||||
#v(1cm)
|
||||
|
||||
// --- Étage 2 : Système et Décision ---
|
||||
#set align(center + horizon)
|
||||
#scale(115%)[
|
||||
#block(fill: gray.lighten(95%), inset: 10pt, stroke: 0.5pt + gray, radius: 4pt)[
|
||||
$ cases(
|
||||
#text(fill: orange)[$r_7 plus.o r_10 plus.o r_15 plus.o r_22 plus.o bold(r_24) plus.o r_29 &= 0$],
|
||||
|
||||
#h(4.5cm) #text(size : 20pt)[$bold(dots.v)$],
|
||||
|
||||
#text(fill: blue)[$r_1 plus.o r_3 plus.o r_12 plus.o bold(r_24) plus.o r_25 plus.o r_28 &= 0$]
|
||||
) $
|
||||
]
|
||||
]
|
||||
|
||||
#v(1cm)
|
||||
|
||||
#set align(left)
|
||||
#set text(size: 1.1em)
|
||||
- *$r_24$* : Surveillé par #text(fill: orange)[$f_0$] et #text(fill: blue)[$f_14$].
|
||||
- Si #text(fill: orange)[$f_0 = 1$] et #text(fill: blue)[$f_14 = 1$], $r_24$ est suspect
|
||||
]
|
||||
|
||||
#myslide("Graphe de Tanner")[
|
||||
@ -361,3 +480,13 @@
|
||||
#myslide("Théorie deriere la définition des codes linaires")[
|
||||
Poser les notations algebriques etc...
|
||||
]
|
||||
|
||||
#myslide("Decodage par maximum de vraisemblance")[
|
||||
Expliquer, quelle distance ? etc
|
||||
]
|
||||
|
||||
#myslide("Code LDPC non régulier")[
|
||||
|
||||
]
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user