diff --git a/cm2-nombres.md b/cm2-nombres.md
new file mode 100644
index 0000000..cab7df3
--- /dev/null
+++ b/cm2-nombres.md
@@ -0,0 +1,136 @@
+CM2 Codage des nombres - Notes de cours
+=======================================
+
+Quizz : Combien vaut 0.1 + 0.2 ?
+- 0
+- -0
+- 0.3
+- 0.30000000000004
+
+Aujourd'hui on va répondre à cette question...
+
+
+Encore et toujours du binaire
+=============================
+
+- Élément de base : binaire
+- Regroupés en octets (8 bits)
+- Qu'on peut regrouper encore (par exemple 4 octets = 32 bits, 8 octets = 64 bits)
+- Sur 4 octets par exemple, 2<sup>32</sup> possibilités, ça ne va pas nous permettre de calculer jusqu'à l'infini...
+  - 2 bits : 2 valeurs (0 et 1)
+  - 8 bits : 256 valeurs (de 0 à 255) -> une partie d'IPv4, une table de caractères
+  - 16 bits : 65 536 valeurs (de 0 à 65 535)
+  - 32 bits : 4 294 967 296 valeurs -> le nombre d'IPv4, la limite à 4GB de RAM des machines/OS 32 bits
+
+La notion de type
+=================
+
+- Langage typé ou non, chaque donnée (nombre) est une interprétation d'un code binaire par rapport à un type
+  - Langage typé (fortement) ≃ le développeur explicite les types
+  - Langage non typé (faiblement typé) ≃ le développeur n'explicite pas les types
+  - Mais les types sont toujours là en-dessous !!!
+  - Pour rire un peu : [c'est le bazar](https://fr.wikipedia.org/wiki/Typage_fort)
+
+- Les types de base : ceux du C, ceux qui sont compris par les microprocesseurs, donc calcul natif et donc rapide
+  - int (pour les entiers)
+  - float, double (pour les réels)
+  - char (pour les... octets !)
+- Les types construits : on les construit à la main par composition de ces types de base
+  - les nombres complexes
+  - les grands entiers (de taille non limitée)
+  - les coordonnées d'un point
+  - ...
+
+- Les types de taille fixe (dont les types de base)
+- Les types de taille variable/infinie (des types construits, les nombres que l'on écrit au crayon sur une feuille !)
+
+- Mapper cet infini habituel sur nos feuilles vers un ordinateur : KO !
+
+Les entiers
+===========
+
+Ici, 0.1 + 0.2 = 0 (int.c)
+
+Représentation des entiers positifs
+-----------------------------------
+
+- Changement de base "simple" (TD2)
+- 155<sub>10</sub> -> 1001 1011<sub>2</sub> (0x9B)
+
+Exemple simple d'addition (char.c) :
+- 155 + 3 = 158
+- 1001 1011 + 0000 0011 = 1001 1110
+
+Mais le débordement :
+- 155 + 155 = 310
+- **MAIS** 1001 1011 + 1001 1011 = 1 0011 0110 -> 0011 0110 = 54 (= 310 - 256)
+
+
+Représentation des entiers relatifs
+-----------------------------------
+
+- Valeur absolue signée
+  - Un bit de signe puis la valeur absolue
+  - Sur 1 octet : 1 bit de signe, 7 bits de valeur
+  - 1001 1011 -> -27 ;-)
+  - Convention d'interprétation du binaire par le type...
+  - 0000 0000 -> 0, 1000 000 -> -0 => 0.1 + 0.2 == -0 (int2.c)
+  - Pas très pratique...
+
+- Complément à 2
+  - Un seul 0 : 0000 0000
+  - 1 -> 0000 0001
+  - -1 -> 1111 1111
+  - 127 -> 0111 1111
+  - -128 -> 1000 0000
+  - Pratique (et utilisé pour les types entiers) car :
+    - un seul 0
+    - les opérations sont identiques à celles pour un entier non signé
+  - Détails [ici](https://fr.wikipedia.org/wiki/Compl%C3%A9ment_%C3%A0_deux)
+
+- Débordement (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)
+
+
+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é)
+- 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é
+
+
+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.