02-exponentielle3.md

---
jupytext:
  text_representation:
    extension: .md
    format_name: myst
    format_version: 0.13
kernelspec:
  display_name: C++17
  language: C++17
  name: xcpp17
---

+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "1ca90f09fc87538c759d09fbe1217009", "grade": false, "grade_id": "cell-ffce5d69407bd085", "locked": true, "schema_version": 3, "solution": false}}

# TP : implanter la fonction exponentielle (3/5)

+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "569e425b06cd8c16e84017c752406681", "grade": false, "grade_id": "cell-ba70cc528a726649", "locked": true, "schema_version": 3, "solution": false}}

## Partie 3 : comparaison de nombres flottants et précision absolue et relative

Nous avons vus que les nombres flottants (`float` ou `double`)
n'étaient qu'une approximation des nombres réels. Notamment,
l'opérateur `==` diffère de l'égalité des nombres réels du fait des
erreurs d'arrondis :

```{code-cell}
---
deletable: false
editable: false
nbgrader:
  cell_type: code
  checksum: 1e636b99e82d325870440aed2894f08c
  grade: false
  grade_id: cell-357388e8811e8887
  locked: true
  schema_version: 3
  solution: false
---
1.0 + 1e20 - 1e20 == 1e20 - 1e20 + 1.0
```

+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "0822c60c62e6c3ef68e63b5367764e8a", "grade": true, "grade_id": "cell-2ba595671ff56d54", "locked": false, "points": 1, "schema_version": 3, "solution": true}}

:::{admonition} Exercice 1

1.  Exécutez les cinq cellules suivantes. Que constatez-vous ?

% REMPLACEZ CETTE LIGNE PAR VOTRE RÉPONSE

:::

```{code-cell}
---
deletable: false
editable: false
nbgrader:
  cell_type: code
  checksum: 0aa154808a718050f75784ffd1e85186
  grade: false
  grade_id: cell-9822d857d4e81d79
  locked: true
  schema_version: 3
  solution: false
---
double a,b;
```

```{code-cell}
---
deletable: false
editable: false
nbgrader:
  cell_type: code
  checksum: c20e8d87557a1145821afa8bdbd569fa
  grade: false
  grade_id: cell-d98a79aa643b191e
  locked: true
  schema_version: 3
  solution: false
---
a = 16;
b = 15.99999999999;
```

```{code-cell}
---
deletable: false
editable: false
nbgrader:
  cell_type: code
  checksum: e91e01eba95383e91c63ae2b9fbf812d
  grade: false
  grade_id: cell-14c516a6791b2309
  locked: true
  schema_version: 3
  solution: false
---
a
```

```{code-cell}
---
deletable: false
editable: false
nbgrader:
  cell_type: code
  checksum: b80af210b01b89dea73d35fcd75ac953
  grade: false
  grade_id: cell-e1b28a8439e86689
  locked: true
  schema_version: 3
  solution: false
---
b
```

```{code-cell}
---
deletable: false
editable: false
nbgrader:
  cell_type: code
  checksum: eb4acdc9ae85cfdafcb2d462375eccbb
  grade: false
  grade_id: cell-659691632843cfcb
  locked: true
  schema_version: 3
  solution: false
---
(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}}

### Précision absolue

:::{admonition} Définition : *précision absolue*

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 :

$$x \simeq y \texttt{si} |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
   un `double`
- `egal` qui prend en paramètres les nombres $x$, $y$ et $\varepsilon$.

:::

```{code-cell}
---
deletable: false
nbgrader:
  cell_type: code
  checksum: 7de0389c0cd7f6051c53f87245d68d53
  grade: false
  grade_id: cell-aa46c278f72ba400
  locked: false
  schema_version: 3
  solution: true
---
/** Valeur absolue pour type double
 * @param x un nombre de type double
 * @return la valeur absolue de x
**/
// REMPLACEZ CETTE LIGNE PAR VOTRE RÉPONSE
```

```{code-cell}
abs(-1.5)
```

```{code-cell}
---
deletable: false
editable: false
nbgrader:
  cell_type: code
  checksum: 7f53fec20e48a1316dcfdd00e15f8439
  grade: true
  grade_id: cell-abf252519d9a3950
  locked: true
  points: 1
  schema_version: 3
  solution: false
---
CHECK( abs(-1.5) == 1.5 );
CHECK( abs( 2.2) == 2.2 );
```

```{code-cell}
---
deletable: false
nbgrader:
  cell_type: code
  checksum: 4616aaab9633a2a67c21aaf85c9836cb
  grade: false
  grade_id: cell-f6efe81b76dfe515
  locked: false
  schema_version: 3
  solution: true
---
/** Égalité entre deux flottants avec précision absolue
 * @param x un nombre de type double
 * @param y un nombre de type double
 * @param epsilon un nombre de type double
 * @return true si la valeur absolue de x - y est plus petite que epsilon
**/
// REMPLACEZ CETTE LIGNE PAR VOTRE RÉPONSE
```

```{code-cell}
egal(1, 1.05, 0.01)
```

```{code-cell}
---
deletable: false
editable: false
nbgrader:
  cell_type: code
  checksum: c69d716e55d182a5c42a2fdf00ef494f
  grade: true
  grade_id: cell-da8592649f3234ee
  locked: true
  points: 1
  schema_version: 3
  solution: false
