cours_01_D.ipynb

{"cells":[{"metadata":{"hide_input":true,"hide_output":true,"init_cell":true,"run_control":{"marked":false},"trusted":true},"cell_type":"code","source":"# Permet de tout executer au lancement du notebook + conserver le notebook actif pendant 2h\nfrom IPython.display import Javascript\nfrom masquer import *\nJavascript(\"\"\"\nfunction repeter(){\nIPython.notebook.kernel.execute(\"a=1\");\n}\n// execute a = 1 en python toutes les 8 minutes pendant 2h\nlet timerId = setInterval(() => repeter(), 4800);\nsetTimeout(() => { clearInterval(timerId); alert('fin de cession'); }, 7200000);\n\n// Supprimer la taille limite pour la sortie d'une cellule\nIPython.OutputArea.prototype._should_scroll = function(lines) {\n    return false;\n};\nIPython.notebook.kernel.execute(\"url = '\" + window.location + \"'\");\n\n// Exécuter toutes les cellule du notebook\n    require(\n        ['base/js/namespace', 'jquery'], \n        function(jupyter, $) {\n            \n                \n                jupyter.actions.call('jupyter-notebook:run-all-cells-below');\n                jupyter.actions.call('jupyter-notebook:save-notebook');\n                Jupyter.actions.call('jupyter-notebook:hide-header')\n\n        }\n    );\"\"\")","execution_count":2,"outputs":[{"output_type":"execute_result","execution_count":2,"data":{"text/plain":"<IPython.core.display.Javascript object>","application/javascript":"\nfunction repeter(){\nIPython.notebook.kernel.execute(\"a=1\");\n}\n// execute a = 1 en python toutes les 8 minutes pendant 2h\nlet timerId = setInterval(() => repeter(), 4800);\nsetTimeout(() => { clearInterval(timerId); alert('fin de cession'); }, 7200000);\n\n// Supprimer la taille limite pour la sortie d'une cellule\nIPython.OutputArea.prototype._should_scroll = function(lines) {\n    return false;\n};\nIPython.notebook.kernel.execute(\"url = '\" + window.location + \"'\");\n\n// Exécuter toutes les cellule du notebook\n    require(\n        ['base/js/namespace', 'jquery'], \n        function(jupyter, $) {\n            \n                \n                jupyter.actions.call('jupyter-notebook:run-all-cells-below');\n                jupyter.actions.call('jupyter-notebook:save-notebook');\n                Jupyter.actions.call('jupyter-notebook:hide-header')\n\n        }\n    );"},"metadata":{}}]},{"metadata":{"slideshow":{"slide_type":"slide"}},"cell_type":"markdown","source":"# <span style=\"color:red;\"><center>Chapitre 1 : Représentation des données : types et valeurs de base</center></span>"},{"metadata":{"slideshow":{"slide_type":"-"}},"cell_type":"markdown","source":"## D. Représentation binaire des nombres réels"},{"metadata":{"slideshow":{"slide_type":"slide"}},"cell_type":"markdown","source":"### I. Nombres réels et décimaux (rappels de collège)\n\n#### 1. Les nombres décimaux\n\n**Définition**\n\nUn nombre $d$ est dit décimal s'il peut s'écrire sous la forme d'une **fraction décimale** :\n$$d=\\frac{N}{10^{\\,p}}\\text{ où } N\\in \\mathbb{Z} \\text{ et } p \\in \\mathbb{N}$$\n\nEvidemment, les nombre entiers sont des nombres décimaux ($p = 0$) par contre, toutes les fractions (nombres rationnels) ne sont pas des décimaux (essayez avec $1/3$)."},{"metadata":{"slideshow":{"slide_type":"subslide"}},"cell_type":"markdown","source":"#### 2. Les nombres réels\n\n**Tous les nombres sont réels** : qu'ils soient entiers à virgule, positif ou négatif, avec un nombre de chiffres après la virgule fini ou pas, ...\n\nMis à part les nombres complexes que vous ne connaissez pas encore et peut être d'autres bizarreries mathématiques que je ne connais pas non plus. ;)\n"},{"metadata":{"heading_collapsed":true,"slideshow":{"slide_type":"subslide"}},"cell_type":"markdown","source":"#### 3. Schéma bilan sur les ensembles de nombres\n\n![schéma](https://cdn.thinglink.me/api/image/798641180488237056/1240/10/scaletowidth)"},{"metadata":{"slideshow":{"slide_type":"subslide"}},"cell_type":"markdown","source":"#### 4. Et en informatique ?\n\nEn informatique, nous avons déjà vu les entiers naturels et relatifs, **tous les autres nombres sont des nombres décimaux**.\n\nEn effet, les nombres réels qui ne sont pas des décimaux sont composés d'un nombre infini de chiffres, il faudrait donc une mémoire informatique de taille infinie pour les stocker. Comme au contraire, la **taille allouée au stockage d'un nombre dans un ordinateur est très limitée** (quelques octets), un ordinateur ne peut traiter que des **approximations de ces nombres** (qui peuvent cependant être très bonnes) **sous forme de nombres décimaux.**\n\n"},{"metadata":{"slideshow":{"slide_type":"subslide"}},"cell_type":"markdown","source":"Il est très important de comprendre que du fait cette **limitation de la quantité de mémoire allouée au stockage des nombres**, un ordinateur ne fait, le plus souvent, des **calculs exacts qu'avec les nombres entiers**. Ainsi, pour un ordinateur, $\\sqrt{2}^2 \\ne 2$ :"},{"metadata":{"slideshow":{"slide_type":"-"},"trusted":true},"cell_type":"code","source":"# La preuve\nfrom math import *\nprint(sqrt(2)**2)\nprint (sqrt(2)**2 == 2)","execution_count":3,"outputs":[{"output_type":"stream","text":"2.0000000000000004\nFalse\n","name":"stdout"}]},{"metadata":{"slideshow":{"slide_type":"slide"}},"cell_type":"markdown","source":"### II. Convertir un nombre réel en binaire\n\n#### 2.1 Ecriture d'un nombre décimal en base 10 (programme de 5ème)\nQuand on écrit le nombre 23,375 en base 10, cela signifie que ce nombre s'obtient en faisant la somme de 2 dizaines, plus 3 unités, plus 3 dixièmes, plus 7 centièmes, plus 5 millièmes.\n\nSoit mathématiquement :\n\n$$ 23,375 = 2 \\times 10^1 + 3 \\times 10^0 + 3 \\times 10^{-1} + 7 \\times 10^{-2} + 5 \\times 10^{-3}$$\n"},{"metadata":{"slideshow":{"slide_type":"subslide"}},"cell_type":"markdown","source":"#### 2.2 Ecriture d'un nombre dyadique en binaire\nOn peut très bien faire exactement la même chose en binaire. On décompose la **partie entière** en une somme de **puissances positives de 2** (c'est l'écriture binaire classique d'un nombre entier) et la **partie décimale** en une somme de **puissances négatives de 2** :\n\n- $23 =  1 \\times 2^4 + 0 \\times 2^3 + 1 \\times 2^2 + 1 \\times 2^1 + 1 \\times 2^0 = 16 + 4 + 2 + 1 = 23$\n\n- $0,375 = 0 \\times 2^{-1} + 1 \\times 2^{-2} + 1 \\times 2^{-3} = 0,25 + 0,125 = 0,375$\n\n- On a donc : $23,375_{10} = 10111,011_2$\n\nEn fait, cela fonctionne dans cet exemple car 23,375 est un **nombre dyadique**, c'est-à-dire qu'il peut s'écrire sour la forme $\\frac{N}{2^{\\, p}}$ où $N \\in \\mathbb{Z}$ et $ p \\in \\mathbb{N}$. Ce sont les **seuls nombres dont l'écriture en binaire est finie**."},{"metadata":{"slideshow":{"slide_type":"subslide"}},"cell_type":"markdown","source":"#### 2.3 Méthode de conversion\nComme pour le codage des entiers, il existe une méthode astucieuse pour **trouver facilement le codage binaire de la partie décimale** : il suffit de **multiplier la partie décimale par 2 jusqu'à obtenir 1** et de **noter la partie entière du résultat obtenu à chaque étape**.\n\nExemple pour 0,375 :\n- $0,375 \\times 2 =$ <span style=\"color:red;\">0</span>,75\n- $0,750 \\times 2 =$ <span style=\"color:red;\">1</span>,5\n- $0,5 \\times 2 =$ <span style=\"color:red;\">1</span>\n- On retrouve bien : $0,375_2 =0,011_2$\n"},{"metadata":{"slideshow":{"slide_type":"subslide"}},"cell_type":"markdown","source":"**Application**\n\nConvertir en écriture binaire les nombres suivants : 5.25, 0.5, 12.75 et 128.375."},{"metadata":{"slideshow":{"slide_type":"subslide"}},"cell_type":"markdown","source":"#### 2.4 Cas des nombres non dyadiques\n\nSi on essaye de coder en binaire, selon la méthode précédente le nombre 0,1 on obtient :\n- $0,1 \\times 2 =$ <span style=\"color:red;\">0</span>,2\n- $0,2 \\times 2 =$ <span style=\"color:red;\">0</span>,4\n- $0,4 \\times 2 =$ <span style=\"color:red;\">0</span>,8\n- $0,8 \\times 2 =$ <span style=\"color:red;\">1</span>,6\n- $0,6 \\times 2 =$ <span style=\"color:red;\">1</span>,2\n- $0,2 \\times 2 =$ <span style=\"color:red;\">0</span>,4\n- $0,4 \\times 2 =$ <span style=\"color:red;\">0</span>,8\n- $0,8 \\times 2 =$ <span style=\"color:red;\">1</span>,6\n- ...\n- D'où : $0,1_{10} =0,0 0011\\, 0011 \\, 0011 ..._2$\n\nEn binaire un **nombre non dyadique** s'écrit avec un **nombre infini de bits**, de même qu'en base 10 un **nombre non décimal** s'écrit avec un **nombre infini de chiffres**."},{"metadata":{"slideshow":{"slide_type":"subslide"}},"cell_type":"markdown","source":"**Remarque**\n\nOn retrouve pour les **nombres non dyadiques le problème de calcul approximatif** indiqué plus haut. Il est impossible de faire des calculs exacts en informatique avec des nombres non dyadiques puisqu'on ne manipule que des valeurs approchées de ces nombres."},{"metadata":{"slideshow":{"slide_type":"-"},"trusted":true},"cell_type":"code","source":"# Illustration\nprint(0.1)\nprint(0.1+0.1)\nprint(0.1+0.1+0.1)","execution_count":4,"outputs":[{"output_type":"stream","text":"0.1\n0.2\n0.30000000000000004\n","name":"stdout"}]},{"metadata":{"slideshow":{"slide_type":"subslide"}},"cell_type":"markdown","source":"**Application**\n\nConvertir en écriture binaire les nombres suivants : 17.2, 35.31 et 0.05."},{"metadata":{"slideshow":{"slide_type":"slide"}},"cell_type":"markdown","source":"### III. Notation en virgule flottante\n\n#### 3.1 Ecriture scientifique\n\nDans ce qu'on a vu au II., il manque une façon de coder **la position de la virgule**. Vous savez que la **notation scientifique** permet d'uniformiser l'écriture des nombres décimaux sous la forme $\\pm a \\times 10^n$ où $a$ est un nombre décimal entre 1 et 10 (non inclus) appelé **mantisse** et $n$ un entier relatif appelé **exposant**.\n\nDe même, on peut toujours écrire un nombre décimal binaire sous la forme $\\pm b \\times 2^n$ où $b$ est un nombre binaire de la forme $1,...$ et $n$ un entier relatif."},{"metadata":{"slideshow":{"slide_type":"subslide"}},"cell_type":"markdown","source":"#### 3.2 Le type `float 32`\nPour coder un nombre décimal $nombre = \\pm b \\times 2^n$, on a alors seulement besoin de coder les nombres $signe$, $mantisse$ et $exposant$ définis par :\n$$ nombre=(-1)^{signe}\\times 1,mantisse\\times 2^{exposant}$$\nIl ne reste plus qu'à définir le nombre de bits alloués pour chacun de ces nombres. Par exemple, pour le type `float`, le plus courant, codé sur 32 bits au total, on a :\n- le 1er bit pour le $signe$ (1 si < 0 et 0 si > 0).\n- les 8 bits suivants pour l'$exposant$ qui vaut $n+127$ où $n$ est la puissance de 2 de nombre en notation scientifique.\n- les 23 bits restants pour la $mantisse$, ou plus exactement la partie après la virgule de la mantisse."},{"metadata":{"slideshow":{"slide_type":"subslide"}},"cell_type":"markdown","source":"#### 3.3 Remarques\n- En codant $exposant=n + 127$ au lieu de simplement coder $n$, on évite de devoir coder des exposants négatifs.\n- Comme la $mantisse$ a forcément le chiffre 1 avant la virgule, cela ne sert à rien de la coder.\n- Si le nombre est dyadique, de sorte que la $mantisse$ comporte moins de 23 chiffres, on complète avec des 0.\n- En base 2, comme en base 10, à chaque fois qu'on décale la virgule d'un cran vers la gauche, il faut multiplier le nombre par 2 pour conserver l'égalité. Par exemple $101,011_2 = 1,01011_2 \\times 2^2$."},{"metadata":{"slideshow":{"slide_type":"subslide"}},"cell_type":"markdown","source":"#### 3.4 Exemple\nOn veut coder en `float 32 bits` le nombre décimal 211.3 (nombre non dyadique).\n- Ce nombre est positif donc $signe = 0$.\n- En écriture binaire : $211.3_{10} = 11010011.0100110011001101..._2 \\approx 1.10100110100110011001101_2\\times 2^7$ donc la $mantisse = 10100110100110011001101$ (partie après la virgule).\n- La puissance de 2 vaut $7$, on code donc un  $exposant = 7+127 = 134_{10} = 10000110_2$.\n- On obtient donc le code binaire suivant sur 32 bits : $0\\: 10000110 \\: 10100110100110011001101$\n\n**ATTENTION**\n\nEn réalité, ce nombre correspond à la valeur approchée $(1+1/2+1/2^3+1/2^6+1/2^7+1/2^9+1/2^{12}+1/2^{13}+1/2^{16}+1/2^{17}+1/2^{20}+1/2^{21}+1/2^{23})\\times 2^7 = 211.3000030517578$."},{"metadata":{"slideshow":{"slide_type":"-"},"trusted":true},"cell_type":"code","source":"print(2**7*(1+1/2+1/2**3+1/2**6+1/2**7+1/2**9+1/2**12+1/2**13+1/2**16+1/2**17+1/2**20+1/2**21+1/2**23))","execution_count":5,"outputs":[{"output_type":"stream","text":"211.3000030517578\n","name":"stdout"}]},{"metadata":{"slideshow":{"slide_type":"subslide"}},"cell_type":"markdown","source":"**Application**\n\nVérifier que le codage en binaire sur 32 bits de 35,31 est $0\\: 10000100 \\: 00011010011110101110000$."},{"metadata":{"slideshow":{"slide_type":"-"},"trusted":true},"cell_type":"code","source":"print(2**5*(1+1/2**4+1/2**5+1/2**7+1/2**10+1/2**11+1/2**12+1/2**13+1/2**15+1/2**17+1/2**18+1/2**19+1/2**20))","execution_count":6,"outputs":[{"output_type":"stream","text":"35.310028076171875\n","name":"stdout"}]},{"metadata":{"slideshow":{"slide_type":"slide"}},"cell_type":"markdown","source":"### IV. Flottants simple et double précision\n\n####  4.1 Tester l'égalité de 2 nombres flottants\n\nComme on l'a vu, **la représentation binaire des nombres réels n'est qu'approximative**, il faut donc se montrer très méfiant si on a besoin de tester l'égalité de 2 nombres réels. De manière générale, il ne faut pas le faire sous peine de mauvaises surprises. Par contre, on peut **tester si la différence entre 2 nombres décimaux est plus petite qu'un certain seuil** (marge d'erreur) judicieusement choisi.\n"},{"metadata":{"slideshow":{"slide_type":"subslide"},"trusted":true},"cell_type":"code","source":"# Exemple\nprint (0.1+0.2 == 0.3)\nprint (0.1+0.2-0.3 < 10**(-10))","execution_count":7,"outputs":[{"output_type":"stream","text":"False\nTrue\n","name":"stdout"}]},{"metadata":{"slideshow":{"slide_type":"subslide"}},"cell_type":"markdown","source":"#### 4.2 Les doubles précisions\n\nSi l'on souhaite **plus de précision** sur la représentation binaire des nombres décimaux, il faut simplement utiliser plus de bits. Ainsi les **flottants double précision** (on parle souvent de *double*) sont codés sur **64 bits**.\n\nLe tableau ci-dessous résume les **caractéristiques des flottants simple et double précision**.\n\n![tableau](img/image-codage-reel.png)\n"},{"metadata":{"slideshow":{"slide_type":"slide"}},"cell_type":"markdown","source":"### Conclusion\n\nLa partie réprésentation des nombres est terminée, pour la suite, c'est-à-dire la représentation des caractères, ça se passe [ici](cours_01_E.ipynb)."}],"metadata":{"celltoolbar":"none","kernelspec":{"name":"python3","display_name":"Python 3","language":"python"},"language_info":{"name":"python","version":"3.7.8","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat":4,"nbformat_minor":4}