Ajout première séquence

representation_base/seance_3/README.md

@@ -0,0 +1,157 @@
+# Codage des décimaux : les flottants
+
+## 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. |
+
+## Petit rappel : la base 10
+
+Intéressons nous à l'écriture d'un nombre décimal en base 10, comme par exemple 223,25
+
+### Codage de la partie entière
+
+Nous savons tous ici, en base 10, que 223 se compose de :
+
+- 3 unités,
+- 2 dizaines
+- 2 centaines.
+
+Cela vient de la série de divisions ci-dessous,  sur laquelle les restes fournissent le nombre d'unités (3), de dizaines (2) et de centaines (2 aussi)
+
+![partie entière base 10](assets/div1base10.jpg)
+
+On écrit alors $`223 = 2 \times 100 + 2 \times 10 + 3 \times 1`$​ : c'est sa décomposition en base 10
+
+### Codage de la partie décimale
+
+Pour la partie décimale, 0.25, en base dix également, on a l'habitude de lire 2 dixièmes et 5 centièmes. Cela vient cette fois de multiplication par 10 :
+
+* $`0,25 \times 10 = 2.5`$ : la partie entière indique le nombre de dixièmes (2) et la partie décimale restante est 0,5
+
+* $`0,5 \times 10 = 5`$ : la partie entière indique le nombre de centièmes (5) et il n'y a plus de partie décimale à _explorer_.
+
+On vient de voir que $`0,25 = 2 \times \frac{1}{10} + 5 \times \frac{1}{100}`$
+
+Ainsi on peut écrire :  $`223,25 = 2 \times 100 + 2 \times 10 + 3 + 2 \times \frac{1}{10} + 5 \times \frac{1}{100}`$
+
+En **notation scientifique**, on obtient : $`223,25= 2,2325 \times 10²`$​
+
+**Définition**
+
+> La __notation scientifique__ est une façon de représenter les nombres décimaux. Elle consiste à exprimer le nombre sous la forme $`\pm a\times 10^{n}`$, où $`\pm`$ est appelé signe, $`a`$ est un nombre décimal de l'intervalle $`[1 ; 10[`$ appelé __mantisse (ou significande)__ et $`n`$ est un entier relatif appelé __exposant__.
+
+## En base 2
+
+### Codage de la partie entière
+
+Pour la partie entière, c'est exactement le même principe mais  en divisant cette fois par 2 :
+
+![partie entière base 10](assets/div1base2.jpg)
+
+On écrit alors : $`223 = 1 \times 2⁰ + 1 \times 2¹ + 1 \times 2² +1 \times 2³ + 1 \times 2⁴ + 0 \times 2⁵ + 1 \times 2⁶ +1 \times 2⁷`$ : C'est sa décomposition en base 2.
+
+Ainsi $`223 = 11111011_2`$
+
+### Codage de la partie décimale
+
+Pour la partie décimale, on procède comme en base 10 mais en multipliant par 2 au lieu de multiplier par 10 :
+
+- $`0,25 \times 2 = 0,5`$​​ : la partie entière vaut **0**, la partie décimale restante est 0.5
+- $`0,5 \times 2 = 1,0`$ : la parie entière vaut **1**. il n'y a plus rien après la virgule donc nous avons terminé
+
+On vient de voir que  $`0.25 = 0 \times 2^{-1} + 1 \times 2^{-2}`$ : c'est sa décomposition en base 2
+
+Ainsi, on peut écrire :
+
+* $`123,25 = 11011111,01_2`$
+* En notation scientifique en base 2 : $`123,25 = 1,111101110_2 \times 2 ^7`$
+
+**Travail à faire**
+
+> Trouvez l'écriture scientifique en base 2 des nombres décimaux ci-dessous :
+>
+> * 8,5
+> * 12,125
+
+## Problème...
+
+Cherchons maintenant l'écriture scientifique de 0,1 en base 2.
+
+* $`0,1 \times 2 = 0,2`$ : partie entière **0** , la partie décimale restante est 0,2
+* $`0,2 \times 2 = `$
+
+**!! SPOILER plus bas, ne défilez pas avant d'avoir trouvé ! !!**
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+**Conclusion :**
+
+**On ne peut coder de façon exacte le nombre 0,1 en base 2.**
+
+**Et ce n'est pas le seul dans ce cas : la plupart des décimaux sont dans le même cas !**
+
+**On est donc contraint de faire une approximation !!**
+
+Allons un peu dans la console de Thonny :
+
+```Python
+>>> 0.1 + 0.1 + 0.1 == 0.3
+???
+```
+
+Ce n'est pas une erreur ou un bug de Python mais la conséquence d'une approximation liée au codage en base 2 :
+
+```python
+>>> 0.1 + 0.1 + 0.1
+???
+```
+
+> **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.**
+
+## IEEE-754
+
+Voir https://www.youtube.com/watch?v=mtizhxkB-Zw&ab_channel=Wandida%2CEPFL
+
+A compléter
+
+________
+
+Inspiré de Mieszczak Christophe CC BY SA

representation_base/seance_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/seance_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/seance_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` ?