Chap. 6 - joffrempsi1

Chap. 6 : Représentations des entiers et réels en informatique
Table des matières
1 Ecriture des entiers
1.1 Les entiers naturels qu’on connaı̂t . .
1.2 L’écriture en base deux . . . . . . . .
1.3 Pour obtenir l’écriture en base deux
1.4 Culture : la base 16 ou hexadécimal
2 Les
2.1
2.2
2.3
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
2
3
3
entiers à l’intérieur d’un ordinateur... et suivant les programmes
Le bit, l’octet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Le codage des entiers aujourd’hui : jusqu’à 64 bits . . . . . . . . . . . . . . .
Le cas des entiers négatifs : la méthode des compléments . . . . . . . . . . .
2.3.1 Echauffement sur l’exemple des int8 . . . . . . . . . . . . . . . . . .
2.3.2 Obtention commode du codage choisi pour les entiers négatifs . . .
2.3.3 Application au calcul des différences . . . . . . . . . . . . . . . . . . .
2.3.4 Cas des entiers en 64 bits . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
4
4
5
5
5
5
6
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3 Représentation binaire des réels : maths
3.1 A propos de l’écriture décimale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 Ecriture binaire (ou dyadique) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.3 Comment calculer la représentation binaire d’un nombre réel donné par son écriture
décimale ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
6
6
4 Représentation informatique des réels : les flottants
4.1 La représentation mantisse-exposant en base 10 . . . . . . . . . . . . . . . . . . . . .
4.2 La représentation mantisse-exposant en base 2 . . . . . . . . . . . . . . . . . . . . . .
4.3 Le standard double précision sur les flottants : 64 bits, illustré en Python . . . . .
4.3.1 La définition du standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.2 Conséquence : nombre de chiffres significatifs . . . . . . . . . . . . . . . . . .
4.3.3 Le plus grand et le plus petit float : l’intervalle des nombres machines
(normalisés) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4 Un avantage de SciLab pour l’affichage . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4.1 Nombres de chiffres affichés . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4.2 Pas d’analogue global du format de SciLab en Python . . . . . . . . . . . .
7
7
7
8
8
9
A Excursion niveau collège : les compléments en base dix
1
1.1
.
.
.
.
.
7
. 9
. 10
. 10
. 11
11
Des maths : l’écriture des entiers naturels en base dix,
deux, seize,..
Les entiers naturels qu’on connaı̂t
Nous avons tous une idée intuitive de la notion de nombre entier naturel. En mathématiques,
on montre que toutes les propriétés des entiers viennent des trois axiomes suivants :
Il existe un ensemble essentiellement unique noté N, muni d’une application s ∶ N → N
avec les propriétés :
(i) s est injective,
(ii) il existe dans N un élément noté 0 tel que 0 ∈/ s(N),
(iii) pour tout sous-ensemble A de N, si A contient 0 et est stable par s, alors A = N.
1
N.B. Ces axiomes disent tout sur N. Si on les cite ici, c’est pour signifier que la nature des nombres
entiers est purement liée à cette notion de succession et pas à la façon de les écrire. Ils disent aussi
que le raisonnement par récurrence contient la clef de toutes les propriétés des entiers....
Nous avons l’habitude de manipuler les entiers en base dix, dire n = 340587 signifie pour nous
n = 3.105 + 4.104 + 0.103 + 5.102 + 8.101 + 7.100 .
D’une manière générale, dire que l’écriture décimale d’un nombre entier est de la forme :
n = ar ar−1 . . . a1 a0 , avec , ∀ i ∈ ⟦0, r⟧, ai ∈ ⟦0, 9⟧,
signifie en fait que :
n = ar 10r + ar−1 .10r−1 + ⋯ + a1 .10 + a0 .
Le ≪ l’ ≫ devant le mot écriture est justifié par le fait que cette écriture est unique pour chaque
nombre entier, à condition de demander que si n ≠ 0, ar ≠ 0. Pour n = 0, on choisit, bien sûr, en
maths, comme unique écriture, l’écriture a0 = 0.
Cette habitude n’est qu’une convention, qui a correspondu au choix de dix chiffres pour coder
tous les nombres.
1.2
L’écriture en base deux
Aujourd’hui, avec les ordinateurs, une autre écriture est devenue incontournable : l’écriture en
base deux.
Une telle écriture va coder une décomposition du nombre entier n sous la forme :
n = br .2r + br−1 2r−1 + ⋯ + b1 .2 + b0 , avec ∀ i ∈ ⟦0, r⟧, bi ∈ {0, 1}
(†)
Pour un exemple concret : voici n0 = 2 + 2 + 2 + 2
Pour signifier qu’on a l’écriture (†) ci-dessous, on peut noter :
4
2
0
n = br br−1 . . . b0[2] ,
et dans l’exemple concret n0 = 10111[2] .
Moins rigoureusement peut-être, on dira aussi simplement n = br br−1 . . . b0 en base deux !
Bien sûr, dans notre exemple n0 = 16 + 4 + 2 + 1 = 23 en base dix. Donc on écrira 23 = 10111[2]
et encore, de façon moins rigoureuse : 23 = 10111 en base deux.
Théorème. Toute nombre entier naturel admet une unique écriture de la forme :
n = br .2r + br−1 2r−1 + ⋯ + b1 .2 + b0 , avec ∀ i ∈ ⟦0, r⟧, bi ∈ {0, 1}
à condition de spécifier que pour n = 0 l’écriture est donnée par r = 0, b0 = 0 et pour n ≠ 0, br ≠ 0.
Avec ces conventions, tout entier naturel non nul admet donc une unique écriture en base deux :
n = br br−1 ⋯b1 b0[2] ,
avec br ≠ 0.
L’unicité dans le théorème précédent permet la :
Définition. Avec les notations du théorème précédent, le nombre l = r + 1 sera appelé ici longueur
de l’écriture en base deux de n. Par exemple, cette longueur vaut 1 si, et seulement si, n = 0 ou
n = 1.
Exercice 1.
a) Donner l’écriture en base deux de tous les entiers de 1 à 12. A partir de maintenant vous savez compter en base deux. Cette écriture des entiers vérifie tout aussi bien les
axiomes de Peano.
b) Quel est le plus grand entier que l’on peut écrire avec 8 chiffres en base deux ? Même question
en remplaçant 8 par un entier l quelconque ?
c) Démontrer si on note l = r + 1 la longueur de l’écriture d’un entier n strictement positif en
base deux vérifie alors r = ⌊log2 (n)⌋, où ⌊ ⌋ désigne la partie entière.
2
1.3
Comment obtenir l’écriture en base deux d’un nombre écrit en base
dix ?
(M1) Des poids forts vers les poids faibles : Mettons qu’on veuille savoir comment s’écrit
54 en base deux. On commence par se demander entre quelles puissances de deux il est : ici 32 et
64. On sait alors quel est le premier chiffre (en partant de la gauche, celui qu’on appelle le poids
fort) de son écriture en base deux : comme 32 = 25 , 54 = 25 + (54 − 32) = 25 + 22. On fait le même
travail pour 22.
Exercice 2. Finir ce travail, pour obtenir l’écriture en base deux de 54, puis faire de même pour
361.
(M2) Des poids faibles vers les poids forts : L’idée de départ est que si n = br 2r +⋯+b1 2+b0
alors en particulier n = 2B + b0 où B est un entier et b0 ∈ {0, 1}. Donc b0 est le reste de la division
euclidienne de n par 2. Donc on sait calculer b0 , le dernier chiffre de l’écriture de n en base 2 (le
poids le plus faible). On a bien sûr b0 = si n est pair et b0 = si n est impair. Pour 54 ce chiffre
fait donc .
On peut ensuite appliquer la même méthode au quotient B de cette division euclidienne. A
partir de l’écriture de départ, B = br 2r−1 + ⋯b2 .2 + b1 et obtenir b1 .
Exercice 3. Appliquer cette méthode pour obtenir l’écriture en base deux de 54, puis de 361.
On comparera et implémentera ces deux méthodes en T.P.
1.4
Culture : la base 16 ou hexadécimal
L’écriture en base 16 utilise traditionnellement les dix chiffres 0,1,. . .,9 suivis par les six premières
lettres de l’alphabet A,B,C,D,E,F. Ainsi la lettre A correspond au 10 de la base 10, et F correspond
à 15 en base dix.
Pour comprendre un nombre écrit en hexadécimal, on utilise une écriture analogue à celle vue
au 1.1, avec les puissances de 16, en remplaçant les lettres par leur valeur décimale : par exemple
si n=3E5D en hexadécimal, on a :
n = 3 × 163 + 14 × 162 + 5 × 16 + 13.
Exercice 4.
a) A quelle âge, en hexadécimal, peut-on passer le permet de conduire en France ?
b) En informatique, le système RGB (Red Green Blue) définit une couleur comme la donnée
de trois nombres chacun entre 0 et 255, définissant pour le premier le niveau de Rouge, le
second le niveau de vert, le troisième le niveau de bleu. (i) Quelle couleur donne le code html
#FF0000 ? (ii) Plus dur : même question pour #FFFF00 ?
Notation en Python(mais aussi C, Java...) La notation 0x27 signifie qu’on considère le
nombre qui admet l’écriture 27 en hexadécimal. La commande hex convertit de décimal en hexa.
Exercice 5. Expliquer comment obtenir l’écriture binaire d’un nombre à partir de son écriture
hexadécimale. Le faire sur l’exemple de n = 3E5D.
3
2
Les entiers à l’intérieur d’un ordinateur... et suivant les
programmes
En informatique, les variables ont un type qui désigne leur nature : ici, nous allons d’abord
parler du type entier integer 1 .
2.1
Le bit, l’octet
Le bit est l’unité d’information : il vaut 0 ou 1. Au début de l’informatique, l’information était
transmise par paquets de 8 bits : on appelle octet un mot de 8 bits. Avec des octets, on peut donc
écrire 28 = 256 suites de 0 et de 1, différentes, comme par exemple 01001011.
2.2
Le codage des entiers aujourd’hui : jusqu’à 64 bits
Les PC les plus récents ont des microprocesseurs 64 bits, ce qui signifie que l’information arrive
par paquets de 64.
En Python 2, mais aussi dans beaucoup de langages, les entiers standard (type int, en Python) sont codés sur 64 bits, c’est-à-dire encore 8 octets. (Si vous avez une machine 32 bits, ce
sera sur 32 bits. De même si vous avez une machine 64 bits, mais un système d’exploitation gérant
32 bits).
Cependant quand, on parle d’entiers en informatique, il s’agit d’entiers avec signe, qui peuvent
être négatifs, on va garder un bit (par convention le premier) pour coder le signe.
Définition (Bit de signe). Pour tous les entiers, le premier bit code le signe : 0 code les positifs,
1 code les négatifs. Ainsi, si les entiers sont codés sur 64 bits, les entiers positifs seront tous de la
forme 0b1 . . . b63
On dispose donc de 63 bits pour coder les entiers positifs d’où l’ :
Exercice 6.
a) Quel est donc le plus grand entier de type int en Python 2 ?
b) Essayer en Python 2.7.
>> a=2**62
>> type(a)
puis
>> a=2**63
>> type(a)
Commentez. Puis faites la même chose en Python 3.
En SciLab, par défaut, tous les nombres rentrés sont des flottants c’est-à-dire des nombres à
virgule (cf.§ 4). Si on tape a=2 en Scilab, on obtient :
a =
2.
Le point derrière le 2 indique qu’il s’agit d’un flottant, i.e. d’un nombre à virgule.
Néanmoins, il est possible de spécifier que les variables sont des entiers, pour avoir des calculs
plus exacts que sur les nombres à virgules...
Par exemple : a=int8(77) pour dire qu’il s’agit de l’entier codé sur 8 bits. Sous la version
actuelle de SciLab, on a au maximum des int32.
Exercice 7 (Les mauvais gag de manip. des entiers en SciLab).
a) Que donnent les commandes SciLab : a=int8(120) b=int8(100) a+b
b) Expliquer la réponse du a).
c) A quoi sert donc ce type entier dans SciLab, s’il est si dangereux ?
1. Ce qui se prononce ’intedjer et pas integueur comme on entend souvent en France.
4
2.3
Le cas des entiers négatifs : la méthode des compléments
2.3.1
Echauffement sur l’exemple des int8
On considère les entiers codés sur 8 bits, (les int8 de SciLab) : pour les entiers positifs, le plus
grand est 01111111 = 27 − 1 = 127, car on n’oublie pas le bit de signe 0.
Une première idée, non retenue, de codage pour les négatifs : on aurait pu coder les
négatifs n ∈ ⟦−127, −1⟧ en mettant 1 devant l’écriture de ∣n∣ en base deux, mais ce n’est pas ce qui
a été choisi ! Une première raison évidente est qu’alors on aurait perdu de la place car on aurait eu
deux façons d’écrire 0. Mais la raison la plus importante est liée à l’addition.
En effet, avec un tel codage : 2 serait codé par 00000010 et -2 par 10000010, mais alors la
somme usuelle sur les nombres en binaires donnerait comme résultat 10000100 c’est-à-dire -4. Il
faudrait donc coder l’addition de manière différente suivant qu’on ajoute des positifs entre eux
(addition usuelle) ou des positifs avec des négatifs.
Il s’avère qu’il y a un moyen de contourner cette difficulté avec la :
Définition (La vraie convention de codage pour les négatifs). Si n est un entier
def
négatif, avec n ∈ ⟦−128, −1⟧, on le code, directement sur 8 bits, par c2 (n) = 28 − ∣n∣ =
256 + n ∈ ⟦128, 255⟧, écrit en binaire. En effet, le premier bit est alors forcément un 1 et donc
on sait qu’il s’agit du code d’un nombre négatif.
Exemple. Le plus petit entier négatif, −128 sera codé par 128 écrit en binaire, donc c2 (n) =10000000.
C’est un mauvais exemple car −128 + 256 = 128. D’où l’
Exercice 8. Quel est le codage c2 (−103) de −103 ?
2.3.2
Obtention commode du codage choisi pour les entiers négatifs
La notion de complément à 1 : Si à partir d’un int8, x, on en modifie les 8 bits en changeant
les 0 en 1 et les 1 en 0, on obtient un nombre c(x) qui s’appelle le complément à 1 de x.
Par exemple c(10011101)=01100010.
Par construction, il est évident que x+c(x)=
Cela donne une relation simple entre x et c(x), qu’on écrira : c(x)=
Application à l’interprétation du codage des entiers négatifs :
On a dit au § 2.3.1 que si n ∈ ⟦−128, −1⟧, on le codait par c2 (n) = 28 + n ∈ ⟦128, 255⟧.
Cette relation ressemble un peu à ce qu’on vient de dire pour le complément à 1. Précisément,
pour obtenir le codage de n ∈ ⟦−128, −1⟧ en int8, il suffit de faire les opérations suivantes :
'
a) On considère l’entier naturel x = −(n + 1) ∈ ⟦0, 127⟧, toujours en base deux,
$
b) puis on considère son complément à 1, c(x). On a alors le codage cherché :
c2 (n) = c(−(n + 1))
Le codage c2 défini au § 2.3.1, s’appelle (bizarrement) le complément à deux (il vaudrait
mieux dire complément à 28 puisqu’au total on a obtenu 28 − ∣n∣).
&
%
Exemple Pour n = −103 = −01100111[2] , on a x = −(−103 + 1) = (103 − 1) = 01100110[2] , puis avec
le complément à 1, on obtient : c(x) = 10011001[2] , qui est bien c2 (n) comme à l’exercice 8.
Exercice 9. Justifier que, d’une manière générale, la méthode donnée dans le cartouche ci-dessus
est valide, c’est-à-dire qu’on a toujours l’égalité : c2 (n) = c(−(n + 1)).
2.3.3
Application au calcul des différences
Remarque. On a vu au chapitre 1 comment il est facile pour un ordinateur d’ajouter des entiers
positifs écrits en base deux (avec une porte logique par bit). Le problème que l’on posait au début
du § 2.3.1 était celui de traiter, avec la même opération +, l’addition d’un entier positif et d’un entier
négatif. On va voir que le codage des négatifs par les compléments à deux permet cela efficacement.
5
Un petit exemple valant mieux qu’un long discours, avec des nombres à trois chiffres en base
deux, à chaque fois le codage machine est à droite.
001
1
+ −2
+ 110
−1
111
−1
111
+ 110
+ −2
−3
101
Notez qu’ici dans le résultat, on n’écrit pas le dernier 1 qui devrait apparaı̂tre à gauche par retenue.
La propriété générale est la suivante :
Proposition. Pour ajouter deux entiers a et b dans ⟦−128, 127⟧ dont la somme reste dans cet
intervalle, il suffit de faire la somme de leurs représentations en int8. Si cette somme a un 9-ième
chiffre à gauche on l’enlève ! Le résultat obtenu est bien le codage machine de a + b.
Exercice 10. Prouver la propriété. Si vous avez du mal, lisez l’appendice A.
2.3.4
Cas des entiers en 64 bits
Pour les entiers codés sur 64 bits, on a la même convention de codage, avec le premier bit qui
donne le signe, et le même système de complément à deux pour les entiers négatifs : cette fois, si
n < 0, c2 (n) = 264 + n.
L’intervalle des entiers codés sur 64 bits en Python est donc ⟦−263 , 263 − 1⟧.
3
Représentation binaire des réels : maths
3.1
A propos de l’écriture décimale
Nous avons l’habitude de l’écriture décimale, qui pour tout réel positif x est de la forme :
x = ar 10r + ar−1 10r−1 + a1 10 + a0 + a−1 10−1 + ⋯ + a−k 10−k + ⋯
(†)
Dans cette écriture, tous les ai sont entre 0 et 9, les . . . à la fin signifie que cette écriture peut
être infinie.
Par exemple 1/3 = 0, 3333....
Les nombres qui admette une écriture finie de la forme (†) s’appellent les nombres décimaux.
Attention : les nombres décimaux ont aussi la particularité d’avoir une autre écriture décimale,
dite impropre, qui consiste à écrire une infinité de 9 à la fin.
Par exemple 1 = 0, 9999.... oui égal et pas approximativement égal (cf. appendice maths sur les
limites) : une telle écriture d’un décimal avec que des 9 à la fin s’appelle écriture impropre.
A part ce problème des écritures impropres pour les nombres décimaux, l’écriture décimale d’un
nombre réel est unique.
3.2
Ecriture binaire (ou dyadique)
On a de même la :
Proposition. Tout réel réel positif x s’écrit :
x = bq 2q + ⋯ + b1 2 + b0 + b−1 2−1 + ⋯b−k 2−k + ⋯
où les bi valent tous 0 ou 1, les (b−i )i∈N ne sont pas tous égaux à 1 à partir d’un certain rang
(écriture propre).
Définition. Les nombres qui admette une développement binaire fini sont appelés nombres dyadiques. Ils sont de la forme a/2k où a est un entier.
6
3.3
Comment calculer la représentation binaire d’un nombre réel donné
par son écriture décimale ?
On considère un nombre réel positif x. Grâce aux méthode du § 1.2, on sait trouver l’écriture
binaire de sa partie entière ⌊x⌋.
Pour trouver les coefficients b−k pour k > 0, qui apparaissent dans l’écriture de la prop. du § 3.2,
on multiplie x par 2k , ce qui donne :
2k x = ⋯ + b−k+1 2 + b−k + b−k−1 2−1 + ⋯
En considérant le reste de la division euclidienne par 2 de ⌊2k x⌋, on obtient b−k .
Exercice 11. Déterminer l’écriture binaire des nombres 3, 25 et 0, 1 (écriture en base dix).
4
4.1
Représentation informatique des réels : les flottants
La représentation mantisse-exposant en base 10
Pour tous les nombres décimaux, on va convenir d’une écriture normalisée : considérons par
exemple le nombre décimal x = 1234, 5678
On peut aussi l’écrire 123, 45678.101 ou 12, 345678.102 ou 1, 2345678.103 ou 0, 12345678.104 ou
12345, 678.10−1 etc.
Parmi toutes ces écritures, on va choisir comme écriture normalisée : x = 1, 2345678.103 et d’une
manière générale :
Définition. L’écriture normalisée, en base dix, d’un nombre décimal x strictement positif avec
une mantisse de longueur r + 1 et un exposant e ≥ 0 est une écriture de la forme :
x = ar , ar−1 . . . a0 .10e
avec ∀ i ∈ ⟦0, r⟧, ai ∈ ⟦0, 9⟧ et ar ≠ 0.
Dans cette représentation, la mantisse est le nombre ar ar−1 . . . a0 .
Remarque. En informatique, la longueur de la mantisse va être fixée, ce qui bien sûr, va nous
obliger à considérer des valeurs approchées des nombres réels (même décimaux) s’ils s’écrivent avec
davantage de chiffres.
Définition (Notation “scientifique” en base dix). En Python la notation 23e17 signifie 23 × 1017 .
L’ordinateur renverra l’écriture normalisée 2.3e18.
Avec SciLab, on peut utiliser la même notation 2.3e18 pour rentrer les nombres, mais il répond
avec une notation légèrement différente (avec le D qui veut dire décimal) :
->1e10
ans =
1.000D+10
4.2
La représentation mantisse-exposant en base 2
C’est celle qui nous sera utile pour passer ensuite au vrai codage des nombres en machine à la
section suivante.
On a l’analogue exact de la définition précédente :
Définition (mantisse mathématique binaire sans signe). L’écriture normalisée, en base 2, d’un
nombre x > 0 avec une mantisse de longueur r + 1 et un exposant e ≥ 0 est une écriture de la forme :
x = ar , ar−1 . . . a0 [2] .2e
avec ∀ i ∈ ⟦0, r⟧, ai ∈ ⟦0, 1⟧ et ar ≠ 0, donc ar = 1.
Dans cette représentation, la mantisse mathématique binaire, sans signe, est le nombre ar ar−1 . . . a0[2] =
ar 2r + ar−1 2r−1 + ⋯ + a1 2 + a0 .
7
Remarque. Souvent on convient de noter un tel nombre par le couple (m, e) où m est la mantisse
et e est l’exposant. Cependant, à ce stade, on n’a parlé que des nombres strictement positifs. Nous
aborderons le codage des négatifs et de zéro, et le codage des exposants dans la section 4.3 suivante
consacrée à la norme IEEE. La vraie mantisse machine sera en fait légèrement différente de la
mantisse mathématique de la définition précédente, notamment à cause d’un bit rajouté pour le
signe, et aussi parce qu’en binaire, pour les nombres strictement positifs, le nombre ar ≠ 0 est
forcément un 1, ce qui permettra de l’enlever du codage du nombre.
Pour l’instant, contentons nous de nous familiariser avec un :
Un bébé exemple : considérons les nombres strictement positifs que l’on peut représenter avec
une mantisse mathématique binaire m de longueur 3, et un exposant e ∈ ⟦−2, 1⟧.
Exercice 12.
a) Combien a-t-on de nombres strictement positifs de cette forme ?
b) Quels sont les entiers parmi ces nombres ?
1
c) Combien y-a-t-il de tels nombres dans ] , 1[ ?
2
1 1
d) Même question dans ] , [ ?
4 2
e) Quel est le plus grand et le plus petits parmi ces nombres ?
4.3
Le standard double précision sur les flottants : 64 bits, illustré en
Python
Les différences de représentation des nombres flottants d’un ordinateur à un autre obligeaient
au départ à reprendre les programmes de calcul pour les porter d’une machine à une autre. Pour
assurer la compatibilité entre les machines, une norme a été proposée par l’IEEE (Institute of
Electrical and Electronics Engineers) et ceci, dès 1985.
4.3.1
La définition du standard
Définition. Le format simple précision est codé sur 32 bits, et le double précision utilise 64 bits.
En Python comme en SciLab, le format utilisé est le format double précision (même si votre
ordinateur est un 32 bits). Le signe est codé sur un bit, l’exposant sur 11 bits, et la mantisse est
codée sur 52 bits. On va voir plus précisément comment chacun est codé.


 

 

