francois.lesueur
/
R1.03
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

découpage du cours sur les nombres

master
Francois Lesueur 2 years ago
parent
0c7d7c00aa
commit
c8f30f8989
4 changed files with 58 additions and 59 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 10
      README.md
  2. 54
      cm2-entiers.md
  3. 51
      cm3-reels.md
  4. 2
      cm4-archi.md

10
README.md
View File

@ -22,11 +22,11 @@ Sur ce dépôt, vous trouverez les notes de cours ainsi que les sujets des TD/TP
Le programme prévisionnel est le suivant :
* CM :
- [CM1](cm1-caracteres.md) : Codage des caractères
- [CM2](cm2-nombres.md) : Codage des entiers et réels
- [CM3](cm3-archi.md) : Architecture d'un ordinateur
- CM4 : Calcul booléen
- CM5 : Histoire de l'informatique et des ordinateurs
- CM6 : Histoire du libre, de l'open-source et du captif
- [CM2](cm2-entiers.md) : Codage des entiers
- [CM3](cm3-reels.md) : Codage des réels
- [CM4](cm4-archi.md) : Architecture d'un ordinateur
- CM5 : Calcul booléen
- CM6 : Histoire
* TD :
- [TD1](td1-caracteres.md) : Codage des caractères
- [TD2](td2-entiers.md) : Codage des entiers

54
cm2-nombres.md → cm2-entiers.md
View File

@ -1,4 +1,4 @@
CM2 Codage des nombres - Notes de cours
CM2 Codage des entiers - Notes de cours
=======================================
Quizz : Combien vaut 0.1 + 0.2 ?
@ -91,55 +91,3 @@ Représentation des entiers relatifs
- Débordement ([char2.c](cm2-nombres-code/char2.c)) :
- 127 + 1 = 128
- 0111 1111 + 0000 0001 = 1000 0000 -> -128
Les réels
=========
Ici, 0.1 + 0.2 = 0.30000000000004 ([détails ici](https://0.30000000000000004.com/)) ([double.c](cm2-nombres-code/double.c))
Virgule fixe
------------
- Un réel = une partie entière et une partie fractionnaire séparés par une ','
- On code par exemple sur 2 octets :
- 1 octet pour la partie réelle en complément à 2 (entier relatif)
- 1 octet pour la partie fractionnaire en inverse : 1/2, 1/4, 1/8, 1/16, etc. (était en décimal 1/10, 1/100, 1/1000, etc.)
- Il n'y a pas 1/10 ! -> On ne peut que s'approcher de 0.1, 0.2 et 0.3...
- Comme on écrit des nombres en décimal et qu'on les approxime avec des 1/2, 1/4, 1/8, etc. :
- 0.1 n'est pas exactement 0.1
- 0.2 n'est pas exactement 0.2
- donc 0.1 + 0.2 n'est pas exactement 0.3
- Note : un nombre en binaire sera aussi approximé pour repasser en base 10...
- L'approximation n'est pas forcément visible car nous utilisons une précision assez grande mais elle est là
- => Pas de calcul décimal exact en réels, **pas de tests d'égalités** !!!
- égalités entre entiers seulement
- au pire test d'écart à la valeur recherchée (mais c'est critiqué, les incertitudes ne se propagent pas d'une bonne manière)
- Utilisé en pratique si pas mieux dispo (micro-contrôleur sans unité à virgule flottante par exemple)
Virgule flottante
-----------------
- Signe (1 bit), exposant, mantisse
- Nombre = signe * mantisse * 2<sup>exposant</sup>
- En C, float (32 bits, peu précis à l'usage) et double (64 bits, plus précis)
- Exemple du double : 1 bit de signe, 11 bits d'exposant, 52 bits de mantisse (norme IEE754)
- Les mêmes approximations que précédemment ! (et donc pas non plus de tests d'égalité !!!)
- Couramment utilisé
- ([floatdouble.c](cm2-nombres-code/floatdouble.c))
Calcul exact (bonus, hors programme)
------------------------------------
Pour aller au-delà de ces limites, il faudra utiliser des biblothèques/logiciels dédiés au calcul, par exemple [SageMath](https://www.sagemath.org/), [Calcium](https://fredrikj.net/calcium/), du décimal codé binaire (DCB) ou encore les [fractions python](https://docs.python.org/3/library/fractions.html) (mais c'est une autre histoire...). Ici, on pourra avoir 0.1 + 0.2 = 3. Les nombres ne sont alors plus représentés comme les types de base vus précédemment qui sont les seuls sur lesquels savent calculer les CPU classiques, mais comme des types construits à plus haut niveau. Points d'attention :
- les calculs sont plus lents, car un calcul de ce type construit impliquera plusieurs calculs sur des types de base au niveau CPU
- les types que vous manipulerez par défaut dans les langages de programmation les plus courants sont uniquement les types de base, efficaces mais donc inexacts.
Annexes
=======
- [Entiers, virgules flottantes ou représentations exotiques ... (Olivier Poncet et Fabien Trégan, DevoxxFR 2022)](https://www.youtube.com/watch?v=1upzDFFIODk). Vidéo de 45 minutes, dont 15 premières minutes sur le programme de cette séance.

51
cm3-reels.md
View File

@ -0,0 +1,51 @@
CM3 Codage des réels - Notes de cours
======================================
Ici, 0.1 + 0.2 = 0.30000000000004 ([détails ici](https://0.30000000000000004.com/)) ([double.c](cm2-nombres-code/double.c))
Virgule fixe
------------
- Un réel = une partie entière et une partie fractionnaire séparés par une ','
- On code par exemple sur 2 octets :
- 1 octet pour la partie réelle en complément à 2 (entier relatif)
- 1 octet pour la partie fractionnaire en inverse : 1/2, 1/4, 1/8, 1/16, etc. (était en décimal 1/10, 1/100, 1/1000, etc.)
- Il n'y a pas 1/10 ! -> On ne peut que s'approcher de 0.1, 0.2 et 0.3...
- Comme on écrit des nombres en décimal et qu'on les approxime avec des 1/2, 1/4, 1/8, etc. :
- 0.1 n'est pas exactement 0.1
- 0.2 n'est pas exactement 0.2
- donc 0.1 + 0.2 n'est pas exactement 0.3
- Note : un nombre en binaire sera aussi approximé pour repasser en base 10...
- L'approximation n'est pas forcément visible car nous utilisons une précision assez grande mais elle est là
- => Pas de calcul décimal exact en réels, **pas de tests d'égalités** !!!
- égalités entre entiers seulement
- au pire test d'écart à la valeur recherchée (mais c'est critiqué, les incertitudes ne se propagent pas d'une bonne manière)
- Utilisé en pratique si pas mieux dispo (micro-contrôleur sans unité à virgule flottante par exemple)
Virgule flottante
-----------------
- Signe (1 bit), exposant, mantisse
- Nombre = signe * mantisse * 2<sup>exposant</sup>
- En C, float (32 bits, peu précis à l'usage) et double (64 bits, plus précis)
- Exemple du double : 1 bit de signe, 11 bits d'exposant, 52 bits de mantisse (norme IEE754)
- Les mêmes approximations que précédemment ! (et donc pas non plus de tests d'égalité !!!)
- Couramment utilisé
- ([floatdouble.c](cm2-nombres-code/floatdouble.c))
Calcul exact (bonus, hors programme)
------------------------------------
Pour aller au-delà de ces limites, il faudra utiliser des biblothèques/logiciels dédiés au calcul, par exemple [SageMath](https://www.sagemath.org/), [Calcium](https://fredrikj.net/calcium/), du décimal codé binaire (DCB) ou encore les [fractions python](https://docs.python.org/3/library/fractions.html) (mais c'est une autre histoire...). Ici, on pourra avoir 0.1 + 0.2 = 3. Les nombres ne sont alors plus représentés comme les types de base vus précédemment qui sont les seuls sur lesquels savent calculer les CPU classiques, mais comme des types construits à plus haut niveau. Points d'attention :
- les calculs sont plus lents, car un calcul de ce type construit impliquera plusieurs calculs sur des types de base au niveau CPU
- les types que vous manipulerez par défaut dans les langages de programmation les plus courants sont uniquement les types de base, efficaces mais donc inexacts.
Annexes
=======
- [Entiers, virgules flottantes ou représentations exotiques ... (Olivier Poncet et Fabien Trégan, DevoxxFR 2022)](https://www.youtube.com/watch?v=1upzDFFIODk). Vidéo de 45 minutes, dont 15 premières minutes sur le programme de cette séance.

2
cm3-archi.md → cm4-archi.md
View File

@ -1,4 +1,4 @@
CM3 Architecture - Notes de cours
CM4 Architecture - Notes de cours
=================================
J'ai quoi dans un ordinateur ?
Write Preview
Loading…
Cancel
Save