Chapitre 1 : Représentation des nombres réels en machine et introduction à Python

Chapitre 1 : Représentation des nombres réels en machine et introduction à Python

I Généralités

1.1 Ecriture décimale

Nous avons l’habitude d’utiliser l’écriture décimale d’un nombre :

Tout réel strictement positif s’écrit sous la forme :

x=a_r×10^r+a_r−1×10^r−1+...+a₁×10+a₀+a₋₁ 10 +a₋₂

10²+...+a_−k 10^k+...

Dans cette écriturer∈Z, lesa_i appartiennent à‚0, 9ƒetar 6=0. Les ... à la fin signifient que cette écriture peut être infinie (par exemple 1/3 = 0,33333...).

Proposition 1

1.2 Ecriture binaire

En informatique, on utilise plutôt l’écriture en base 2 des nombres :

Tout réelx∈R^∗₊s’écrit :

x=1×2^r+ar−1×2^r−1+...+a1×2+a0+a₋1

2 +a₋2

2² +...+a_−k 2^k +...

oùr∈Z, lesa_ivalent 0 ou 1.

Cette écriture est appelée écriture en base 2 dex.

L’écriture 1ar−1...a₀,a₋₁a₋₂...²représentera le nombre 1×2^r+ar−1×2^r−1+...+a₁×2+a₀+a₋1

2 +a₋2

2² +....

Proposition 2

Un nombre est dit dyadique si son écriture en base 2 est finie. Ces nombres sont de la forme a

2^p oùp∈Neta∈Z. Exemple

• a=101, 1²=1×2²+0×2¹+1+2⁻¹=5, 5

• b=1011, 01²=1×2³+0×2²+1×2¹+1+0×2⁻¹+1×2⁻²=11, 25

• c=22, 625

22=2×11=2(2×5+1)=2²×(2×2+1)+2=2⁴+2²+2¹=10110². 2×0, 625=1, 25=1+0, 25

2²×0, 625=2+0, 5 2³×0, 625=2²+1

Donc 0, 625=2⁻¹+2⁻³=0, 101². D’où 22, 625=10110, 101².

• d=125, 75

125=2×62+1=2²×31+1=2²×(2×15+1)+1=2³×(2×7+1)+2²+1=2⁴×(2×3+1)+2³+2²+1=2⁵×(2+1)+2⁴+2³+2²+1= 2⁶+2⁵+2⁴+2³+2²+1=1111101².

2×0, 75=1, 5=1+0, 5 2²×0, 75=2+1

Donc 0, 75=2⁻¹+2⁻²=0, 11². D’où 125, 75=1111101, 11². Exercice 1 :

Déterminer l’écriture binaire dex=21, 375 et vérifier le résultat.

II Représentation des réels en machine

2.1 Représentation en virgule fixe

Une partie des bits est réservée pour coder la partie entière et une partie pour la partie décimale (plus un bit de signe).

La réalisation d’opérations est alors très simple à réaliser. Cependant ceci est contraignant car il est très probable que de la place mémoire soit gâchée par une telle représentation. Par exemple, les nombres strictement inférieurs à 1 ont leur partie entière nulle, l’espace utilisé pour stocker la partie entière pourrait être utilisé pour représenter plus de décimales et donc obtenir une plus grande précision. Ce sera l’idée de la représentation en virgule flottante.

2.2 Représentation en virgule flottante normalisée

La norme IEEE-574 est actuellement le standard pour la représentation des nombres à virgule flottante en binaire. Cette norme décrit entre autre le stockage du signe, de la mantisse, de l’exposant et définit également le 0, l’infini et les NaN (Not a number).

Nous allons plutôt utiliser l’idée de la notation scientifique mais en base 2.

Un nombre réel non nul sera représenté en machine sous la formes×m×2^eoù

• s∈{+1,−1} représente le signe.

• m=1c₁...c_n²avec lesc_k∈{0, 1} etnfixée, précisée dans le paragraphe suivant.mest appelé mantisse.

• eest un entier relatif appelé exposant appartenant à une plage de valeurs fixée.

L’ensemble des nombres de cette forme est appelé ensemble des nombres flottants ou des nombres à virgule flottante.