Figure 1: An IEEE-754 64 bits binary floating point number.
1
Introduction
a) Le bit de signe S porte 0 pour les positifs stricts et 1 pour les négatifs stricts. On va voir que
le nombre zéro a 2 deux codages l’un avec 0 l’autre avec 1 comme bit de signe.
A X sources are available on
This document
is E
an pour
open-source
project.
The
E
b) Le code
l’exposant
: Les 11
bitsL T
d’exposants
peuvent coder 211 the
= 2048 nombres.
Scilab Forge:
Comme on veut coder aussi bien des exposants positifs que négatifs, on va utiliser encore la
méthode des compléments. En notant e l’exposant mathématique, on code E = e+1023 en base
http://forge.scilab.org/index.php/p/docscifloat/
deux. On convient que les valeurs mathématiques autorisées pour e sont dans ⟦−1022, 1023⟧
donc Eare
∈ ⟦1,
2046⟧. Reste
valeurs
disponibles
pourAttributionE.
The LATEXetsources
provided
underdeux
the terms
of spéciales
the Creative
Commons
ShareAlike 3.0
i) EUnported
= 0 coderaLicense:
les nombres très petits et notamment 0.
ii) E = 2047 codera le nombres trop grands traités comme infinis.
http://creativecommons.org/licenses/by-sa/3.0
2. contrairement au cas des entiers
The Scilab scripts are provided on the Forge, inside the project, under the scripts
sub-directory. The scripts are available under the CeCiLL license:
8
http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
2
Floating point numbers
c) Le code M de mantisse machine :
i) Pour le nombre 0, on le code avec la mantisse machine M = 0 . . . 0 et l’exposant machine
E = 0 réservé.
ii) Pour les nombres non nuls, on sait que la mantisse mathématique m = ar ar−1 . . . a0
commence par ar = 1. La mantisse machine M codera ar−1 . . . a0 0 . . . 0 en complétant
avec des 0 pour avoir 52 chiffres si nécessaire.
Exemple. Le nombre 1, qui avait une mantisse mathématique m = 1 et un exposant e = 0 sera
codé par S = 0, E = 01111111111, M = 0 . . . 0. Car E = e + 1023 écrit en base deux et M s’obtient à
partir de m en enlevant le premier 1.
Exercice 13. Quel sera le codage machine des nombres suivants écrits en base deux : a = 1, 0111.23 ,
b = −1, 101.2−5 ?
Définition (Nombres machines normalisés). On appelle nombres machines normalisés le sousensemble des nombres dyadiques qui peuvent être écrits exactement par le codage IEEE précédent.
C’est bien sûr un ensemble fini. Pour les autres nombres, les nombres machines serviront d’approximation.
4.3.2
Conséquence : nombre de chiffres significatifs
Exercice 14 (Nombres de chiffres significatifs).
a) Suivant le format défini précédemment, on
peut coder exactement des nombres ayant au plus 53 chiffres en binaires. On dit qu’il y a
53 chiffres significatifs en binaire. Combien a-t-on alors de chiffres significatifs en écriture
décimale ?
b) Que fait le programme suivant en SciLab ?
i=1
while 1.+10^(-i)>1
i=i+1
end
c) Ecrire et tester le même programme en Python.
4.3.3
Le plus grand et le plus petit float : l’intervalle des nombres machines (normalisés)
Exercice 15 (Dépassement de capacité : overflow, underflow). Exécutez les lignes suivantes
en Python et en SciLab et commentez le résultat par rapport à la déf. donnée au 4.3.1
a)
1e-323, 1e-324
b)
1e308, 1e309
Remarque. Comme expérimenté dans l’exercice précédent a), le code IEEE permet de gérer des
nombres plus petits que les nombres décrits au § 4.3.1. Ceci est possible par le fait que pour l’instant
avec le code d’exposant E = 0 . . . 0, on n’a codé que le nombre 0. Les nombres codés avec M ≠ 0 et
E = 0 . . . 0 sont dits sous-normaux, nous n’insisterons pas sur ce point.
Remarque. Toutes ces informations sont disponibles en Python, via le module sys qui contient
des informations systèmes.
from sys import *
# on importe tout le contenu du module
float_info.max_exp
qui répond bien 1024, mais il faut comprendre que 1024 est le premier interdit.
Vous pouvez jouer avec les options de complétion de la commande float_info. pour apprendre
plus de choses.
9
Définition (L’intervalle des nombres machines et les nombres normalisés). D’après ce qui précède 3 ,
tous les flottants normalisés représentés en machines en Python, sont donc dans l’intervalle
[xmin , xmax [ où xmin = 2−1022 et xmax = 21024 .
Remarque (Différence overflow/underflow). Si au cours d’un calcul avec des floats l’ordinateur
tombe sur un nombre plus grand que xmax , on dit qu’il y a un overflow (dépassement), et le calcul
s’arrête, pour donner un infini. S’il tombe sur un nombre positif strictement plus petit que xmin ,
le calcul continue, mais en donnant au nombre en question la valeur zéro.
4.4
Un avantage de SciLab pour l’affichage
4.4.1
Nombres de chiffres affichés
En SciLab, la commande format permet de régler ce nombre : attention format(m) va afficher
les nombres avec m caractères en comptant le signe (même s’il n’est pas marqué pour le signe +)
et la virgule (le point en fait) comme des caractères : il faut donc ajouter 2 dans format pour avoir
le nombre de chiffres voulu. Par exemple :
-->format(3)
-->exp(1)
ans =
3
-->format(4)
-->exp(1)
ans =
2.7
-->format(10)
-->exp(1)
ans =
2.7182818
Attention : La commande format autorise jusqu’à 25 caractères donc 23 chiffres, mais il ne faut
pas s’y fier ! Par exemple :
-->format(25)
-->%pi
%pi =
3.1415926535897931159980
Là, on se dit, bon, SciLab connaı̂t 22 décimales de π. Sauf que, si on demande à un logiciel de
calcul formel comme Mathematica ou simplement au site http ://www.wolframalpha.com : on
obtient pour π
3.14159265358979323846264338327950288
En SciLab, les 16 premiers chiffres de π sont justes, mais le 17ème est faux si on croı̂t Wolfram
Alpha.
3. en laissant de côté les nombres sous-normaux
10
4.4.2 Pas d’analogue global du format de SciLab en Python
En python : on doit à chaque fois préciser le format qu’on veut pour l’affichage. La raison est
qu’il s’agit d’un langage de programmation : le code doit dire exactement le résultat qu’on
veut, indépendamment d’un réglage global.
Par exemple, en Python, avec le module math pour avoir pi :
>>> ’{:.22f}’.format(pi)
’3.1415926535897931159980’
Ici le .22f veut dire qu’on veut 22 chiffres après la virgule. Nous reviendrons sur l’utilisation
de la méthode format en Python.
Les deux programmes ont le même nombre π qui est différent de celui de Mathematica à partir
de la 16eme décimale ! Cela peut paraı̂tre étrange non ? On pourrait se dire que de toutes façons
tous les calculs numériques n’auront pas une précision de plus de 16 chiffres, donc cette erreur sur
π n’affecterait pas les calculs : c’est faux, à cause des phénomènes de ≪ cancellation ≫ que l’on verra
plus tard en calcul numérique. Alors, pourquoi avoir ≪ rentré ≫ un nombre π faux ? Voir l’exercice
suivant :
Exercice 16 (L’explication du mystère sur π). Le nombre pi du module math est un float, codé
donc sur avec une mantisse binaire de 53 chiffres. Une façon de savoir exactement quel est le nombre
codé en machine pour pi est d’utiliser la commande pi.as_integer_ratio() qui répond
(884279719003555, 281474976710656)
Ce couple dit que le pi du module math est le nombre rationnel (884279719003555/281474976710656)
a) Obtenir l’écriture en base deux de chacun de ces deux nombres à l’aide de Python.
b) Conclure : quelle est la représentation (m, e) binaire de ce nombre pi ?
c) Aurait-il été possible de représenter pi plus précisément ? Question difficile !
A
Excursion niveau collège : les compléments en base dix
En base dix, on parle de méthode des compléments pour désigner la méthode suivante :
Définition. Pour chaque chiffre i, son complément est par définition 9 − i.
Pour un nombre n à r chiffres par exemple n = 356291, on appelle complément de n le nombre
c obtenu en remplaçant chaque chiffre de n par son complément.
Sur l’exemple c = 643708.
L’intérêt d’introduire les complément vient de la facile :
Proposition. Pour calculer la différence a − b de deux nombres entiers a et b, on peut écrire le
complément c de a, calculer la somme S = c + b puis écrire le complément C de S. Alors C = a − b.
Exemple Si on veut calculer 24563 − 15743. On écrit le complément de 24563 qui est c = 75436.
On calcule la somme b + c = 75436 + 15743 = 91179. Le complément de la somme s’écrit 08820, c’est
la différence cherchée.
Exercice 17. Démontrez cette propriété.
11
Solutions des exercices
Solution 1
a) 0, 1, 10, 11, 100, 101, 110, 111, 1000, 1001, 1010, 1011, 1100.
Une remarque : du point de vue des ensembles, l’ensemble des entiers écrits en base deux ou
des entiers écrits en base deux sont-ils le même ensemble ? On a plutôt envie de dire non, ils
ne sont pas constitués des mêmes éléments. Mais, il y a une bijection entre les deux ensembles,
qui est compatible avec la notion de successeur (et mieux cette bijection est unique). C’est en
ce sens-là qu’il faut comprendre l’unicité de l’ensemble N donné par les axiomes de Peano.
b) Le plus grand entier N qu’on peut écrire avec huit chiffres en base deux est :N = 11111111[2] .
Donc N = 27 + 26 + ⋯ + 2 + 1 = 28 − 1 par la formule sur la somme des termes d’une suite
géométrique. Donc N = 255.
Deuxième question : avec l chiffres, le nombre maximum sera Nl = 2l−1 + ⋯ + 2 + 1 = 2l − 1.
c) Si n a une écriture de longueur l en base deux, il est compris entre 100 . . . 00[2] (avec l chiffres)
et 111 . . . 11[2] (avec l chiffres). Donc, 2l−1 ≤ n ≤ 2l − 1 < 2l ou encore 2r ≤ n < 2r+1 ou encore
En appliquant la fonction log2 , qui est strictement croissante : on obtient log2 (2r ) ≤ log2 (n) <
log2 (2r+1 ), autrement dit : r ≤ log2 (n) < r + 1.
Donc r est le plus grand entier inférieur ou égal à log2 (n) i.e. par déf. la partie entière.
Solution 2 a) Pour 54, on obtient avec 22 = 16 + 6 = 16 + 4 + 2, finalement : 54 = 32 + 16 + 4 + 2 =
110110[2] .
b) Pour 361, 361 = 256 + 105 = 28 + 64 + 41 = 28 + 26 + 41 = 28 + 26 + 32 + 9 = 28 + 26 + 25 + 23 + 20 .
Donc 361 = 101101001[2] .
Solution 3
54 = 2 × 27 + 0,
27
= 2 × 13 + 1,
13
= 2 × 6 + 1,
6
= 2 × 3 + 0,
3
= 2 × 1 + 1,
1
= 2×0+1
La suite des restes donne donc l’écriture en base deux 110110[2] .
Solution 4 a) A douze ans : ou bien on compte : après F, il y a 10,11, 12,... 19,1A etc
ou bien on dit dix-huit c’est 16+2.
b) (i) FF code 255 en hexadécimal. Donc il s’agit d’un pur rouge vif. (ii) Mélange égal de rouge
et de vert : jaune. Il s’agit de ce qu’on appelle la synthèse additive des couleurs.
Solution 5 L’idée : chaque chiffre de l’écriture hexadécimale se décompose en un bloc de quatre
chiffres en binaire. En effet : d’un côté on transforme chaque puissance de 16 en puissance de 2 et
de l’autre chaque nombre entre 0 et 15 va donner un nombre d’au plus quatre chiffres en binaire,
qu’on va écrire avec exactement quatre chiffres en binaire, quitte à mettre des zéros devant.
Ainsi pour n = 3×163 +14×162 +5×16+13 = 3.(24 )3 +14.(24 )2 +5.24 +13 = 11[2] .212 +1110[2] .28 +
0101[2] .24 + 1101, ce qui donne : n = 11111001011101[2] .
Solution 6
12
Solution des exercices du chapitre 6, II et III
Solution 6
62
a) Le plus grand entier s’écrira avec des 1 sur 63 bits. C’est donc Nmax = ∑ 2k (somme de 63
k=0
termes car on part de zéro).
D’après la formule sur la somme des termes d’une suite géométrique, ici de raison 2, on aura
1 − 263
= 263 − 1.
donc Nmax =
1−2
b) Le premier bloc répond <class ’int’> et le second bloc répond <type ’long’> Il y a donc
un type long pour les entiers plus longs. L’idée est que pour les entiers codables en dessous de
64 bits, ils sont reconnus comme tels et traités plus rapidement. Les entiers de type long ont
pour seule limitation de taille la mémoire disponible. Pour cela, le programme les découpe
en morceaux. Python sait passer tout seul d’un type à l’autre (au moins du type int au
type long en cas de besoin).
En Python 3, les types int et long ont été fusionnés. Les entiers sont toujours de taille
illimitée, et représentés en interne par morceaux (sur un ordinateur 64 bits par paquets de
30 bits).
Il est quand même bon de connaı̂tre cette différences entre entiers codés sur un nombre de
bits fixe et entiers longs du point de vue de l’informatique en général (par exemple en C.)
Nous
allons mieux voir cette différence avec les entiers dans SciLab.
Solution 7 a) La réponse, étonnante, est -36.
b) −36 + 256 = 220. Le calcul sur les int8 est en fait un calcul modulo 256. On va mieux
comprendre pourquoi au paragraphe suivant.
c) Si on est sûr de faire des calculs qui ne sortent pas de la taille fixée ([-128,127] pour les int8,
beaucoup plus pour les int32), ces calculs seront exacts et rapides.
Solution 8 On écrit −103 + 256 = 153 en binaire, ce qui donne : c2 (−103) =10011001.
N.B. pour les outils de conversions en binaire : cf. T.P. 5
En Python, on peut utiliser bin(153) qui renvoie non pas un entier mais une chaı̂ne de caractères
’0b10011001’. En SciLab, on peut utiliser la commande dec2bin(153) qui elle, renvoie 10011001, mais
en fait codé aussi comme une chaı̂ne de caractères. Cf. T.P. 5 pour tout cela.
Solution 9 Soit n ∈ ⟦−128, −1⟧. Par définition :
c2 (n) = 28 + n (∗)
D’autre part, on a dit au début du paragraphe que pour tout x ∈ ⟦0, 255⟧,
x + c(x) = 11111111[2] = 28 − 1
Donc c(x) = 28 − 1 − x. En appliquant cette relation à x = −(n + 1), on a
c(−(n + 1)) = 28 − 1 + (n + 1) = 28 + n.
(∗∗)
En comparant (∗) et (∗∗), on a la conclusion.
Solution 10 Soit i ∈ ⟦1, 127⟧ et j ∈ ⟦−128, −1 ⟧ alors par définition c2 (j) = 28 + j ∈ ⟦128, 255⟧, et :
i + c2 (j) = i + 28 + j = 28 + (i + j)
(†)
Par hypothèse le résultat de i + j est dans ⟦−128, 127 ⟧. On distingue deux cas :
● premier cas : (i + j) ∈ ⟦−128, −1⟧.
Dans ce cas, l’égalité (†) ci-dessus dit que i + c2 (j) = c2 (i + j). Donc le résultat de l’addition
i + c2 (j) est bien le codage machine de i + j.
● deuxième cas : (i + j) ∈ ⟦0, 127⟧. Dans ce cas, le nombre 28 + (i + j) s’écrit en binaire comme
i + j en rajoutant seulement un 1 sur le 9ième chiffre à gauche. C’est le second cas de l’exemple.
Donc en enlevant ce 1, on a bien i + j.
1
Solution 11 a) On sait déjà que 3 = 11[2] . Pour 0, 25, on sait que 0, 25 = 1/4 donc l’écriture binaire
est immédiate : 3, 25 = 11, 01[2] .
b) Là, on applique l’algorithme indiqué plus haut pour x = 0, 1, en notant, comme en Python,
% le reste de la division euclidienne
−k
−1
−2
−3
−4
−5
−6
−7
−8
−9
x.2k
0, 2
0, 4
0, 8
1, 6
3, 2
6, 4
12, 8
25, 6
51, 2
y = ⌊x.2k ⌋ y%2
0
0
0
0
0
0
1
1
3
1
6
0
12
0
25
1
51
1
Cela n’a pas l’air de vouloir s’arrêter ! En fait, quand pour k = 6, on obtient x.2k = 6, 4 = 6 + 0, 4
la suite de l’algorithme est la même qu’à partir de x.2−2 = 0, 4. En effet les restes des divisions
par deux des x.2k suivant k = 6 ne dépendront que du terme 0, 4 de la somme 6 + 0, 4 puisque
6, multiplié par n’importe quelle puissance de 2, donnera toujours un reste nul. Autrement dit, à
1.2. REPRÉSENTATION SCIENTIFIQUE DES NOMBRES DANS DIFFÉRENTES BASES5
partir de k = 6 l’algo. donne les mêmes résultats qu’à partir de k = 2. Donc le développement en
base 2 de x = 0, 1 est périodique à partir du rang k = 2 :
une infinité de décimales et ne peuvent donc pas avoir de représentation exacte
...
0, 1 = des
0, 00011001100110011
en machine. Le plus simple
calculs devient alors
L’expérience pra[2] approché.
tique montre que cette quantité limitée de nombres représentables est largement
(On a souligné
la pour
période
se répète).
suffisante
les qui
calculs.
Sur l’ordinateur, les nombres utilisés lors des calculs
Le fait que
le
décimal
0,
1
ait
une
binaire
infinie
peut provoquer
erreurs
de calculs
sont des nombres machine écriture
x̃ provenant
d’un
ensemble
discret de des
nombres
maen informatique
comme
nous
le
verrons
plus
loin.
chine x̃
x̃min , . . . , x̃max . Ainsi, chaque nombre réel x doit être transformé en
un nombre machine x̃ afin de pouvoir être utilisé sur un ordinateur. Un exemple
Solution 12
a) Pour chaque valeur de e, la mantisse m commençant toujours par un 1, elle
est donné sur la figure 1.1.
est de la forme 1a1 a0 , donc on a quatre chiffres possibles pour chaque valeur de e. Comme e
prend 4 valeurs, on a au total 16 chiffres strictement
positifs.
0
0
b) Les entiers sont
x ceux
R pour lesquels il n’y a que des zéros après la virgule : donc 1, 00[2] .2 = 1 ;
1
1
1, 00[2] .2 = 10[2] = 2 ; 1, 10[2] .2 = 11[2] = 3.
c) De tels nombres
ont leur écriture en base deux qui commence par 0, 1. Comme on doit les
x̃ F
écrire avec une mantisse de longueur 3, ils sont de la forme 1, a1 a0 [2] .2−1 . Cela donne quatre
x̃min
0̃
x̃max
nombres :
−1
−1
1, 00[2] .2Fig.
= 1.2
1/2,–1,Représentation
01[2] .2−1 = 1/2 des
+ 1/8,
1, 10[2]réels
.2−1 =R1/2
1/4,nombres
1, 11[2] ..2
= 1/2F+ 1/4 + 1/8.
nombres
par+ les
machine
d) De tels nombres ont leur écriture en base deux qui commence par 0, 01. Comme on doit les
écrire avec
une mantisse
de longueur
3, ils
sont
de la pour
formeêtre
ils sont
demais
la forme
a1 a0 [2] .2−2 .
Prenons
un exemple,
beaucoup
trop
simple
utilisé
pour1,fixer
Cela donne
encore
3, L nombres.
1, U
2. Dans ce cas on a 3 chiffres significatifs et
les idées
: t quatre
e) A cause
de la contrainte
l’exposant
petit, le plus
nombre
00[2] .2−2 = 1/4.
33 nombres
dans lesur
système
F. Ilsleseplus
répartissent
avecpetit
0 d’une
part,est
161,nombres
1
Le plus
grandque
est l’on
1, 11ne
= 2 + 1 +pas
1/2 ici,
= 7/2.
négatifs
représente
et 16 nombres positifs représentés sur la
[2] .2
figure
1.3.
Le schéma suivant donne la répartition.
0
1
4
1
2
5
8
3
4
7
8
1
3
2
2
5
2
3
7
2
Fig. 1.3 – Nombres positifs de F dans le cas t 3, L
1, U 2
Solution 13
a) Pour a, m = 10111, e = 3 donc M = 01110 . . . , E = 3+1023 = 1026 = 10000000010[2]
(qui fait Dans
bien 11
et l’écriture
S = 0 bienensûr.
cetchiffres)
exemple,
binaire des nombres entre 12 et 1 est
b) Pour b, on codera par S = 1, E = e + 1023 codé en base deux donc E = 01111111010. Enfin
1 1
1
3
M = 1010 . . . .
0.100 2 ,
0.110 2 ,
2
4
2 4
7
1 1
1 1 1
5
0.101 2 ,
0.111 2 .
8
2 8
82 2 4 8
On obtient ensuite les autres nombres en multipliant par une puissance de
Solution 14 a) On peut coder de manière exacte les nombres entiers positifs de 0 à 253 − 1. Or
2**53 donne 9007199254740992.
Pour savoir la longueur de cet entier, une façon est de le convertir en chaı̂ne de caractères :
a=str(2**53) puis len(a) donne 16. Ainsi, donc on peut écrire de manière exacte des nombres
qui ont strictement moins de 16 chiffres en base dix.
Donc les flottants sont représentés avec 15 chiffres significatifs.
b) Ce programme teste si quand on ajoute au flottant 1. le nombre 10−i le résultat est bien vu
comme strictement plus grand que 1. Cela est le cas jusqu’à i = 16.
c)Le code suivant en Python donne le même résultat : i = 16.
i=1
while 1+10**(-i)>1:
i+=1
Solution 15 En Python, on obtient :
a) En Python, on obtient :
>>> 1e-323
1e-323
>>> 1e-324
0.0
Commentaire : A partir de 1e-324 un nombre est considéré comme nul, et à partir de 1e309 il
est considéré comme trop grand : inf abrège ici l’infini.
Or, au § 4.3.1, on a dit que le plus petit exposant négatif permis était −1022. Autrement dit
que le plus petit nombre codable était 2−1022 . Or :
>>> 2**(-1022)
2.2250738585072014e-308
Donc ce n’est pas cohérent ! L’explication est donnée à la remarque suivante : il y a des nombres
machines autres que les nombres normalisés, appelés nombres sous-normaux qui permettent de
coder des nombres plus petits que ce qu’on attendrait si on n’utilisait que les nombres normalisés.
b) En Python encore :
>>> 1e308
1e+308
>>> 1e309
inf
Commentaire : le plus grand exposant permis étant e = 1023, le plus grand nombre annoncé par le
paragraphe 4.3.1 est celui qui s’écrit avec M = 11 . . . 11 donc m = 253 − 1 et e = 1023.
Là, le nombre obtenu est donc 1, 111 . . . 1[2] .21023 , qu’on peut calculer en décimal par exemple
comme suit :
S=0
f o r i in range ( 5 3 ) :
S=S+2∗∗(1023 − i )
p r i n t ( f l o a t ( S ) ) # c e q u i donne
1 . 7 9 7 6 9 3 1 3 4 8 6 2 3 1 5 7 e +308
Ici le résultat est bien cohérent avec l’expérimentation proposée.
Solution 16
a) On utilise le code
from math import *
num,den=pi.as_integer_ratio() # comme as_integer_ratio() renvoie un couple...
num2=bin(num)
den2=bin(den)
>>> num2
3
’0b11001001000011111101101010100010001000010110100011’
>>> den2
’0b1000000000000000000000000000000000000000000000000’
b) On comprend que le dénominateur est une puissance de deux. Comme den2 est une chaı̂ne de
caractère avec : len(den2) on obtient que la chaı̂ne est de longueur 51 et donc le nombre a
49 chiffres. Donc den vaut 248 , ce qu’on peut vérifier bien sûr. Donc la représentation (m, e)
avec une mantisse mathématique binaire pour pi est donnée par ;
m = 11001001000011111101101010100010001000010110100011
et
e = −48.
La longueur de m est donnée via len(num2) qui donne 52, donc en enlevant le ’0b’, la
longueur est 50 (ce qu’on pouvait aussi savoir mathématiquement !).
c) Donc a priori on pourrait avoir une précision supplémentaire puisque la mantisse mathématique
M codant pi n’aura que 49 chiffres binaires au lieu des 53 possibles ? En fait, c’est plus subtil
que cela.
Comme la partie avant la virgule de l’écriture de π en binaire commence par 11 (qui code 3),
avec une mantisse mathématique de longueur 54, on a droit à 52 chiffres après la virgule.
Donc la meilleure mantisse binaire de longueur 54 pour π sera donnée en considérant l’entier
le plus proche de 252 π.
Comment calculer cet entier ? Certainement pas avec Python puisqu’on veut justement
tester Python. On va faire confiance au site Wolfram Alpha, qui repose sur le logiciel de
calcul formel Mathematica qui est muni d’un algorithme pour calculer un nombre énorme
de décimales de π.
Si on demande le calcul de 252 π, on obtient comme partie entière p = 14148475504056880. Si
on exécute les instructions suivantes :
p=14148475504056880
p2=bin(p)[2:]
print(p2)
On obtient :
’110010010000111111011010101000100010000101101000110000’
Ainsi p2 écrit en binaire se termine par 4 zéros, ce qui signifie encore que p est divisible par
24 .
Merveille :
si on met 4 zéros derrière m on trouve exactement p2 !
Autrement dit, la raison pour laquelle la mantisse binaire utilisée pour coder π en Python
fait 48 chiffres au lieu des 52 possibles est que la partie entière de 252 π se termine par 4 zéros
en binaire. Ainsi le pi du module math de Python est ⌊252 π⌋/252 .
Une réserve sur le choix fait par Python et Scilab : Le résultat de Wolfram Alpha de
252 π donne aussi les chiffres après la partie entière. Or il s’avère que l’entier le plus proche
de 252 π n’est pas sa partie entière, mais sa partie entière plus 1. En effet 252 π vaut environ
1.4148475504056880551531886830049042748947319002065055082... × 1016
Le 1 que nous avons surligné après dit que l’entier le plus proche de 252 π n’est pas sa partie
entière, mais l’entier suivant !
Autrement dit, il semble plus pertinent de coder π par (m′ , e′ ) avec m′ la mantisse mathématique
binaire m′ = p2 + 1 i.e. :
m′ = 110010010000111111011010101000100010000101101000110001 et e′ = −52.
En décimal, cela reviendrait à ajouter 2−52 = 2.2204.10−16 à l’écriture de pi ce qui donnerait
une approximation de π par un nombre plus grand que π mais plus proche du nombre réel.
Solution 17 On veut calculer a-b. On calcule c tel que a+c=99999 On calcule c+b puis le
complément : 99999-(c+b)=(99999-c)-b=a-b.
4