diff --git a/.gradebook.db b/.gradebook.db
index 097d68bead6681704d8fd315adbb67ee6ec909c6..ae41f14af364e0ac4c1c4ac96d262606b4a632b4 100644
Binary files a/.gradebook.db and b/.gradebook.db differ
diff --git a/02-exponentielle3.md b/02-exponentielle3.md
index bd1abeb5e4b999e1e16c372547a45265d0150977..7ac148ed83119e87b809dbc1a14e6de0a14696f0 100644
--- a/02-exponentielle3.md
+++ b/02-exponentielle3.md
@@ -130,7 +130,7 @@ nbgrader:
 (a == b)
 ```
 
-+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "a03b3b94828a1e69046a2b0ffb1bd3c2", "grade": false, "grade_id": "cell-5017bdc388a2f6c4", "locked": true, "schema_version": 3, "solution": false}}
++++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "b176aaa4d92d7a9b9db2491886070c43", "grade": false, "grade_id": "cell-5017bdc388a2f6c4", "locked": true, "schema_version": 3, "solution": false}}
 
 ### Précision absolue
 
@@ -139,18 +139,17 @@ nbgrader:
 Chaque fois que l'on veut comparer deux nombres flottants, il faut
 spécifier avec quelle **précision** on veut les comparer.
 
-Le plus simple est de fixer un seuil de ***précision
-absolue*** $\eta$, c'est-à-dire la différence de valeur en dessous de
-laquelle on considère que deux nombres sont égaux :
+Pour cela, on fixe un seuil de ***précision absolue*** $\eta>0$ et on
+considère que deux nombres $x$ et $y$ sont égaux à $\eta$ près si :
 
-$$x \simeq y \texttt{si} |x - y| < \eta .$$
+$$ |x - y| < \eta .$$
 
 :::
 
 :::{admonition} Exercice 2
 
 Implantez les deux fonctions suivantes dont on vous donne la documentation :
-- `abs` mais qui prend cette fois en paramètre un `double` et retourne
+- `abs` qui prend cette fois en paramètre un `double` et retourne
    un `double`
 - `egal` qui prend en paramètres les nombres $x$, $y$ et $\varepsilon$.
 
diff --git a/cours.md b/cours.md
index f1e4da3d08fd115d90ee96d10dae530eb4b0acec..db961e6be110056cd56445f389afbb1ea7d63898 100644
--- a/cours.md
+++ b/cours.md
@@ -183,8 +183,8 @@ uniquement avec ces instructions
 
 ##### Tarte tatin
 
-::::{grid}
-:::{grid-item-card}
+:::::{grid}
+::::{grid-item-card}
 -   Ingrédients : 5 belles pommes, ingrédients pour pâte brisée et caramel
 -   *Préparer une pâte brisée*
 -   *Préparer un caramel* et le verser au fond du plat à tarte
@@ -192,11 +192,13 @@ uniquement avec ces instructions
 -   Faire revenir les pommes dans une poêle avec du beurre
 -   Disposer les pommes dans le plat, et étaler la pâte au dessus
 -   Faire cuire 45 minutes et retourner dans une assiette
-:::
-:::{grid-item-card}
-<img src="media/tarte-tatin.jpg" height=20ex alt="une tarte tatin" />
+::::
+::::{grid-item-card}
+:::{image} media/tarte-tatin.jpg
+:alt: une tarte tatin
 :::
 ::::
+:::::
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
@@ -227,10 +229,8 @@ uniquement avec ces instructions
 
 #### Une impression de déjà vu? (1)
 
-<!-- TODO IMG -->
-
-::::{grid}
-:::{grid-item-card}
+:::::{grid}
+::::{grid-item-card}
 
 ```c++
 while ( regarde() == Vide ) {
@@ -258,20 +258,21 @@ while ( regarde() == Vide ) {
 }
 ouvre();
 ```
-:::
-:::{grid-item-card}
-<img src="media/laby2c.png" style="float: right;" alt="laby niveau 2c" height="30ex"/>
+::::
+::::{grid-item-card}
+:::{image} media/laby2c.png
+:alt: "laby niveau 2c"
+:height: 30ex
 :::
 ::::
+:::::
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
 #### Une impression de déjà vu? (2)
 
-<!-- TODO IMG -->
-
-::::{grid}
-:::{grid-item-card}
+:::::{grid}
+::::{grid-item-card}
 ```c++
 void avance_tant_que_tu_peux() {
     while ( regarde() == Vide ) {
@@ -291,11 +292,14 @@ droite();
 avance_tant_que_tu_peux();
 ouvre();
 ```
-:::
-:::{grid-item-card}
-<img src="media/laby2c.png" alt="laby niveau 2c" height="20ex"/>
+::::
+::::{grid-item-card}
+:::{image} media/laby2c.png
+:alt: "laby niveau 2c"
+:height: 30ex
 :::
 ::::
+:::::
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
@@ -475,13 +479,11 @@ slideshow:
 factorielle(5) / factorielle(3) / factorielle(2)
 ```
 
-<!-- -->
-
 +++ {"slideshow": {"slide_type": "slide"}}
 
 ### Syntaxe d'une fonction
 
-**Syntaxe :**
+:::{admonition} Syntaxe
 
 ``` c++
 type nom(type1 parametre1, type2 parametre2, ...) {
@@ -490,11 +492,12 @@ type nom(type1 parametre1, type2 parametre2, ...) {
     return expression;
 }
 ```
--   `parametre1, parametre2, ...` : les **paramètres formels**
+-   `parametre1, parametre2, ...` : les ***paramètres formels***
 -   Le type des paramètres formels est fixé
--   Les variables sont appelées **variables locales**
--   À la fin, la fonction **renvoie** la valeur de `expression`  
+-   Les variables sont appelées ***variables locales***
+-   À la fin, la fonction ***renvoie*** la valeur de `expression`  
     Celle-ci doit être du type annoncé
+:::
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
@@ -518,7 +521,7 @@ float max(float a, float b) {
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
--   `max` n'est utilisée que si elle est *appelée*
+-   `max` n'est utilisée que si elle est ***appelée***
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
@@ -534,7 +537,7 @@ max(1.5, 3.0)
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
-1.   les **paramètres** `a` et `b` sont initialisés avec les valeurs `1.5` et `3.0`
+1.   les paramètres `a` et `b` sont initialisés avec les valeurs `1.5` et `3.0`
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
@@ -546,7 +549,7 @@ max(1.5, 3.0)
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
-4.  le `return` spécifie la **valeur de retour** de la fonction :  
+4.  le `return` spécifie la ***valeur de retour*** de la fonction :  
     la valeur de l'expression `max(1.5, 3.0)`
 
 +++ {"slideshow": {"slide_type": "slide"}}
@@ -557,7 +560,7 @@ max(1.5, 3.0)
 
 ### Documentation d'une fonction (syntaxe javadoc)
 
-**Exemple :**
+:::{admonition} Exemple
 
 ``` c++
 /** Fonction qui calcule la factorielle
@@ -566,21 +569,24 @@ max(1.5, 3.0)
  **/
 int factorielle(int n) ...
 ```
+:::
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
-**Une bonne documentation :**
-
+:::{admonition} Une bonne documentation :
+:class: hint
 -   Est concise et précise
 -   Donne les *préconditions* sur les paramètres
 -   Décrit le résultat (ce que fait la fonction)
+:::
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
-**Astuce pour être efficace :**
-
+:::{admonition} Astuce pour être efficace
+:class: hint
 -   *Toujours commencer par écrire la documentation*  
     De toute façon il faut réfléchir à ce que la fonction va faire!
+:::
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
@@ -619,42 +625,47 @@ CHECK( factorielle(3) == 6  );
 CHECK( factorielle(4) == 24 );
 ```
 
-+++ {"slideshow": {"slide_type": "fragment"}}
-
-<!-- **Note :** jusqu'en 2020-2021, ainsi que les trois premières séances de
-2021-2022, ce cours utilisait le nom `ASSERT` au lieu de `CHECK`. Le
-changement a eu lieu pour assurer la compatibilité avec
-l'infrastructure `doctest`. Pour simplifier la transition, dans
-l'environnement Jupyter de ce cours, on peut utiliser les deux
-indifféremment. -->
-
 +++ {"slideshow": {"slide_type": "slide"}}
 
 #### Tests d'une fonction
 
-**Astuces pour être efficace :**
+:::{admonition} Astuces pour être efficace
+:class: hint
 
 -   *Commencer par écrire les tests d'une fonction*  
     De toute façon il faut réfléchir à ce qu'elle va faire!
+:::
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
+:::{admonition}
+:class: hint
 -   Tester les cas particuliers
+:::
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
+:::{admonition}
+:class: hint
 -   Tant que l'on est pas sûr que la fonction est correcte :
     -   Faire des essais supplémentaires
     -   Capitaliser ces essais sous forme de tests
+:::
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
+:::{admonition}
+:class: hint
 -   Si l'on trouve un bogue :
     -   Ajouter un test caractérisant le bogue
+:::
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
+:::{admonition}
+:class: hint
 -   Les *effets de bord* sont durs à tester!
+:::
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
@@ -748,106 +759,97 @@ factorielle(1+2)
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
-#### Syntaxe
+:::{admonition} Syntaxe
 
 ``` c++
 nom(expression1, expression2, ...)
 ```
+:::
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
-#### Sémantique
-
-+++ {"slideshow": {"slide_type": "fragment"}}
-
+:::{admonition} Sémantique
 1.  Evaluation des expressions  
-    Leurs valeurs sont les **paramètres réels**
-
-+++ {"slideshow": {"slide_type": "fragment"}}
-
-2.  Allocation de mémoire sur la **pile** pour :
+    Leurs valeurs sont les ***paramètres réels***
+2.  Allocation de mémoire sur la ***pile*** pour :
     -   Les variables locales
     -   Les paramètres formels
-
-+++ {"slideshow": {"slide_type": "fragment"}}
-
 3.  Affectation des paramètres réels aux paramètres formels  
     (par copie; les types doivent correspondre!)
-
-+++ {"slideshow": {"slide_type": "fragment"}}
-
 4.  Exécution des instructions
-
-+++ {"slideshow": {"slide_type": "fragment"}}
-
 5.  Lorsque `return expression` est rencontré, évaluation de
     l'expression qui donne la **valeur de retour de la fonction**
-
-+++ {"slideshow": {"slide_type": "fragment"}}
-
 6.  Désallocation des variables et paramètres sur la pile
-
-+++ {"slideshow": {"slide_type": "fragment"}}
-
 7.  La valeur de l'expression `nom(...)` est donnée par la valeur de
     retour
+:::
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
 #### Évolution de la pile sur l'exemple
 
-::::{grid}
-:::{grid-item-card}
+:::::{grid}
+::::{grid-item-card}
 1. État initial
-:::
-:::{grid-item-card}
-<img src="media/pile-etat-initial.png" alt="1 case unique contenant '...'" height="20ex"/>
-:::
 ::::
+::::{grid-item-card}
+:::{image} media/pile-etat-initial.png
+:alt: 1 case unique contenant '...'"
+:height: 20ex
+::::
+:::::
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
-::::{grid}
-:::{grid-item-card}
+:::::{grid}
+::::{grid-item-card}
 1. Allocation de la mémoire sur la pile 
-:::
-:::{grid-item-card}
-<img src="media/pile-allocation.png" alt="3 cases ajoutées contenant 'int n : ? (paramètre formel)' puis 'int resultat : ? (variable locale)' puis 'int k : ? (variable locale)'. Les 3 cases sont entourées d'une accolade avec marqué 'f'" height="20ex"/>
+::::
+::::{grid-item-card}
+:::{image} media/pile-allocation.png
+:alt: "3 cases ajoutées contenant 'int n : ? (paramètre formel)' puis 'int resultat : ? (variable locale)' puis 'int k : ? (variable locale)'. Les 3 cases sont entourées d'une accolade avec marqué 'f'"
+:height: 20ex
 :::
 ::::
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
-::::{grid}
-:::{grid-item-card}
+:::::{grid}
+::::{grid-item-card}
 3 : Affectation du paramètre réel au paramètre formel
-:::
-:::{grid-item-card}
-<img src="media/pile-affectation.png" alt="le point d'interrogation après le n est remplacé par 3" height="20ex"/>
-:::
 ::::
+::::{grid-item-card}
+:::{image} media/pile-affectation.png
+:alt: "le point d'interrogation après le n est remplacé par 3"
+:height: 20ex
+::::
+:::::
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
-::::{grid}
-:::{grid-item-card}
+:::::{grid}
+::::{grid-item-card}
 4 : Exécution des instructions
-:::
-:::{grid-item-card}
-<img src="media/pile-exécution.png" alt="Le point d'intrrogation après résultat est remplacé par '6' et celui après k par '4'" height="20ex"/>
-:::
 ::::
+::::{grid-item-card}
+:::{image} media/pile-exécution.png
+:alt: "Le point d'intrrogation après résultat est remplacé par '6' et celui après k par '4'"
+:height: 20ex
+::::
+:::::
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
-::::{grid}
-:::{grid-item-card}
+:::::{grid}
+::::{grid-item-card}
 5,6,7 : Désallocation de la mémoire sur la pile et valeur de retour
-:::
-:::{grid-item-card}
-<img src="media/pile-retour.png" alt="les 3 cases de la pile sont supprimées. On revient à l'état de départ. La valeur 6 est écrite juste au dessus de la pile avec indiqué 'valeur de retour'" height="20ex"/>
-:::
 ::::
+::::{grid-item-card}
+:::{image} media/pile-retour.png
+:alt: "les 3 cases de la pile sont supprimées. On revient à l'état de départ. La valeur 6 est écrite juste au dessus de la pile avec indiqué 'valeur de retour'"
+:height: 20ex
+::::
+:::::
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
@@ -908,21 +910,29 @@ b
 -   On peut les modifier.
 -   Mais ...
 
-#### Rappel
++++ {"slideshow": {"slide_type": "fragment"}}
 
+:::{admonition} Rappel
+:class: hint
 Lors d'un appel de fonction ou de procédure, la valeur du paramètre réel
 est **copiée** dans le paramètre formel.
+:::
 
-#### Conséquence
++++ {"slideshow": {"slide_type": "fragment"}}
 
+:::{admonition} Conséquence
 -   Une modification du paramètre formel n'affecte pas le paramètre
     réel
 -   Si la variable est volumineuse (tableaux, chaîne de caractères,
     etc.), cette copie peut être coûteuse
 
-On dit que les paramètres sont passés **par valeur**.
+:::
+
++++ {"slideshow": {"slide_type": "fragment"}}
+
+On dit que les paramètres sont passés ***par valeur***.
 
-Au second semestre, vous verrez le passage de paramètres **par référence**.
+Au second semestre, vous verrez le passage de paramètres ***par référence***.
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
@@ -933,18 +943,17 @@ Au second semestre, vous verrez le passage de paramètres **par référence**.
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
-### Fonctions particulières : procédures
+### Fonctions particulières : ***procédures***
 
 Besoin de sous-programmes qui *agissent* au lieu de *calculer* :
 -   On veut produire un effet (affichage, musique, *etc*)
 -   On veut modifier l'état interne d'une structure de donnée
 
-On parle d'**effet de bord**
+On parle d'***effet de bord***
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
-**Exemple :**
-
+:::{admonition} Exemple
 ``` c++
 void avance_tant_que_tu_peux() {
     while ( regarde() == Vide ) {
@@ -952,6 +961,7 @@ void avance_tant_que_tu_peux() {
     }
 }
 ```
+:::
 
 +++ {"slideshow": {"slide_type": "fragment"}}
 
@@ -967,6 +977,7 @@ void avance_tant_que_tu_peux() {
 
 ### Fonctions particulières : fonctions récursives ♣
 
+:::{admonition} Exemple
 ``` c++
 int factorielle(int n) {
     if ( n == 0 ) {
@@ -976,23 +987,29 @@ int factorielle(int n) {
     }
 }
 ```
+:::
 
-+++
++++ {"slideshow": {"slide_type": "fragment"}}
 
-Une ***fonction*** récursive est une fonction qui s'appelle
+:::{admonition} Définition
+Une ***fonction récursive*** est une fonction qui s'appelle
 elle-même.
+:::
 
 Cela peut paraître étrange de définir un objet à partir de lui-même,
 mais c'est comme pour les suites définies par récurrence en
 mathématiques: il faut et il suffit de s'assurer d'avoir un cas de
 base et une étape de récurrence bien posée.
 
-**Exercice :**
++++ {"slideshow": {"slide_type": "fragment"}}
+
+:::{admonition} Exercice
 
 - Exécuter pas à pas :
     - `factorielle(0)`
     - `factorielle(3)`
     - `factorielle(-1)`
+:::
 
 +++ {"slideshow": {"slide_type": "slide"}}
 
@@ -1023,7 +1040,3 @@ base et une étape de récurrence bien posée.
 -   *Tests* : ce que fait la fonction (exemples)
 -   *Code* : comment elle le fait
 
-```{code-cell}
-
-```
-