added beginning of BH. must revamp figs+

slides/cours_21.md

@@ -56,8 +56,8 @@ graph TD;
 ```C
 arbre symétrie(arbre)
     si !est_feuille(arbre)
-        échanger(arbre.enfant[0], arbre.enfant[1])
-        échanger(arbre.enfant[2], arbre.enfant[3])
+        échanger(arbre.enfant[0], arbre.enfant[2])
+        échanger(arbre.enfant[1], arbre.enfant[4])
         pour i de 0 à 3
             symétrie(arbre.enfant[i])
     retourne arbre
@@ -103,10 +103,10 @@ arbre symétrie(arbre)
 ## Écrire le pseudo-code (5min, matrix)
 
 ```C
-rien compression_sans_perte(arbre)
+rien compression_sans_pertes(arbre)
     si !est_feuille(arbre)
         pour i de 0 à 3
-            compression_sans_perte(arbre.enfant[i])
+            compression_sans_pertes(arbre.enfant[i])
         si derniere_branche(arbre)
             valeur, toutes_égales = valeur_enfants(arbre)
             si toutes_egales
@@ -207,8 +207,8 @@ bool last_value(node *qt, int *val) {
 * Avec l'écart-type
 
 \begin{equation*}
-\mu = \frac{1}{4}\sum_{i=0}^{3} p[i],\quad \sigma = \sqrt{\frac{1}{N}\sum_{i=0}^3 (\mu-p[i])
-^2}
+\mu = \frac{1}{4}\sum_{i=0}^{3} p[i],\quad \sigma = \sqrt{\frac{1}{4}\sum_{i=0}^3 (\mu-p[i])
+^2} = \sqrt{\frac{1}{4}\left(\sum_{i=0}^3p[i]^2\right)-\mu^2}
 \end{equation*}
 
 ## Que devient l'algorithme?
@@ -234,3 +234,390 @@ bool last_value(node *qt, int *val) {
 . . .
 
 ![Arbre compressé.](figs/quad_img_simple_comp_avg.svg)
+
+# Compression avec perte (6/N)
+
+## Modifications sur la structure de données?
+
+. . .
+
+* On stocke la moyenne, et le carré de la moyenne.
+
+```C
+struct noeud
+    flottant moyenne, moyenne_carre
+    node enfants[4]
+```
+
+* Comment on calcule `moyenne` et `moyenne_carre` sur chaque noeud (pseudo-code)?
+
+# Calcul de la moyenne
+
+## Pseudo-code (5min, matrix)
+
+. . .
+
+```C
+rien moyenne(arbre) {
+    si !est_feuille(arbre)
+        pour enfant dans arbre.enfants
+            moyenne(enfant)
+        pour enfant dans arbre.enfants
+            arbre.moyenne += enfant.moyenne
+            arbre.moyenne_carre += enfant.moyenne_carre
+        arbre.moyenne /= 4
+        arbre.moyenne_carre /= 4
+```
+
+# La compression avec pertes
+
+## Pseudo-code (5min, matrix)
+
+. . .
+
+```C
+rien compression_avec_pertes(arbre, theta)
+    si !est_feuille(arbre)
+        pour i de 0 à 3
+            compression_avec_pertes(arbre.enfant[i])
+        si derniere_branche(arbre)
+            si racine(arbre.moyenne*arbre.moyenne - arbre.moyenne_carre) < theta
+                detruire_enfants(arbre)
+```
+
+## Le code en entier
+
+```C
+arbre = matrice_à_arbre(matrice)
+moyenne(arbre)
+compression_sans_pertes(arbre)
+```
+
+# La dynamique des corps célestes
+
+## Slides très fortement inspirés du cours de J. Latt, Unige
+
+## Simulation du problème à $N$-corps
+
+* Prédiction du mouvement d'un grand nombre de corps célestes.
+* Modélisation:
+    * On se limite aux étoiles;
+    * Chaque étoile est caractérisée par un point (coordonnées) et une masse;
+    * On simule en deux dimensions.
+    * Interactions uniquement par les lois de la gravitation Newtonienne (oui-oui c'est de la **physique**!).
+
+
+# Les équations du mouvement
+
+## Mouvement de la $i$-ème étoile
+
+* Algorithme de Verlet ($t_{n+1}=t_n+\delta t$)
+
+    $$
+   \vec x_i(t_{n+1})= 2\vec x_i(t_n)-\vec x_i(t_{n-1})+\vec a_i(t_n)\delta t^2.
+   $$
+
+## Force de gravitation
+
+* $\vec a_i(t_n)=\vec F_i/m_i$.
+* Sur l'étoile $i$, la force résultante est donnée par
+
+    $$
+    \vec F_i=\sum_{j=1,j\neq i}^N \vec F_{ij}.
+    $$
+    avec
+    $$
+    \vec F_{ij}=\frac{G m_i m_j(\vec x_j-\vec x_i)}{||\vec x_j-\vec x_i||^3}.
+    $$
+
+# Algorithme du problème à $n$-corps
+
+## Pseudo-code: structure de données
+
+```C
+struct étoile
+    flottant m
+    vec x, x_precedent, f
+```
+
+## Pseudo-code: itération temporelle
+
+```C
+rien iteration_temporelle(étoiles, dt)
+    pour étoile_une dans étoiles
+        étoile_une.a = 0
+        pour étoile_deux dans étoiles
+            si (étoile_un != étoile_deux)
+                étoile_une.f += 
+                    force(étoile_une, étoile_deux)
+    pour étoile dans étoiles
+        étoile.x, étoile.x_precedent = 
+            verlet(étoile.x, étoile.x_precedent, 
+                   étoile.f / étoile.m, dt)
+```
+
+# Algorithme du problème à $n$-corps
+
+## Complexité
+
+* Complexité de chacune des parties?
+
+. . .
+
+* $\mathcal{O}(N^2)$, $\mathcal{O}(N)$.
+
+## En temps CPU pour **une itération**
+
+* Si temps pour $N=1$ on calcule en $1\mu s$:
+
++--------+-------+-------+-----------+
+|     N  |  N^2  | t [s] | t [réel]  |
++--------+-------+-------+-----------+
+|    10  |  10^2 | 1e-4  |           |
++--------+-------+-------+-----------+
+|  10^2  |  10^4 | 1e-2  |           |
++--------+-------+-------+-----------+
+|  10^4  |  10^8 | 1e+2  | ~1min     |
++--------+-------+-------+-----------+
+|  10^6  | 10^12 | 1e+6  | ~11j      |
++--------+-------+-------+-----------+
+|  10^9  | 10^18 | 1e+12 | ~30k ans  |
++--------+-------+-------+-----------+
+|  10^11 | 10^22 | 1e+16 | ~300M ans |
++--------+-------+-------+ ----------+
+
+* Typiquement il y a des milliers-millions d'itérations.
+* Il y a $10^{11}$ étoiles dans la galaxie.
+* Houston we have a problem.
+
+# Question
+
+## Comment faire mieux, des idées?
+
+. . .
+
+* Si un groupe d'étoiles est suffisamment loin, on le modélise comme un corps unique situé en son centre de masse.
+* Exemple: Si on simule plusieurs galaxies, on considère chaque galaxie comme un corps unique!
+* Un arbre quaternaire est une structure parfaite pour regrouper les étoiles.
+
+# Le cas à 10 corps
+
+::: columns
+
+:::: {.column width=50%}
+
+## Illustration: le cas à 10 corps
+
+![](figs/nbody_bare.png){width=60%}
+
+::::
+
+:::: {.column width=50%}
+
+## Problématique
+
+* On veut calculer la force sur $1$.
+
+::::
+
+:::
+
+. . .
+
+
+::: columns
+
+:::: {.column width=50%}
+
+## Illustration: le cas à 10 corps
+
+![](figs/nbody_n2.png){width=60%}
+
+
+::::
+
+:::: {.column width=50%}
+
+## Résultat
+
+* Calcul et somme des forces venant des $9$ autre corps.
+
+::::
+
+:::
+
+# Le cas à 10 corps
+
+::: columns
+
+:::: {.column width=50%}
+
+## Réduction d'un groupe à un seul corps
+
+![](figs/nbody_group.png){width=100%}
+
+::::
+
+:::: {.column width=50%}
+
+## Idée
+
+* On accélère le calcul en traitant un groupe comme un seul corps.
+* Fonctionne uniquement si le groupe est assez loin.
+* Autrement l'approximation est trop grossière.
+
+::::
+
+:::
+
+# Solution: l'arbre quaternaire
+
+## Corps célestes - arbre
+
+![](figs/nbody_qt_withtree.png)
+
+* On omet les noeuds vides pour éviter la surcharge.
+* La numérotation est:
+    * 0: ID
+    * 1: SD
+    * 2: ID
+    * 3: SG
+
+# Algorithme d'insertion
+
+::: columns
+
+:::: {.column width=50%}
+
+## Insertion corps 1
+
+![](figs/corps1.png){width=100%}
+
+::::
+
+:::: {.column width=50%}
+
+## Arbre
+
+![](figs/arbre1.png){width=100%}
+
+* Quadrant ID.
+* La feuille est vide, on insère.
+
+::::
+
+:::
+
+# Algorithme d'insertion
+
+::: columns
+
+:::: {.column width=50%}
+
+## Insertion corps 2
+
+![](figs/corps2.png){width=100%}
+
+::::
+
+:::: {.column width=50%}
+
+## Arbre
+
+![](figs/arbre2.png){width=100%}
+
+* Quadrant SD.
+* La feuille est vide, on insère.
+
+::::
+
+:::
+
+# Algorithme d'insertion
+
+::: columns
+
+:::: {.column width=50%}
+
+## Insertion corps 3 (1/N)
+
+![](figs/corps3_1.png){width=100%}
+
+::::
+
+:::: {.column width=50%}
+
+## Arbre
+
+![](figs/arbre3_1.png){width=100%}
+
+* Quadrant SD.
+* La feuille est prise par 2.
+
+::::
+
+:::
+
+# Algorithme d'insertion
+
+::: columns
+
+:::: {.column width=50%}
+
+## Insertion corps 3 (2/N)
+
+![](figs/corps3_2.png){width=100%}
+
+::::
+
+:::: {.column width=50%}
+
+## Arbre
+
+![](figs/arbre3_2.png){width=100%}
+
+* On crée un nouveau noeud.
+* Deux corps dans le noeud ID.
+* On crée un nouveau noeud.
+
+::::
+
+:::
+
+# Algorithme d'insertion
+
+::: columns
+
+:::: {.column width=50%}
+
+## Insertion corps 3 (3/N)
+
+![](figs/corps3_3.png){width=100%}
+
+::::
+
+:::: {.column width=50%}
+
+## Arbre
+
+![](figs/arbre3_3.png){width=100%}
+
+* 2 va dans ID.
+* 3 va dans SG.
+* C'est des feuilles vides, tout va bien.
+
+::::
+
+:::
+
+# Algorithme d'insertion
+
+## Que fait-on avec les noeuds intérieurs?
+
+* On les utilise pour:
+    * stocker la masse totale;
+    * stocker le centre de masse.
+
+## Les feuilles contiennent les étoiles.
+
+