maj chapitre 3

representation_base/chapitre_3/README.md

@@ -1,12 +1,12 @@
 # Représentation des décimaux : les flottants
 
-## 1. Attendus
+## Le Programme
 
-| 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. |
+![bo.png](assets/bo.png)
 
-## 2. Contexte 
+-------
+
+## 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:
 
@@ -15,7 +15,7 @@ Nous avons appris à encoder des nombres entiers naturels, et relatifs, et nous
 
 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
+###  À Faire
 
 1. effectuez le calcul $`0.2 + 0.1`$ en Python :
 
@@ -39,7 +39,9 @@ Maintenant que nous allons tenter de coder les réels, les limites de notre mach
 
 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
+---------------------
+
+## Codage de la virgule
 
 Il existe deux façons de coder les nombres réels, en virgule fixe ou virgule flottante.
 
@@ -57,16 +59,16 @@ C’est extrêmement simple. Cette manière de faire s’appelle virgule fixe, c
 
 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
+#### À Faire
 
 Représenter les valeurs suivants sur 8 bits, en virgule fixe :
 
 1. 7,75
 2. 0,1
 
-### 3.2. Virgule flottante
+### Virgule flottante
 
-#### 3.2.1. Notation scientifique
+#### 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}^*`$ 
 
@@ -81,14 +83,14 @@ Le terme __exposant__ correspond à la puissance de 10, et le terme __mantisse__
 - la mantisse (ou significande) est « 1,23 » ;
 - l'exposant est « -2 ».
 
-##### 3.2.1.1. À Faire
+##### À 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
+#### 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}`$.
 
@@ -101,7 +103,34 @@ Par exemple :
 
 _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
+
+
+#### 3.2.3 Passage de l'écriture décimale à l'écriture binaire pour un nombre flottant
+
+Si vous avez bien suivi, vous savez qu'un nombre est composé de deux parties :
+
+- partie entière, à gauche de la virgule
+- partie décimale (ou fractionnaire), à droite de la virgule
+
+On traite ces deux parties indépendamment l'une de l'autre :
+
+- La partie entière va s'écrire comme nous l'avons appris précédemment.
+
+- Pour la partie décimale, on va procéder par multiplications par 2 successivement.
+  - Après chaque multiplication, le résultat est reporté sans sa partie entière
+  - On poursuit les multiplications jusqu'à obtenir 1 comme résultat.
+  - On prend la partie entière de chaque résultat, de haut en bas, pour obtenir l'écriture binaire du nombre.
+
+Exemple : 
+
+- $` 0,6875 \times 2 = **1**,375`$
+- $`0,375  \times 2 = **0**,75 `$
+- $`0,75 \times 2 = **1**,5`$
+- $`0,5 \times 2 = **1** `$
+
+0,6875 s'écrit donc 0,1011<sub>2</sub>
+
+#### 3.2.4. Principe du codage en virgule flottante
 
 Un nombre flottant est formé de trois éléments : la mantisse, l'exposant et le signe. 
 
@@ -132,6 +161,10 @@ Supposons un nombre flottant codé sur un octet utilisant 1 bit de signe, 3 bits
 
 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.
@@ -201,6 +234,8 @@ $`2^{-23}`$ . On ne peut pas trouver un flottant compris entre les deux.
 
 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