---
CHECK(     egal( 1,  1.05, 0.1 ) );
CHECK( not egal( 1,  1.05, 0.01) );
CHECK(     egal(10, 10.05, 0.1 ) );
CHECK( not egal(10, 10.05, 0.01) );
```

### Précision relative ♣

:::{admonition} Indication
:class: hint

Si la notion de précision relative décrite ci-dessous ne vous paraît
pas claire en première lecture, vous pouvez passer directement à la
[partie 4](02-exponentielle4.md) et revenir ici ultérieurement.

:::

Lorsque les valeurs à comparer sont très variables en ordre de
grandeur, la précision absolue n'est souvent pas bien adaptée. Par
exemple, si l'on compare des altitudes de pics montagneux, une
précision absolue de l'ordre du mètre ($\eta = 10^1$m) suffit
souvent. En revanche si l'on compare des tailles de personnes, on
cherche généralement à précis au centimètre ($\eta = 10^{-2}$m).

Ainsi, dans les applications, c'est le plus souvent le nombre de
chiffres significatifs en commun qui est pertinent à
mesurer, ce que l'on formalise comme suit

:::{admonition} Définition: précision relative

Pour comparer $x$ et $y$ avec une ***précision relative*** de
l'ordre de cinq chiffres significatifs, on prend
$\varepsilon=10^{-5}=0,00001$, et on dit que $x$ est égal à $y$ à
$\varepsilon$ près si :

$$ |x - y| < \varepsilon|x| \qquad \text{et} \qquad |x - y| < \varepsilon |y|$$

Moralement : la différence entre $x$ et $y$ est négligeable devant $x$
et devant $y$.

:::

Ce concept est particulièrement pertinent pour le calcul de
l'exponentielle car celle-ci donne des valeurs d'ordres de grandeur
très différents : $e^1 \simeq 10^0$, $e^5 \simeq 10^2$, $e^{10} \simeq
10^5$ ...

:::{admonition} Exercice 3

1.  Dans chacun des exemples suivants, est-ce que $x\simeq y$ avec une
    précision relative $\varepsilon=0.1$? Une précision relative
    $\varepsilon=0.01$?

	- $x=1.22$, $y=1.24$
	- $x=1220$, $y=1240$
	- $x=0.0122$, $y=0.0124$
	- $x=0$, $y=0.01$

:::

+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "1cd8ce624e0d6eab52009520bfe95f14", "grade": false, "grade_id": "cell-55c9c5c79654d21b", "locked": true, "schema_version": 3, "solution": false}}

:::{admonition} Exercice 3 (suite)
2.   Définissez la fonction suivante
:::

```{code-cell}
---
deletable: false
nbgrader:
  cell_type: code
  checksum: e9593c2b767005303ac77970dcab0494
  grade: false
  grade_id: cell-f6efe81b76dfe516
  locked: false
  schema_version: 3
  solution: true
---
/** Égalité entre deux flottants avec précision relative
 * @param x un nombre de type double
 * @param y un nombre de type double
 * @param epsilon un nombre de type double
 * @return true si la valeur absolue de x - y est plus petite que epsilon * |x| et que epsilon * |y|
**/
// REMPLACEZ CETTE LIGNE PAR VOTRE RÉPONSE
```

```{code-cell}
egal_relatif(15.999999, 16, 0.00001)
```

```{code-cell}
---
deletable: false
editable: false
nbgrader:
  cell_type: code
  checksum: 63f8c37c821ea9feb1111cb3c4e471cf
  grade: true
  grade_id: cell-da8592649f3234ef
  locked: true
  points: 1
  schema_version: 3
  solution: false
---
CHECK(     egal( 1,  1.05, 0.1  ) );
CHECK( not egal( 1,  1.05, 0.01 ) );
CHECK(     egal(10, 10.05, 0.001) );
CHECK( not egal(10, 10.05, 0.01 ) );
```

+++ {"deletable": false, "editable": false, "nbgrader": {"cell_type": "markdown", "checksum": "c69293ee58fe41d06fc737f13afb7d99", "grade": false, "grade_id": "cell-29e58e1837c86ada", "locked": true, "schema_version": 3, "solution": false}}

:::{admonition} Exercice 3 (suite)
3.  Trouvez des valeurs de `epsilon` telles que les nombres ci-dessous
    soient considérés comme égaux par `egal_relatif` :
:::

```{code-cell}
egal_relatif(15, 16, 0.001)
```

```{code-cell}
egal_relatif(0.0001, 0.002, 0.001)
```

+++ {"deletable": false, "nbgrader": {"cell_type": "markdown", "checksum": "a004276f32bf0be4e145a883c8b19132", "grade": true, "grade_id": "cell-fd99a546db74023d", "locked": false, "points": 1, "schema_version": 3, "solution": true}}

:::{admonition} Exercice 3 (suite)
4.  Que se passe-t-il lorsque $x$ ou $y$ valent $0$ ?

    % REMPLACEZ CETTE LIGNE PAR VOTRE RÉPONSE
:::

```{code-cell}
egal_relatif(0.00001, 0, 0.0000001)
```

## Bilan de la partie 3

Maintenant que avez défini la comparaison de nombres flottants avec
une précision relative fixée, vous pouvez passer à la [partie
4](02-exponentielle4.md).