mise à jour

representation_base/chapitre_3/README.md

@@ -0,0 +1,283 @@
+# Représentation des décimaux : les flottants
+
+## 1. Attendus
+
+| Contenus | Capacités attendues |
+| :--: | :-- |
+| Représentation approximative des nombres réels : notion de nombre flottant | Calculer sur quelques exemples la représentation de nombres réels : 0.1, 0.25 ou 1/3. |
+
+## 2. Contexte 
+
+Nous avons appris à encoder des nombres entiers naturels, et relatifs, et nous avons vu que les limites physiques des machines imposaient des limites sur l'étendue des valeurs. Par exemple, sur un octet on dispose de $`2^8 = 256`$ valeurs distinctes qui permettent d'encoder:
+
+- des nombres entiers naturels entre 0 et 255.
+- des nombres entiers relatifs entre -128 et 127.
+
+Maintenant que nous allons tenter de coder les réels, les limites de notre machine vont encore entraîner des limites sur l'étendue des valeurs, mais également sur la __précision des valeurs__.
+
+### 2.1. À Faire
+
+1. effectuez le calcul $`0.2 + 0.1`$ en Python :
+
+```python
+>>> 0.2 + 0.1
+???
+```
+
+2. testez l'égalité suivante : 
+
+```python
+>>> 0.2 + 0.1 == 0.3
+???
+```
+
+> **Il n'est pas possible de coder un nombre décimal en valeur exacte en base 2**.
+>
+> **On obtient une approximation du nombre décimal, et non le nombre en lui même.**
+>
+> **Cette approximation est appelée _nombre en virgule flottante_ et correspond au type _float_ en Python.**
+
+Ainsi, un calcul avec des nombres à virgule ne peut-être qu'__approximatif__. Cependant plus on augmente la taille du registre du processeur et plus nous pourrons représenter de valeurs, et plus nos calculs gagneront en précision.
+
+## 3. Codage de la virgule
+
+Il existe deux façons de coder les nombres réels, en virgule fixe ou virgule flottante.
+
+### 3.1. Virgule fixe
+
+Le codage en __virgule fixe__ consiste à garder __un nombre fixe de chiffes après la virgule__.
+
+Pour une représentation sur $`n`$ bits, on fixe $`e`$ bits pour la partie entière et $`v`$ bits pour la partie décimale où $`e + v = n`$.
+
+__Exemple__ : Sur un octet, on peut utiliser 4 bits pour la partie entière et 4 bits pour la partie décimale.
+
+Ainsi, `0101 1011` a pour valeur : $`2^2 +  2^0 + 2^{-1} + 2^{-3} + 2^{-4} = 4 + 1 + 0.5 + 0.125 + 0.0625 = 5.6875`$   
+
+C’est extrêmement simple. Cette manière de faire s’appelle virgule fixe, car la position de la virgule est connue d’avance. 
+
+L’inconvénient de cette méthode est que, pour un nombre avec peu de chiffres après la virgule, on perd un espace de stockage significatif. Si le nombre en question est `0110 1000`, on perd trois bits “inutilement”.
+
+#### 3.1.1. À Faire
+
+Représenter les valeurs suivants sur 8 bits, en virgule fixe :
+
+1. 7,75
+2. 0,1
+
+### 3.2. Virgule flottante
+
+#### 3.2.1. Notation scientifique
+
+Cette écriture se base sur la notation scientifique des nombres : $`\pm a \times 10^n`$ où $`1 \le a \lt 10`$ et $`n \in \mathbb{Z}^*`$ 
+
+Par exemple :
+
+- 12 s'écrit : $`1,2 \times 10^1`$
+- -85 s'écrit : $`-8,5 \times 10^1`$
+- 0,0123 s'écrit : $`1,23 \times 10^{-2}`$
+
+Le terme __exposant__ correspond à la puissance de 10, et le terme __mantisse__ correspond à la partie décimale. Ainsi, dans « 1,23 × 10−2 » :
+
+- la mantisse (ou significande) est « 1,23 » ;
+- l'exposant est « -2 ».
+
+##### 3.2.1.1. À Faire
+
+Exprimez les nombres suivants en notation scientifique :
+
+- La distance $`d`$ entre la Lune et la Terre est de 384 400km
+- Le poids $`p`$ du moustique Tigre est d'environ 0, 000 001 07kg.
+
+#### 3.2.2. Notation scientifique binaire
+
+Un nombre binaire à virgule de quatre chiffres $`n_1n_0,n_{-1}n_{-2}`$ correspond au nombre décimal $`n_1 \times 2^1 + n_0 \times 2^0 + n_{-1} \times 2^{-1} + n_{-2} \times 2^{-2}`$.
+
+On peut ainsi avoir une notation scientifique binaire : $`n_1n_0,n_{-1}n_{-2}`$ en binaire peut se noter $`n_1,n_0n_{-1}n_{-2} \times 2^1`$.
+
+Par exemple : 
+
+- $`11_2 = 1,1_2 \times 2^1`$
+- $`0,11_2 = 1,1_2 \times 2^{-1}`$
+
+_N.B : Dans le cas de la notation scientifique binaire, le nombre avant la virgule doit être compris entre $`1_2`$ inclus et $`10_2`$ exclus (c'est-à-dire 2 exclus), c'est-à-dire que sa partie entière est nécessairement 1._
+
+#### 3.2.3. Principe du codage en virgule flottante
+
+Un nombre flottant est formé de trois éléments : la mantisse, l'exposant et le signe. 
+
+$$
+\begin{aligned}
+s.m \times 2^e
+\end{aligned}
+$$
+
+![](./assets/virgule_flottante.svg)
+
+- Le bit de poids fort $`s`$ est le bit de __signe__ : si ce bit est à 1, le nombre est négatif, et s’il est à 0, le nombre est positif. 
+- Les $`e`$ bits suivants représentent l'__exposant biaisé__ (sauf valeur spéciale),
+- Les $`m`$ bits suivants ($`m`$ bits de poids faible) représentent la __mantisse__.
+
+__Exemple__ :
+
+Supposons un nombre flottant codé sur un octet utilisant 1 bit de signe, 3 bits pour l'exposant et 4 bits pour la mantisse: `1 101 1011`
+
+- $`s`$ est le signe représenté par le bit de poids fort. Notre codage représente donc un nombre négatif.
+- $`e`$ est l'exposant biaisé, représenté par un entier relatif décalé et non en complément à 2.
+  - Ce décalage est de $`2^{|e|-1} - 1`$ ($`|e|`$ représente le nombre de bits utilisé pour coder l'exposant). 
+  - L'exposant a pour valeur $`101`$ codé sur 3 bits. Il doit être décalé de $`2^2 - 1 = 3`$. 
+  - Ainsi, puisque $`101_2 = 5_{10}`$, l'exposant $`101`$ correspond à un exposant de $`5 - 3 = 2`$.
+- $`m`$ est la mantisse, elle représente en binaire uniquement les chiffres après la virgule.
+	- Dans notre exemple, la mantisse est $`1011`$,
+	- Soit $`m = 1 + 1 \times 2^{-1} + 1 \times 2^{-3} + 1 \times 2^{-4} = 1 + \frac{1}{2} + \frac{1}{8} + \frac{1}{16} = 1,6875`$  
+
+Le code `1 101 1011` sur un octet utilisant 1 bit de signe, 3 bits pour l'exposant et 4 bits pour la mantisse représente donc: $`-1,6875 \times 2^2 = -6,75`$
+
+## 4. La norme IEEE 754
+
+> L'__IEEE 754__ est une norme pour la représentation des nombres à virgule flottante en binaire. Elle est la norme la plus employée actuellement pour le calcul des nombres à virgule flottante dans le domaine informatique.
+
+Cette norme définit notamment 2 formats pour représenter des nombres à virgule flottante:
+
+- _simple précision_ (32 bits : 1 bit de signe, 8 bits d'exposant (-126 à 127), 23 bits de mantisse),
+
+![](./assets/ieee_754_simple.svg)
+
+- _double précision_ (64 bits : 1 bit de signe, 11 bits d'exposant (-1022 à 1023), 52 bits de mantisse)
+
+![](./assets/ieee_754_double.svg)
+
+### 4.1. Valeurs remarquables
+
+Chaque norme défini aussi des valeurs spéciales, par exemple en double précision:
+
+- le zéro positif: +0 = `0 00000000000 0000000000000000000000000000000000000000000000000000`,
+- le zéro négatif: -0 = `1 00000000000 0000000000000000000000000000000000000000000000000000`,
+- l'infini positif: +∞ = `0 11111111111 0000000000000000000000000000000000000000000000000000`,
+- l'infini négatif: +∞ = `1 11111111111 0000000000000000000000000000000000000000000000000000`
+
+### 4.2. Impossibilité de coder tous les nombres réels
+
+Voici l’écriture binaire en format double précision de deux flottants.
+
+| Nombre flottant | Représentation format double précision (mantisse sur 23 bits) |
+| :--: | :--: |
+| $`2.0^{(1)}`$ | `0 10000000 00000000000000000000000` |
+| $`2.000000238418579^{(2)}`$ | `0 10000000 00000000000000000000001` |
+
+Calcul de (1) :
+
+```math
+\begin{aligned}
+n & = s.m \times 2^e \\
+e & = e_{biaisé} - décalage \\
+e_{biaisé} & = 10000000_2 = 2^7 \\
+décalage & = 2^{8 - 1} - 1 \\
+e & = 2^7 - (2^7 - 1) \\
+m & = 1 + 0 \\
+n & = 1 \times 2^1 = 2.0
+\end{aligned}
+```
+
+Calcul de (2) :
+
+```math
+\begin{aligned}
+n & = s.m \times 2^e \\
+e & = e_{biaisé} - décalage \\
+e_{biaisé} & = 10000000_2 = 2^7 \\
+décalage & = 2^{8 - 1} - 1 \\
+e & = 2^7 - (2^7 - 1) \\
+m & = 1 + 2^{-23} \\
+n & = (1 + 2^{-23})\times 2^1 = 2 + 2^{-22} = 2.000000238418579
+\end{aligned}
+```
+
+On comprend aisément qu’il n’y a pas de flottant entre 2.0 et 2.000000238418579.
+Le flottant 2.000000238418579 est donc représenté comme le suivant de 2.0.
+La précision possible avec une mantisse sur 23 bits se situe au niveau dernier bit qui vaut
+$`2^{-23}`$ . On ne peut pas trouver un flottant compris entre les deux.
+
+### 4.3. Conclusion
+
+Les nombres flottants sont une représentation approximative des nombres réels dans un ordinateur. En particulier, il n’est pas possible de représenter de manière exacte en machine tous les nombres réels. La manipulation de nombres réels par un langage informatique est donc à prendre avec précaution car elle peut engendrer des résultats surprenants, en particulier il ne faut jamais tester l’égalité entre deux flottants.
+
+## 5. Exercices
+
+### 5.1. Exercice
+
+On considère des nombres flottants encodés sur un octet avec dans l'ordre:
+
+- 1 bit de signe,
+- 3 bits d'exposant,
+- 4 bits de mantisse.
+
+1. Trouver les nombres à virgule représentés par les mots binaires suivant:
+	- `0111 1000`
+	- `1001 0001`
+2. Donner les représentations binaires des nombres flottants suivants:
+	- 2,5 (qui est égal à $`1,25 \times 2`$).
+	- -1,125.
+3. Avec cet encodage à 8 bits:
+	- Quel est le plus grand nombre à virgules que l'on peut représenter ?
+	- Quel est le plus petit nombre à virgule, donc négatif ?
+	- Quel est le plus petit nombre à virgule strictement positif que l'on peut représenter ?
+
+### 5.2. Exercice
+
+1. Quelles sont les valeurs attendues des instructions suivantes ?
+
+  ```python
+  >>> # Cas 1
+  >>> from math import sqrt
+  >>> sqrt(2.0)**2 == 2.00
+  ???
+  ```
+
+  ```python
+  >>> # Cas 2
+  >>> 9007199254740992.0 + 1
+  ???
+  ```
+
+  ```python
+  >>> # Cas 3
+  >>> 1.2 - 1.0
+  ???
+  ```
+
+  ```python
+  >>> # Cas 4
+  >>> 0.5 - 0.2 - 0.2 - 0.1
+  ???
+  ```
+
+
+  ```python
+  >>> # Cas 5
+  >>> 9007199254740992.0 + 1.0 + 1.0
+  ???
+  ```
+
+  ```python
+  >>> # Cas 6
+  >>> 1.0 + 1.0 + 9007199254740992.0 
+  ???
+  ```
+2. Copier et exécuter les instructions précédentes et comparer avec les résultats attendus.
+
+### 5.3. Exercice
+
+On considère le programme suivant:
+
+```python
+a = 0.0
+for loop in range(0,10):
+    a = a + 0.1
+    print(a)
+```
+
+1. Si l'on calculait sur des nombres rationnels exacts, que se passerait-il lors de l'exécution de ce programme ?
+2. Écrire ce programme et l'exécuter. Que constate-t-on ?
+3. Vérifier avec le convertisseur en ligne que la représentation binaire de 0,1 est `0 01111111011 1001100110011001100110011001100110011001100110011010`.
+4. Quel nombre décimal cette représentation désigne-t-elle en réalité Quel nombre décimal cette représentation désigne-t-elle en réalité ? Expliquer le résultat obtenu.
+

representation_base/chapitre_3/exercices/PATRIOT/CORRECTION.md

@@ -0,0 +1,125 @@
+# Missile Patriot
+
+![An MIM-104 Patriot missile is test fired](./assets/missile.jpeg)
+Source : Department of Defense. American Forces Information Service. Defense Visual Information Center.
+
+## Pré-requis
+
+Avoir programmer :
+
+- une fonction qui prend un nombre de secondes et affiche au format (hh:mm:ss)
+- une fonction qui calcule le PGCD de 2 entiers
+
+## Corrigé
+
+Le micro-contrôleur de l’antimissile *Patriot* stocke la valeur $`\frac{1}{10}`$ en ne conservant que 23 bits pour la partie décimale (codage en virgule fixe).
+
+Il calcule le temps écoulé depuis son démarrage en multiples de $`\frac{1}{10}`$ème de seconde.
+
+1. Écrire $`\frac{1}{10}`$ en binaire, en conservant au moins 30 chiffres binaires après la virgule.
+
+	```math
+	\begin{aligned}
+	& 0,1 \times 2 = \textcolor{red}{0},2 \\
+	& \left.\begin{aligned}
+	0,2 \times 2 & = \textcolor{red}{0},4 \\
+	0,4 \times 2 & = \textcolor{red}{0},8 \\
+	0,8 \times 2 & = \textcolor{red}{1},6 \\
+	0,6 \times 2 & = \textcolor{red}{1},2 \\
+	0,2 \times 2 & = \textcolor{red}{0},4 \\
+	0,4 \times 2 & = \textcolor{red}{0},8 \\
+	0,8 \times 2 & = \textcolor{red}{1},6 \\
+	0,6 \times 2 & = \textcolor{red}{1},2 \\
+	0,2 \times 2 & = \textcolor{red}{0},4 \\
+	\end{aligned}\right\rbrace \textit{suivi de 2 fois}
+	\end{aligned}
+	```
+
+	Soit $`0,1 = 0,00011001100110011001100110011_2`$
+
+2. Sachant que les registres du *Patriot* ne conservent que 23 bits après la virgule, quelle est, en base 10, la valeur qui est codée effectivement à la place de $`\frac{1}{10}`$ ?
+
+	La représentation binaire de 0,1 sur 23 bits est $`0,00011001100110011001100_2`$. Le nombre $`n`$ associé correspond à :
+
+	```math
+	\begin{aligned}
+	n & = 0 \times 2^{-1} + 0 \times 2^{-2} + 0 \times 2^{-3} + 1 \times 2^{-4} + \dots + 0 \times 2^{-23}\\
+	 & = 2^{-4} + 2^{-5} + 2^{-8} + 2^{-9} + 2^{-12} + 2^{-13} + 2^{-16} + 2^{-17} + 2^{-20} + 2^{-21} \\
+	 & = \frac{1}{2^4} + \frac{1}{2^5} + \frac{1}{2^8} + \frac{1}{2^9} + \frac{1}{2^{12}} + \frac{1}{2^{13}} + \frac{1}{2^{16}} + \frac{1}{2^{17}} + \frac{1}{2^{20}} + + \frac{1}{2^{21}}\\
+	 & = \frac{2^{17}}{2^{17} \times 2^4} + \frac{2^{16}}{2^{16} \times 2^5} + \frac{2^{13}}{2^{13} \times 2^8} + \frac{2^{12}}{2^{12} \times 2^9} + \frac{2^9}{2^9 \times 2^{12}} + \frac{2^8}{2^8 \times 2^{13}} + \frac{2^5}{2^5 \times 2^{16}} + \frac{2^4}{2^4 \times 2^{17}} + \frac{2}{2\times2^{20}} + \frac{1}{2^{21}}\\
+	 & = \frac{2^{17} + 2^{16} + 2^{13} + 2^{12} + 2^9 + 2^8 + 2^5 + 2^4 + 2 + 1}{2^{21}} \\
+	 & = \frac{131072 + 65536 + 8192 + 4096 + 512 + 256 + 32 + 16 + 2 + 1}{2097152} \\
+	 & = \frac{209715}{2097152} \\
+	 & \simeq 0.09999990463256836
+	 \end{aligned}
+	```
+
+3. Quelle est l’erreur approximative commise sur la représentation de $`\frac{1}{10}`$ ?
+
+	L'erreur approximative sur la représentation de $`\frac{1}{10}`$ :
+
+	```math
+	\begin{aligned}
+	\epsilon & = \frac{1}{10} - n\\
+	 & = \frac{1}{10} - \frac{209715}{2097152} \\
+	 & = \frac{2097152 - 2097150}{20971520} \\
+	 & = \frac{2}{20971520} \\
+	 & = \frac{1}{10485760} \\
+	 & \simeq 0.000000095
+	\end{aligned}
+	```
+
+4. Combien de signaux d’horloge le *Patriot* reçoit-il en 100 h de fonctionnement ?
+
+	Le nombre de signaux d'horloges $`s`$ que reçoit un missile _Patriot_ en 100h de fonctionnement :
+
+	```math
+   \begin{aligned}
+    s & = \textit{nombre de signaux par seconde} \times \textit{nombre de secondes en } 100h \\
+   & = 10 \times 60 \times 60 \times 100 \\
+   & = 3600000
+    \end{aligned}
+	```
+
+5. En tenant compte de l’erreur calculée à la question 3., quel est le décalage de l’horloge du *Patriot* par rapport à l’heure réelle au bout de 100h ?
+
+	Le décalage de l'horloge $`d`$ du missile _Patriot_ au bout de 100h de fonctionnement :
+
+	```math
+	\begin{aligned}
+	d & = \textit{nombre de signaux d'horloges sur } 100h \times \textit{erreur approximative de la représentation d'un } \frac{1}{10} \\
+	 & = s \times \epsilon \\
+	 & = 3600000 \times \frac{1}{10485760} \\
+	 & = 360000 \times \frac{1}{1048576} \\
+	 & = \frac{360000}{1048576} \\
+	 & = \frac{5625}{16384} \\
+	 & \simeq 0,34 s
+	\end{aligned}
+	```
+
+6. Sachant qu’un missile se déplace à une vitesse d’environ 1 676 m/s, à quelle erreur de position en mètres correspond le décalage d’horloge d’un *Patriot* ayant fonctionné 100 h sans interruption ?
+
+	Soient :
+
+	- $`v`$, la vitesse du missile, 1676m/s,
+	- $`d`$, le décalage de l'horloge calculée à la question 5,
+	- $`e`$, l'erreur de position d'un missile _Patriot_, ayant fonctionné 100h, est :
+
+	```math
+	\begin{aligned}
+		e & = v \times d \\
+		& = 1676 \times \frac{5625}{16384} \\
+		& = \frac{9427500}{16384} \\
+		& = \frac{2356875}{4096} \\
+		& \simeq 575,40 m
+	\end{aligned}
+	```
+
+7. Conclure, sachant que, pour atteindre sa cible un *Patriot*  doit l’approcher à moins de 500 m.
+
+	La question 6 nous a permis de calculer l'erreur de position du missile _Patriot_ ayant fonctionné pendant 100h. Le décalage d'un tel missile est supérieur à la distance d'approche finale de 500m. En conclusion, le missile _Patriot_ n'atteint pas sa cible.
+
+N.B :
+
+- En 1991, pendant la guerre du Golfe, un anti-missile _Patriot_ manque l’interception d’un missile Scud. Bilan : 28 soldats morts.
+- Si au lieu de tronquer $`\frac{1}{10}`$ on avait arrondi au plus proche : $`0,00011001100110011001101_2`$ alors l’erreur aurait été de 0,000000024 au lieu de 0,000000095 soit environ 140 m au lieu de 575 !

representation_base/chapitre_3/exercices/PATRIOT/ENONCE.md

@@ -0,0 +1,26 @@
+# Missile Patriot
+
+![An MIM-104 Patriot missile is test fired](./assets/missile.jpeg)
+Source : Department of Defense. American Forces Information Service. Defense Visual Information Center.
+
+## Pré-requis
+
+Avoir programmé :
+
+- une fonction qui prend un nombre de secondes et l'affiche au format (hh:mm:ss)
+- une fonction qui calcule le PGCD de 2 entiers
+- une fonction qui indique si une fraction de 2 entiers est irréductible (i.e dont le PGCD est égal à 1)
+
+## Énoncé
+
+Le micro-contrôleur de l’antimissile *Patriot* stocke la valeur $`\frac{1}{10}`$​ en ne conservant que 23 bits pour la partie décimale (codage en virgule fixe).
+
+Il calcule le temps écoulé depuis son démarrage en multiples de $`\frac{1}{10}`$ème de seconde.
+
+1. Écrire $`\frac{1}{10}`$ en binaire, en conservant au moins 30 chiffres binaires après la virgule.
+2. Sachant que les registres du *Patriot* ne conservent que 23 bits après la virgule, quelle est, en base 10, la valeur qui est codée effectivement à la place de $`\frac{1}{10}`$ ?
+3. Quelle est l’erreur approximative commise sur la représentation de $`\frac{1}{10}`$ ?
+4. Combien de signaux d’horloge le *Patriot* reçoit-il en 100 h de fonctionnement ?
+5. En tenant compte de l’erreur calculée à la question 3., quel est le décalage de l’horloge du *Patriot* par rapport à l’heure réelle au bout de 100h ?
+6. Sachant qu’un missile se déplace à une vitesse d’environ 1 676 m/s, à quelle erreur de position en mètres correspond le décalage d’horloge d’un *Patriot* ayant fonctionné 100 h sans interruption ?
+7. Conclure, sachant que, pour atteindre sa cible un *Patriot*  doit l’approcher à moins de 500 m.

representation_base/chapitre_3/exercices/README.md

@@ -0,0 +1,43 @@
+## Exercice 1
+
+Écrire, en Python, une fonction `approximation` , prenant en entrée :
+- deux paramètre `a` et `b`, les flottants à comparer),
+- un paramètre `precision`, un entier donnant le nombre de chiffres après la virgule souhaitée entre 0 et 16
+
+* Cette fonction reverra `True` si $`|a - b|< 10^{-precision}`$​ et `False` sinon.
+* Documenter la fonction
+* Créer plusieurs DocTests renvoyant soit True soit False.
+
+_Remarque : On utilisera la fonction valeur absolue : [`abs` ](https://www.w3schools.com/python/ref_func_abs.asp)_
+
+Si nous avons besoin de comparer des flottants, on utilisera donc cette fonction.
+
+## Exercice : 2
+
+Ecrire, en Python, une fonction `pythagore` prenant en entrée 3 flottants `a`, `b`, `c` et renvoie `True` si le triangle de dimension `a`, `b`et `c`est rectangle et `False` sinon.
+
+_Attention : On ne sait pas lequel de `a`, `b` ou `c` est le plus grand côté ! Il faudra donc étudier tous les cas possibles !`
+
+- Documenter la fonction
+- Créer plusieurs DocTests renvoyant soit True soit False. 
+
+## Exercice : 3
+
+Écrire, en Python, une fonction `f` prenant en entrée un paramètre `x`, un flottant. Cette fonction renverra $x^3 + 3 * x^2 +3 * x +1$ 
+
+Écrire, en Python, une fonction `g` prenant en entrée un paramètre `x`, un flottant. Cette fonction renverra $(x + 1)^3$
+
+Écrire en Python une fonction `egalite` prenant en entrée 2 paramètres `f` et `g`, deux fonctions Python renvoyant des valeurs flottantes. Elle devra :
+
+- Comparer approximativement, avec une précision de 10 chiffres après la virgule, les fonctions `f` et `g` en prenant aléatoirement 1000 valeurs de `x` dans l'intervalle [-10, 10].
+- Si une des comparaisons est fausse, alors la fonction renverra `False`
+- Si toutes les comparaisons sont vraie, alors la fonction renverra `True`
+
+
+
+_Remarque : Évidemment, il s'agit de comparaison **approximative**. Si les deux fonctions sont égales 1000 fois à $`10^{-10}`$ près, il y a de fortes chances qu'elles sont égales... mais ce n'est pas une certitude !_
+
+Modifier et `f` pour qu'elle renvoie $`x²`$ et `g` pour qu'elle renvoie $`x² + 10^{⁻11}`$.
+
+- les deux fonctions sont-elles égales ?
+- qu'en dit la fonction `egalite` ?