Skip to content
Snippets Groups Projects
Commit ffc6b356 authored by Nicolas M. Thiéry's avatar Nicolas M. Thiéry
Browse files

Préparation

parent 8a5bb52d
No related branches found
No related tags found
No related merge requests found
No preview for this file type
......@@ -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$.
......
......@@ -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}
```
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment