mise à jour

representation_base/README.md

@@ -24,8 +24,8 @@ L'objet de cette séquence est de répondre à la question : __Comment sont cod
 
 Cette séquence se décompose en 5 chapitres :
 
-- [Chapitre 1 : Représentation d'un entier naturel](./seance_1/)
-- [Chapitre 2 : Représentation d'un entier relatif](./seance_2/)
-- [Chapitre 3 : Représentation d'un flottant](./seance_3/)
-- [Chapitre 4 : Représentation d'un booléen](./seance_4)
-- [Chapitre 5 : Représentation d'un texte](./seance_5/)
+- [Chapitre 1 : Représentation d'un entier naturel](./chapitre_1/)
+- [Chapitre 2 : Représentation d'un entier relatif](./chapitre_2/)
+- [Chapitre 3 : Représentation d'un flottant](./chapitre_3/)
+- [Chapitre 4 : Représentation d'un booléen](./chapitre_4/)
+- [Chapitre 5 : Représentation d'un texte](./chapitre_5/)

representation_base/chapitre_1/TP/COULEURS.ipynb

@@ -0,0 +1,207 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Un peu de couleurs\n",
+    "\n",
+    "## Contexte\n",
+    "\n",
+    "Le codage informatique le plus simple de la couleur consiste à donner, pour chaque pixel, c'est-à-dire pour tout élément de l'image, trois valeurs chacune sur un octet, correspondant directement à la luminosité. \n",
+    "\n",
+    "Un pixel d'une image, d'un écran est constitué de 3 composantes de luminophore:\n",
+    "\n",
+    "<center>\n",
+    "<span style='background-color: rgb(255, 0, 0);'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span style='background-color: rgb(0, 255, 0);'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span><span style='background-color: rgb(0, 0, 255);'>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</span>\n",
+    "</center>\n",
+    "\n",
+    "## Codage en RGB\n",
+    "\n",
+    "HTML et CSS acceptent la notation RGB `rgb(24,255,12)` où les nombres représentent la valeur en pourcentage pour le rouge, le vert et le bleu.\n",
+    "\n",
+    "Chaque nombre représente la valeur de la luminosité sur un octet (8 bits)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### À Faire\n",
+    "\n",
+    "1. Combien y a-t-il de valeurs possibles pour le rouge, vert et le bleu ? \n",
+    "2. Combien de couleurs totales peut-on coder avec 3 octets ?\n",
+    "3. Dans le code, modifier la valeur des composantes rgb pour changer la couleur du <span style='background-color: rgb(255, 255, 255);'>Fond du texte</span>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Codage condensé\n",
+    "\n",
+    "HTML et CSS acceptent également la notation condensée `#08A12C`, où le code après # agglutine trois valeurs hexadécimales qui sont directement celle des octets de commande des luminophores.\n",
+    "\n",
+    "Exemple : \n",
+    "\n",
+    "Le fond du texte suivant est en <span style='background-color: #808080;'>couleur grise</span>. \n",
+    "\n",
+    "En regardant le code source, on s'aperçoit que notation condensée de la couleur est : `#808080`. \n",
+    "\n",
+    "Il correspond à au codage RGB `rgb(128, 128, 128)` : <span style='background-color: rgb(128, 128, 128);'>couleur grise</span>\n",
+    "\n",
+    "### À Faire\n",
+    "\n",
+    "1. Convertir $80_{16}$ en base 10\n",
+    "2. Quel lien existe-t-il entre une composante RGB et le codage condensé d'une couleur ?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Couleurs de l'arc-en-ciel\n",
+    "\n",
+    "Un arc-en-ciel est un phénomène optique se produisant dans le ciel, visible dans la direction opposée au Soleil quand il brille pendant la pluie. C'est un arc de cercle coloré d'un dégradé de couleurs continu du rouge, à l'extérieur, au jaune au vert et au bleu, jusqu'au violet à l'intérieur.\n",
+    "\n",
+    "L'objectif est de reconstituer les couleurs d'un arc en ciel !\n",
+    "\n",
+    "En analysant le code source, les couleurs de fond sont manquantes, vous devez modifiez les codes pour afficher les couleurs correspondantes.\n",
+    "\n",
+    "<table>\n",
+    "<tr>\n",
+    "    <td style=\"background-color : rgb(255, 255, 255); color: black;\">Violet</td>\n",
+    "    <td style=\"background-color : #ffffff; color: black;\">Indigo</td>\n",
+    "    <td style=\"background-color : rgb(255, 255, 255); color: black;\">Bleu</td>\n",
+    "    <td style=\"background-color : #ffffff; color: black;\">Vert</td>\n",
+    "    <td style=\"background-color : rgb(255, 255, 255); color: black;\">Jaune</td>\n",
+    "    <td style=\"background-color : #ffffff; color: black;\">Orangé</td>\n",
+    "    <td style=\"background-color : rgb(255, 255, 255); color: black;\">Rouge</td>\n",
+    "</tr>\n",
+    "</table>\n",
+    "\n",
+    "Pour cela, vous disposez de la liste des valeurs des couleurs...en binaire :\n",
+    "\n",
+    "| Couleur | Valeur binaire |\n",
+    "| :--: | :--: |\n",
+    "| Violet | `10000000 00000000 10000000` |\n",
+    "| Indigo | `00110011 01100110 11111111` |\n",
+    "| Bleu | `00000000 11001100 11111111` |\n",
+    "| Vert | `10011001 11001100 00000000` |\n",
+    "| Jaune | `11111111 11001100 00000000`|\n",
+    "| Orangé | `11111111 01100110 00000000`|\n",
+    "| Rouge | `11111111 00000000 00000000`|\n",
+    "\n",
+    "### À Faire\n",
+    "\n",
+    "1. Convertir les valeurs binaires en décimales\n",
+    "2. Programmer les blocs d'instructions permettant de :\n",
+    "    1. convertir une couleur RGB en condensé,\n",
+    "    2. convertir une couleur condensé en RGB.\n",
+    "3. Modifier les codes couleurs du tableau pour afficher les couleurs de l'arc-en-ciel"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Conversion RGB $\\rightarrow$ condensé\n",
+    "\n",
+    "Ci-dessous, l'aide de la fonction `hex`, obtenue en exécutant `help(hex)`\n",
+    "\n",
+    "```python\n",
+    ">>>help(hex)\n",
+    "Help on built-in function hex in module builtins:\n",
+    "\n",
+    "hex(number, /)\n",
+    "    Return the hexadecimal representation of an integer.\n",
+    "    \n",
+    "    >>> hex(12648430)\n",
+    "    '0xc0ffee'\n",
+    "```\n",
+    "\n",
+    "Écrire les instructions qui permettent de convertir la valeur d'un RGB en condensé"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "la composante condensé de ( 0 , 0 , 0 ) est : None\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Conversion Codage RGB vers Codage condensé\n",
+    "\n",
+    "rouge = 0\n",
+    "vert = 0\n",
+    "bleu = 0 \n",
+    "\n",
+    "condense = None # valeur calculée du condensé de la couleur \n",
+    "\n",
+    "print(\"la composante condensé de (\", rouge, \",\", vert, \",\", bleu, \") est :\", condense)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Conversion condensé $\\rightarrow$ RGB\n",
+    "\n",
+    "Écrire les instructions qui permettent de convertir la valeur d'un condensé en RGB"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "la composante RGB de None est : 0 0 0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Conversion Codage condensé vers Codage RGB\n",
+    "\n",
+    "condense = None # valeur condensé de la couleur \n",
+    "\n",
+    "rouge = 0 # Extraire la valeur rouge de condense et la convertir en décimale\n",
+    "vert = 0 # Extraire la valeur verte de condense et la convertir en décimale\n",
+    "bleu = 0 # Extraire la valeur bleue de condense et la convertir en décimale\n",
+    "\n",
+    "print(\"la composante RGB de\", condense, \"est :\", rouge, vert, bleu)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

representation_base/chapitre_1/TP/SHADOK.md

@@ -0,0 +1,101 @@
+---
+title : TD - Les Shadoks
+author : M. BODDAERT, M. MIESZCZAK
+license : CC-BY-NC-SA
+---
+# Les Shadoks
+
+## Contexte
+
+Les Shadoks réussissent à compter avec seulement 4 mots de leur bien maigre vocabulaire : __GA BU ZO__ et __MEU__.
+
+Dans cette [vidéo](https://youtu.be/lP9PaDs2xgQ), le professeur Shadoko explique simplement la méthode employée par les Shadoks.
+
+Ci dessous, l'explication du professeur Shadoko:
+
+_"Notez bien. Quand il n'y a pas de Shadok, on dit __GA__ et on écrit __O__.
+Quand il y a un Shadok en plus on dit __BU__ et on écrit __I__.
+Quand il y a un Shadok en plus on dit __ZO__ et on écrit __L__.
+Quand il y a un Shadok en plus on dit __MEU__ et on écrit __◺__._
+
+_Quand il y a un Shadok en plus on se rend compte qu'on ne peut plus compter._
+
+_On met tous les Shadoks dans une poubelle et on a __BU__ poubelle et __GA__ Shadok._
+
+_Et on continue: __BUGA__; __BUBU__; __BUZO__...Et on continue_
+
+_Les Shadoks applaudirent sauf un. Le devin plombier s'écria et disait qu'on n'avait pas idée des mettre des dessins sur des poubelles et des Shadoks et que la meilleure chose à faire, c'était de brûler Shadoko. Les Shadoks applaudirent aussi._
+
+## Question 1
+
+Complétez le tableau suivant en comptant jusqu'à 20 en _Shadoks_.
+
+| Nombre | Shadok |
+| ---- | ---- |
+| 0    | GA   |
+| 1    | BU   |
+| 2    | ZO   |
+| 3    | MEU  |
+| 4    |      |
+| 5    |      |
+| 6    |      |
+| 7    |      |
+| 8    |      |
+| 9    |      |
+| 10   |      |
+| 11   |     |
+| 12   |     |
+| 13   |     |
+| 14   |     |
+| 15   |     |
+| 16   |     |
+| 17   |     |
+| 18   |     |
+| 19   |     |
+| 20   |     |
+
+## Question 2
+
+1. Nous, humains, utilisons le système décimale. Quel est le système de numération utilisé par les Shadoks ?
+2. Quelle méthode permet de convertir un nombre décimal en shadok ? et inversement ?
+
+## Question 3
+
+Sachant que  **ZO MEU GA** _shadoks_ correspond à $`(44)_{10}`$, convertissez les nombres shadoks suivants en décimal :
+
+1. BUBUZO
+2. MEUGABU
+
+Saurez vous sauver le professeur du bûcher,même si brûler le professeur est intéressant aussi faut dire, en révélant le nombre écrit sur le panneau ?
+
+3. BUZOGAMEU
+
+## Question 4
+
+Plus difficile maintenant, le professeur a dénombré 21 shadoks hostiles à son système de numération et 94 shadoks favorables. Saurez vous écrire ces 2 entiers en écriture shadok ?
+
+1. 21 
+2. 94 
+
+## Question 5
+
+Les shadoks parlent mais écrivent également !!
+
+Convertissez les entiers écrits en shadoks, en décimale :
+
+1. II0◺
+2. ◺I◺O
+3. IOIOIO
+
+## Question 6
+
+Le Professeur Shadoko s'étant enfui, les shadoks ont besoin d'un traducteur officiel décimal / shadok. 
+
+Convertissez en _écriture_ shadok, les nombres suivants :
+
+1. 33
+2. 3210
+2. Votre jour / mois et année de naissance ! Les Shadoks vous souhaiteront un bon anniversaire prochainement.
+
+
+

representation_base/chapitre_1/cours/README.md

@@ -8,7 +8,7 @@
 <br>
 
 
-![bo_1.png](/representation_base/assets/BO_1.PNG)
+![bo_1.png](/premiere/representation_base/assets/BO_1.PNG)
 
 
 ## <span style="color:blue"> Apport de connaissances </span>
@@ -33,7 +33,7 @@ Donc 4138 peut s’écrire : 4 * 10<sup>3</sup> + 1 * 10<sup>2</sup> + 3 * 10<su
 →où 10 est appelé BASE de cette numération (ici décimale)<br>
 →où chaque chiffre (compris entre 0 et 9) est soit celui des unités, dizaines, etc…
 
-![exercice_1.png](/representation_base/assets/exercice_1.PNG)
+![exercice_1.png](/premiere/representation_base/assets/exercice_1.PNG)
 
 ✏ *Un nombre est égal à la somme des valeurs de ses rangs, et on peut décomposer n'importe quel nombre en
 puissance de sa base.* ✏
@@ -45,9 +45,9 @@ contraction de **_binary digit_**, littéralement **_chiffre binaire_**. <br>Un
 En électronique, il est facile d'obtenir un système présentant deux états stables distincts. Prenons l'exemple
 d'un interrupteur
 
-![interrupteur.png](/representation_base/assets/interrupteur.PNG)
+![interrupteur.png](/premiere/representation_base/assets/interrupteur.PNG)
 
-![exemples.png](/representation_base/assets/exemples.PNG)
+![exemples.png](/premiere/representation_base/assets/exemples.PNG)
 
 Ainsi, pour coder une information qui peut ne prendre que deux états stables, la numération binaire est la
 plus adaptée.
@@ -63,7 +63,7 @@ l’occurrence 2 et 10), nous adoptons les notations suivantes.
 → Méthode des divisions successives <br>
 Exemple: (11)<sub>d</sub> = (?)<sub>b</sub>
 
-![10_vers_2.png](/representation_base/assets/10_vers_2.PNG)
+![10_vers_2.png](/premiere/representation_base/assets/10_vers_2.PNG)
 
 (11)<sub>d</sub> => (1011)<sub>b</sub>
 
@@ -81,7 +81,7 @@ Si nous généralisons un peu : avec **_k_** bits, nous pouvons coder **_2<sup>k
 
 Compléter le tableau suivant afin de coder les 8 premiers entiers naturels (entiers positifs ou nul)
 
-![tableau.png](/representation_base/assets/tableau.PNG)
+![tableau.png](/premiere/representation_base/assets/tableau.PNG)
 
 ### À faire vous-même 
 
@@ -96,7 +96,7 @@ Un octet ((**byte** en anglais) est un regroupement de 8 bits.
 On parle aussi de mot. Il permet de coder 2<sup>8</sup> = 256 mots différents.
 Si nous codons des entiers naturels, nous coderons les nombres 0 à 255. Dans la littérature, un regroupement de 4 bits est appelé un quartet (cela nous servira plus tard).
 
-![octet.png](/representation_base/assets/octet.PNG)
+![octet.png](/premiere/representation_base/assets/octet.PNG)
 
 ### <span style="color:violet">Unités de mesure</span>
 
@@ -126,7 +126,7 @@ Méthode :
 <li>Ecrire le nombre binaire dans le tableau de correspondance <br>
 <li>Faire la somme des valeurs des rangs pour lesquels la valeur du bit vaut 1.
 
-![2_vers_10.png](/representation_base/assets/2_vers_10.PNG)
+![2_vers_10.png](/premiere/representation_base/assets/2_vers_10.PNG)
 
 Somme : ............
 
@@ -153,11 +153,11 @@ Ce sera donc un système en **base 16**.
 
 > Compléter la colonne binaire
 
-![binaire.png](/representation_base/assets/binaire.PNG)
+![binaire.png](/premiere/representation_base/assets/binaire.PNG)
 
 > Passer de la base décimale à la base hexadécimale <br> Écrire le nombre 63650 (10) en base 16
 
-![exercice_2.png](/representation_base/assets/exercice_2.PNG)
+![exercice_2.png](/premiere/representation_base/assets/exercice_2.PNG)
 
 > Faisons la conversion de la base 16 vers la base 10, écrire le nombre 2A3 (16) en base décimale
 
@@ -165,7 +165,7 @@ Méthode :
 <li>Ecrire le nombre hexadécimal dans le tableau de correspondance en positionnant le chiffre correspondant à chacun des rangs.
 <li> Faire la somme des produits des chiffres avec la pondération correspondante.
 
-![tableau-hexa.png](/representation_base/assets/tableau_hexa.PNG)
+![tableau-hexa.png](/premiere/representation_base/assets/tableau_hexa.PNG)
 
 > Passer du code binaire au code hexadécimal
 
@@ -189,7 +189,7 @@ Pour passer d'une base à une autre, on passera par la base 10 car c'est sur cet
 
 Exemple : (944)<sub>10</sub> → ( 12234)<sub>5</sub>
 
-![base_quelconque.png](/representation_base/assets/Base_quelconque.PNG)
+![base_quelconque.png](/premiere/representation_base/assets/Base_quelconque.PNG)
 
 -------------------------
 
@@ -201,24 +201,24 @@ Prenons l'exemple d'un mot de 2 octets (16 bits) comme 5BC9. Il y a deux organis
 
 <li> Le gros boutisme (ou ou « mot de poids fort en tête » ou big endian en anglais), qui consiste à placer l'octet de poids fort en premier, c'est à dire à l'adresse mémoire la plus petite.
 
-![gros_boutisme.png](/representation_base/assets/gros_boutisme.PNG)
+![gros_boutisme.png](/premiere/representation_base/assets/gros_boutisme.PNG)
 
 > Quelques architectures respectant cette règle : _les processeurs Motorola 68000, les SPARC (Sun Microsystems) ou encore les System/370 (IBM)_. De plus, tous les protocoles TCP/IP communiquent en gros-boutiste. Il en va de même pour le protocole PCI Express.
 
 <li>Le petit boutisme (ou little endian en anglais), qui au contraire place l'octet de poids faible en premier.
 
-![petit_boutisme.png](/representation_base/assets/petit_boutisme.PNG)
+![petit_boutisme.png](/premiere/representation_base/assets/petit_boutisme.PNG)
 
 > Les processeurs x86 ont une architecture petit-boutiste. Celle-ci, au prix d'une moindre lisibilité du code machine par le programmeur, simplifiait la circuiterie de décodage d'adresses courtes et longues en 1975, quand un 8086 avait 29 000 transistors. Elle est d'influence pratiquement nulle aujourd’hui.
 
 Généralisons pour 4 octets. Ainsi, le mot 5BC96AF sera représenté de la manière suivante :
 en **gros boutisme**
 
-![gros_boutisme_2.png](/representation_base/assets/gros_boutisme_2.PNG)
+![gros_boutisme_2.png](/premiere/representation_base/assets/gros_boutisme_2.PNG)
 
 en **petit boutisme**
 
-![petit_boutisme_2.png](/representation_base/assets/petit_boutisme_2.PNG)
+![petit_boutisme_2.png](/premiere/representation_base/assets/petit_boutisme_2.PNG)
 
 La représentation petit ou gros boutisme est en principe transparente à l'utilisateur car cela est géré au niveau du système d'exploitation. Cette représentation prend de l'importance quand on accède aux octets soit en mémoire, soit lors d'échanges d'informations sur un réseau.
 

representation_base/chapitre_1/exercices/README.md

@@ -1,11 +1,35 @@
-# Convertisseur
+# Codage des entiers
+
+## Exercice 1
+
+Donner l'écriture décimale des entiers ci-dessous positifs codés en binaire sur un octet sans complément à 2.
+
+- $`00001000_2`$ = 
+- $`00001011_2`$ =
+- $`10000001_2`$=
+- $`11111110_2`$
+- $`01000010_2`$ =
+
+## Exercice 2
+
+Donner l'écriture binaire des entiers positifs ci-dessous sur un octet sans complément à 2.
+
+* 203 = 
+* 47 = 
+* 23 = 
+* 237 = 
+* 33 =
+* 24 =
+* 128 =
+* 255 =
+
+## Exercice 3
+
 
 Certaines oeuvres (film, livre, série...) contiennent un nombre dans leur titre. L'objectif est d'écrire les nombres en base 2, ce qui donne une toute autre lecture des titres...
 
 Exemple : Terminator $`2`$ $`\rightarrow`$ Terminator $`\overline{10}^2`$
 
-## Titre de films
-
 - Les **4** Fantastiques
 - Le **6**ème sens
 - Blanche neige et les **7** nains
@@ -22,29 +46,54 @@ Exemple : Terminator $`2`$ $`\rightarrow`$ Terminator $`\overline{10}^2`$
 - **28** jours plus tard
 - Les **Quatre Cents** Coups
 
-## Titre de livres
+## Exercice 4
 
-- Entretien avec **un** vampire, d'Anne rice
-- L'homme **bicentenaire**, Isaac Asimov
-- Les **Trois** Mousquetaires, Alexandre Dumas
-- Les **Quatre** Filles du docteur March, Louisa May Alcott
-- Blanche-Neige et les **sept** nains, Frères Grimm
-- **Cinquante** nuances de Grey, E.L. James
-- Le Tour du monde en **80** jours, Jules Verne
-- **99** francs, Frédéric Beigbeder
-- Fahrenheit **451**, Ray Bradbury
-- Les **Mille et Une** Nuits
-- **1984**, Georges Orwell
-- Ils étaient **dix**, Agatha Christie
-- **Vingt mille** lieues sous les mers
+Poser les additions de ces nombres binaires, tous positifs et codés sans complément à 2. Donner la valeur en base 10 du résultat.
 
-## Expressions
+* $`10_2+10_2`$
+* $`101_2+11_2`$
+* $`10001_2+11010_2`$
+* $`1101_2+10101_2`$
 
-- Être unis comme les **cinq** doigts de la main
-- L’art de faire du **neuf** avec du vieux
-- Chercher **midi** à **quatorze** heures
+## Exercice 5
 
-## Recette
+Convertir en hexadécimal :
+
+* 203 =
+* 47 = 
+* 23 = 
+* 237 = 
+* 33 =
+* 24 =
+
+De même avec les entiers positifs ci-dessous codés sans compléments à 2.
+
+* $`10110010_2 = `$
+* $`10011001_2 = `$
+
+## Exercice 6
+
+Convertir en base 10.
+
+* $`1F_{16} = `$
+* $`13_{16} = `$
+* $`45_{16} = `$
+* $`FF_{16} = `$
+* $`FAB_{16} = `$
+* $`ABCD_{16} = `$
+
+## Exercice 7
+
+Convertir en base 10.
+
+- Un homme a $`14_{16}`$ doigts, si on compte les orteils !
+- En zone résidentielle, la vitesse est souvent limitée à $`1E_{16}`$ km/h.
+- La vitesse sur les autoroutes françaises est limitée à $`82_{16}`$ km/h.
+- Dans des conditions normales, l'eau bout à $`64_{16}`$ ºC.
+- Le revenu annuel médian en France s'élève à $`6EA_{16}`$ euros.
+- La population mondiale dépasse les $`1A0 000 000_{16}`$ habitants
+
+## Exercice 8
 
 Une recette de cuisine demande de la précision. 
 

representation_base/chapitre_2/README.md

@@ -116,7 +116,7 @@ Dans l'opération ci-dessus, nous avons un 1 pour le 9ième bit, mais comme notr
 - Quel est le plus petit entier négatif que l'on peut représenter sur huit (8) bits ?
 - Et quel est le le plus grand ?
 
-# ✎ Remarque ✎:
+# ✎ Remarque ✎ :
 
 Plus généralement, nous pouvons dire que pour une représentation sur $`n`$ bits, il sera possible de coder des valeurs comprises entre $`-2^{n-1}`$ et $`+2^{n-1} - 1`$ .
 
@@ -125,3 +125,4 @@ Sachant que dans le langage C, les entiers signés sont codés sur 32 bits, dont
 En Python, la taille des entiers est arbitraire (donc non fixe), ainsi les valeurs minimale et maximale des entiers ne dépend que de la quantité de mémoire disponible sur votre machine.
 
 Néanmoins, on dispose de la bibliothèque _numpy_ qui permet de forcer une représentation sur 8 bits, par exemple, à l'aide de la fonction *int8*
+

representation_base/chapitre_2/exercices/README.md

@@ -0,0 +1,38 @@
+# Exercices
+
+## Exercice 1
+
+Donner la représentation binaire en complément à 2 des entiers relatifs suivants sur 8 bits: 25, -30, -124,100
+
+## Exercice 2
+
+Soit le nombre écrit en binaire en complément à 2: $`00110110`$. Donner le signe de ce nombre. Ecrire en binaire l'opposé de ce nombre.
+
+## Exercice 3
+
+Peut-on écrire un nombre en binaire en complément à 2 sur 16 bits ? Si oui, donner un exemple de nombre négatif.
+
+## Exercice 4
+
+1. L'ours polaire peut atteindre 26m de profondeur et l'orque 109m. Donner les représentations en binaire en complément à 2 sur 8 bits de ces profondeurs.
+Quelles opérations permet de vérifier l'exactitude de vos calculs ?
+2. Le zéro absolu est la température la plus basse qui puisse exister. Selon un accord international, la valeur du zéro absolu est fixée à −273,15 °C. Nous allons l'arrondir à -273°C. Combien de bits sont nécessaires pour le représenter en binaire en complément à 2 ? Donner sa représentation binaire sur le nombre de bits identifiés.
+3. Le point le plus profond atteint par un homme en plongée sous-marine est de $`1010110100_2`$. Donner sa représentation en décimale. 
+4. La température minimale $`T_{min}`$ jamais observée en europe est $`1000110`$. Sans calculer la valeur en décimale donner à quelle température minimale puissance de 2 $`T_k`$, $`T_{min} > T_k`$.
+
+## Exercice 5
+
+Soit les nombres écrits en binaire en complément à 2 sur 8 bits: $`a=10101010`$ et $`b=01101101`$. Calculer $`a+b`$ en binaire. Ecrire $`a`$ et $`b`$ en décimal et vérifier le résultat de votre addition.
+
+## Exercice 6
+
+Soit les nombres écrits en binaire en complément à 2 sur 8 bits: $`c=10001011`$ et $`d=00010101`$. Calculer $`c+d`$ en binaire. Ecrire $`c`$ et $`d`$ en décimal et vérifier le résultat de votre addition.
+
+## Exercice 7
+
+Soit $`e=10011100`$ et $`f=00010101`$ en binaire signés sur 8 bits. Calculer $`e-f`$ en binaire et en décimal. Que constatez vous?
+
+Calculer $`c-d`$ (cf exercice 5) en binaire et en décimal. Que constatez-vous? Pourquoi ?
+
+
+

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/seance_2/exercices/README.md

@@ -1,16 +0,0 @@
-- 10924 : Point le plus profond, située au fond de l’océan Pacifique, la fosse des Mariannes. En 2020, le submersible Fendouzhe a plongé à cette profondeur et a observé des traces de pollution humaine (bouteille et sac en plastique) https://www-francetvinfo-fr.cdn.ampproject.org/c/s/www.francetvinfo.fr/meteo/climat/video-un-submersible-chinois-au-coeur-des-eaux-les-plus-profondes-de-la-terre_4192715.amp
-
-- 26 : Ours polaire
-- 109 : Orque
-- 273 : Grand requin blanc
-- 332 : Point le plus profond atteint par un homme en plongé sous-marine (Ahmed Gabr in 2014)
-- 1024 : Début de la Midnight zone. Aucun rayon solaire n'est capable d'atteindre cette profondeur
-- 1596 : Hydrothermal vents are formed from seawater passing through extremely hot volcanic rocks. They release heavy metals that are toxic to most animals. But even in those extreme conditions specialized life finds a way to survive.
-- 3005 : Cuvier's Beaked Whales are the deepest diving mammals.
-- 3688 : Profondeur moyenne des océans
-- 3800 : On April 14th, 1912 the Titanic sank to its final resting place at a depth of 3,800 meters.
-- 4000 : The Abyssal Zone
-- 6000 : The Hadal Zone. More people have been to the Moon than the Hadal Zone.
-- 6227 : The USS Johnston sank in WWII and is the deepest shipwreck ever found.
-- 8848 : Équivalent de l'altitude du mont Everest
-- 10225 : Hadal Amphipod

representation_base/seance_3/README.md

@@ -1,157 +0,0 @@
-# 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