Ï En binaire, le premier chiffre de la mantisse est nécessairement 1 (hormis pour 0). Il n’a donc pas besoin d’être stocké.

On parle de bit implicite. On ne code donc que la mantisse réduitem⁰telle quem=1+m⁰. Ï Le bit de signe est égal à 0 si le nombre est positif et à 1 si le nombre est négatif.

Ï L’exposant pouvant être négatif, pour le coder, on aurait pu utiliser l’astuce du complément à 2 mais c’est un décalage qui est réalisé pour stocker ce nombre. Ainsi, on dispose de 2^nevaleurs pour l’exposant. Les valeurs 1111...11111²et 0000...00000² sont réservées pour des cas particuliers. On applique un décalage égal à 2^ne−1−1. L’exposant doit donc être compris entre 1−(2^ne−1−1)= −2^ne−1+2 et 2^ne−2−(2^ne−1−1)=2^ne−1−1.

2.3 Flottant simple précision : sur 32 bits

• 1 bit est utilisé pour représenter le signe.

• 8 bits sont utilisés pour représenter l’exposant.

• 23 bits sont utilisés pour représenter la mantisse.

Ï Le décalage pour l’exposant est égal à 2⁸⁻¹−1=127. L’exposanteest donc un entier relatif compris entre−126 et 127 et les 8 bits de l’exposant donnent la représentation binaire de l’exposant décalée⁰=e+127.

Ï La mantisse est représentée avec 23 chiffres après la virgule en base 2.

Valeurs extrémales et précision

• Le plus petit (en valeur absolue) nombre représentable est±1, 000...0²×2⁻¹²⁶' ±1.2×10⁻³⁸

• Le plus grand (en valeur absolue) nombre représentable est±1, 111...1²×2¹²⁷'2¹²⁸'3.4×10³⁸

• La précision de la mantisse est de l’ordre de 2⁻²³'1, 2×10⁻⁷, ce qui correspond à environ 7 chiffres significatifs (en base 10).

Exemple

• On cherche le nombre représenté en mémoire par : 0 01111100 01000000000000000000000.

Le signe est positif.

L’exposant décalé est 01111100²=2⁶+2⁵+2⁴+2³+2²=124, l’exposant est 124−127= −3.

La mantisse réduite est 0, 01², la mantisse est 1, 01²=1+2⁻²=1, 25.

Le nombre est : 1, 25×2⁻³=0, 15625.

• On cherche la représentation sur 32 bits dec=22, 625=10110, 101²=1, 0110101²×2⁴ Le signe est positif donc le bit de signe vaut 0.

L’exposant est 4, l’exposant décalé est 4+127=131=2×65+1=2×(2×32+1)+1=2²×2⁵+2+1=2⁷+2+1=10000011². La mantisse est 1, 0110101², la mantisse réduite est 0, 0110101².

c est donc représenté en mémoire par :

Exercice 2 :

1. Déterminer le nombre représenté en mémoire par : 0 10000011 100101100000000000000000 2. Déterminer la représentation sur 32 bits ded=125, 75=1111101, 11².

2.4 Flottant double précision : sur 64 bits

• 1 bit est utilisé pour représenter le signe.

• 11 bits sont utilisés pour représenter l’exposant.

• 52 bits sont utilisés pour représenter la mantisse.

Ï Le décalage pour l’exposant est égal à 2¹¹⁻¹−1=1023. L’exposanteest un entier relatif compris entre−1022 et 1023=2¹⁰−1 et les 11 bits de l’exposant donnent la représentation binaire de l’exposant décalée⁰=e+1023.

Ï La mantisse est représentée avec 52 chiffres après la virgule.

Valeurs extrémales et précision

• Le plus petit (en valeur absolue) nombre représentable est±1, 000...0²×2⁻¹⁰²²' ±2.2×10⁻³⁰⁸

• Le plus grand (en valeur absolue) nombre représentable est±1, 111...1²×2¹⁰²³' ±2¹⁰²⁴' ±1.8×10³⁰⁸

• La précision de la mantisse est de l’ordre de 2⁻⁵²'2.2×10⁻¹⁶, ce qui correspond à environ 16 chiffres significatifs (en base 10).

III Introduction à Python

3.1 Préambule

Python est un langage de programmation dont la première version, développée par Guido van Rossum, est apparue en 1989 et qui a continué à être développé jusqu’à la version 3 disponible actuellement. C’est un langage informatique large- ment utilisé qui présente l’avantage d’être sous licence libre et d’être gratuit.

Un environnement de développement intégré (IDE : Integrated Development Environment) est un ensemble d’outils permettant de rationaliser la création et le développement de programmes.

Il existe différents environnements de développement gratuits et compatibles avec Python : Idle, Spyder, Pyzo ... Nous utili- serons l’environnementPyzoqui a été utilisé les années précédentes lors des oraux du concours Centrale-Supélec.

Il comprend entre autre :

• un éditeur permettant d’écrire et de sauvegarder des programmes longs ;

• une console interactive (shell) qui permet d’interagir avec Python directement.

• une aide interactive

3.2 Installation

•Il faut commencer par téléchargerPyzoà l’adresse suivante :

http ://www.pyzo.org/start.html

et l’installer. Pyzo est disponible pour Windows, Linux et OSX. Vous venez alors d’installer l’éditeur de l’environnement Pyzo.

•Puis, il vous faut ensuite installeranaconda(comprenant entre autre un interpréteur Python mais également de nombreux packages scientifiques) un lien est disponible sur la même page. Choisissez la version 3 de Python. Il est conseillé de l’instal- ler à l’endroit par défaut.

•Lancez Pyzo. L’environnement anaconda est généralement détecté automatiquement. Il vous suffit alors d’accepter de l’utiliser.

•Vous pouvez enfin si vous le souhaitez mettre Pyzo en français. Pour ce faire, lancez Pyzo, allez dans le menuSettings,select languageet choisissezFrench. Il vous faut redémarrer Pyzo pour que cette modification soit prise en compte.

3.3 Lancement de Pyzo

Au lancement de Pyzo, vous obtenez un écran de la forme :

La console ou shell :

La console interactive s’utilise comme une calculatrice.

La validation se fait en appuyant sur entrée. Chaque ligne tapée est alors immédiatement exécutée.

Par souci de lisibilité, la console n’est adaptée qu’à des calculs ou des programmes courts et qui n’ont pas besoin d’être sauvegardés. Les programmes plus longs ou destinés à être sauvegardés sont écrits dans l’éditeur.

Dans la console interactive, on ne peut pas modifier une ligne de commande précédemment exécutée. On pourra cepen- dant rappeler au niveau de l’invite de commande une des lignes précédemment exécutées grâce aux flèches de défilement.

On pourra alors la modifier avant de relancer le calcul.

Éditeur

L’éditeur nous permet d’écrire et de sauvegarder des programmes.

Pour exécuter un programme, il suffit d’aller dans le menuexécuterpuis de sélectionner la commandeexécuter le contenu de l’onglet courant(raccourci Ctrl + E). Les instructions sont alors lues et exécutées, le résultat, lorsqu’il y en a un, s’affiche dans la console interactive.

Pour créer un nouveau fichier, on utilise le menu fichier, Nouveau. On peut alors taper nos instructions, les sauvegarder et les exécuter.

Les fenêtres d’outils

Il est possible de choisir les fenêtres d’outils qui s’affichent en allant dans le menu Outils. On peut notamment ouvrir la fenêtre d’aide interactive qui permet d’obtenir la documentation sur les commandes utilisées au fur et à mesure de leur saisie.

3.4 Valeurs et types

On peut travailler sur des valeurs de types différents :

• des entiers 0,-1, 6

• des nombres à virgule flottante 1.0856, 0.3333333, 1/3

• des nombres complexes 2+3j, 1j

BLe complexe de carré -1 est 1j et pas j qui est représente la variable j.

• des chaînes de caractères

"mon texte",’mon texte’

• des booléens

1>2 est un booléen dont la valeur est False

• des listes [1,2,1.9]

• des tuples

>>>type(2)

<class ’int’>

>>>type(2.)

<class ’float’>

>>>type(1+2j)

<class ’complex’>

>>>type(1>2)

<class ’bool’>

>>>type(1+2*j)

Traceback (most recent call last) : File "<stdin>", line 1, in <module>

NameError : name ’j’ is not defined}

Le symbole>>> signifie que ce qui suit a été entré dans la console. Ce symbole ne doit pas être tapé.

3.5 Opérations

On peut effectuer les opérations usuelles sur les entiers, les flottants et les complexes :+,∗,−, /,∗∗(puissance qui est appelée aussi exponentiation), abs()(valeur absolue ou module).

On peut également obtenir les parties réelle et imaginaire d’un nombre complexezen utilisant les commandes z.realet z.imag.

On peut également obtenir le quotient de la division euclidienne dep parq en effectuant p//qet le reste le la division euclidienne depparq en effectuant p%q. Ces opérations peuvent se faire avec des objets quelconques de type entiers, flottants ou complexes. On dit que Python a un "typage fort", c’est-à-dire qu’il va convertir seul les données selon la règle suivante :

int_→ float_→complex

Il existe des opérations analogues pour les autres types. Elles seront vues ultérieurement.

Exercice 3 :

Donner les résultats aux commandes suivantes :

>>>a=1+1.5

>>>type(a)

>>>b=1+2.

>>>type(b)

>>>c=1/2

>>>type(c)

>>>d=4/2

>>>type(d)

>>>e=1.5+2j

>>>type(e)

>>>(1+3j).real

>>>(1+3j).imag

>>>1+3j.imag

>>>10//3

>>>10%3

IV Conséquences de la représentation des nombres

4.1 Dépassement de capacité ou overflow

Lorsque le résultat d’un calcul est supérieur au plus grand nombre représentable en machine, on parle de dépassement de capacité ou d’overflow.

>>>10.**500

OverflowError : (34, ’Result too large’)

4.2 Problèmes d’arrondi

L’ensembleRne peut pas être représenté en machine sur un nombre fini de bits puisque l’information ne peut alors être que finie. Un réel est donc approché par un flottant. Ainsi, la plupart des nombres ne peuvent pas être représentés en machine de manière exacte. La conversion en flottant sera à l’origine d’erreurs d’arrondi. Ces approximations peuvent se cumuler dans les calculs et conduire à des résultats très imprécis voir erronés.

>>>0.1+0.2

0.30000000000000004

>>>0.1+0.2-0.3 5.551115123125783e-17

4.3 Phénomène d’absorption

Ce problème apparait lors de l’addition de deux nombres ayant des ordres de grandeurs très différents.

>>>(1.+2**53)-2**53 0.0

L’écriture en base 2 de 1+2⁵³est 1 000 ... 000

| {z }

52 fois 0

1²=1, 000 ... 000

| {z }

52 fois 0

1² ×2⁵³. Or, la mantisse est limitée à 52 bits, ainsi, le der- nier 1 sera perdu. Ce nombre sera donc représenté en machine par 1, 000 ... 000

| {z }

52 fois 0

2 ×2⁵³. Ainsi, en représentation machine, 1+2⁵³=2⁵³, ce qui explique le résultat renvoyé par Python.

Conséquences : on évitera si possible d’additionner deux quantités aux ordres de grandeurs très différents.

4.4 Phénomène de cancellation

Ce problème se rencontre lorsque l’on calcule la différence de nombres très proches. Il y a cette fois une perte importante du nombre de chiffres significatifs.

Supposons que l’on connaissexetyavec 25 chiffres significatifs après la virgule (en binaire) : x=1.1010010001101110010101011²

y=1.1010010001101110010010100² x−y=0.0000000000000000000010111²

Le résultat dex−y sera écrit sous la forme 1.0111²×2⁻²¹pour être représenté en machine. La précision ne sera donc plus que de 4 chiffres significatifs en binaire (les chiffres suivants n’ont pas de signification). Cette perte importante de précision est appelée phénomène de cancellation ou d’annulation.

Conséquences : Afin d’éviter les problèmes de cancellation, on évitera si possible de soustraire deux nombres très voisins.

Il faut garder de phénomène à l’esprit afin d’organiser au mieux les calculs pour éviter ce phénomène.

Par exemple, il est préférable de calculer 1

x(x+1)plutôt que1 x− 1

x+1bien que ces quantités sont théoriquement égales. La seconde expression est plus sensible au phénomène de cancellation.