243-616-EM Intégration de systèmes Cégep Édouard-Montpetit

Notation en point flottant selon le standard IEEE 754

Introduction
Lorsque l’on déclare des variables, celles-ci vont alors occuper un nombre défini d’octets en mémoire
selon leur type respectif, un « char » prendra un seul octet tandis qu’un « int » prendra 4 octets. Les
variables en point flottant n’y échappent pas et prendront un certains nombre d’octets. Pour une
variable du type « float » celle-ci occupera 4 octets et celle du type « double » prendra 8 octets. La
question est alors comment représenter un nombre fractionnaire si aucun bit ne peut représenter la
virgule ou le point décimal. Le texte qui suit vous explique la façon d’exprimer et de déterminer la
valeur de chaque bit d’un nombre en point flottant suivi de quelques exemples et exercices.

Représentation de chaque type de variable

Les « char et int » : La variable de type « char » occupe 1 octet en mémoire et permet de représenter
directement un nombre compris entre 0 et 255 (0 à FF) ou entre -128 et 127
lorsqu’on l’emploie en mode signé. Chaque bit de ce nombre détermine la valeur
globale de ce dernier selon son poids en fonction de sa position. Par exemple, si
j’ai le nombre binaire 1001 1101 chaque bit à 1 aura comme poids le chiffre 2
exposant le numéro de la position de ce bit à 1, le nombre final en décimal sera
alors la somme du poids de chaque bit à 1. Rappelons que le bit le moins
significatif est à droite et que sa position est 0, tandis que le 8e bit complètement à
gauche est le plus significatif et sa position est 7.
Ex. : 1001 1101 vaut

Donc la représentation d’un nombre décimal en binaire sur 8 bits est simple et le même
calcul pourra s’appliquer pour un nombre entier « int » de 32 bits ou plus.

Les « float et double » : Même si un « float » occupe 32 bits ou 4 octets et qu’un « double » occupe
64 bits ou 8 octets en mémoire, leur représentation sera complètement
différente des entiers.

Les « float » en mode simple précision soit sur 32 bits se décline comme suit :

S S 8 bits 23 bits

Exposant La mantisse (partie fractionnaire)

Bit de signe : 0 --> positif
1 --> négatif
Les « double » en mode double précision soit sur 64 bits se décline comme suit :

S 11 bits 52 bits

Exposant La mantisse (partie fractionnaire)

Bit de signe : 0 --> positif 1 --> négatif

André Touchette Page 1/10

243-616-EM Intégration de systèmes Cégep Édouard-Montpetit

Avant d’expliquer comment un nombre en point flottant peut être exprimé sous forme binaire dans le
format présenté à la page précédente, il serait bon de voir comment nous en sommes parvenus à
employer cette notation.

Nombre à virgule fixe :

Prenons par exemple un nombre à virgule fixe, ce qui signifie qu’il peut y avoir plus d’un chiffre avant la
virgule comme le nombre 124.375 ce nombre en décimal pourrait aisément être traduit en binaire par le
chiffre 0101 1100.011
La première partie avant le point est 0101 1100 valant en décimal le nombre 124 :

tandis que 011 se trouvant après le point vaut sous forme détaillée le calcul suivant :

Pourquoi alors ne pas utiliser cette forme dans la représentation en mémoire ? Pour la simple et bonne
raison qu’il n’y a aucun bit dans cette suite de code binaire permettant d’établir quelle est la position du
point ou de la virgule dans le nombre que j’exprime en plus, le point peut changer de place en fonction
du nombre à représenter comme 1725.25 ou 4.625 etc..

Notation scientifique base 10 :

L’utilisation de la notation scientifique nous permet d’exprimer un nombre en ayant toujours qu’un seul
chiffre avant la virgule comme par exemple :
3
1725.25 donne en notation scientifique 1.72525 x 10 il nous faudra connaître la valeur de l’exposant de
la base 10 pour être en mesure de retrouver le nombre original.
Nous appliquerons le même principe que la notation scientifique mais cette fois en binaire.

Notation scientifique base 2 :

À partir du nombre décimal suivant 2534.625 sa traduction en binaire à virgule fixe nous donne le code
1001 1110 0110.101
Transformons ce nombre binaire en notation scientifique en base 2, le résultat sera alors :
1.0011 1100 1101 0100 x 211 . Comme on peut le voir, nous avons déplacé le point de 11 positions vers
la gauche jusqu’à ce qu’il y ait qu’un seul chiffre avant la point. Comment allons-nous maintenant
traduire ce nombre et son exposant en n’ayant plus à se soucier de la virgule ou du point ? Mais avant,
vous remarquerez que le chiffre devant la virgule sera toujours « 1 » donc dans notre représentation
binaire en mémoire, ce bit ne sera pas représenté mais sous entendu. La norme IEEE 754 établie la
manière de représenter un nombre en point flottant voici comment.

André Touchette Page 2/10

 243-616-EM Intégration de systèmes Cégep Édouard-Montpetit

Norme IEEE 754 : Simple précision sur 32 bits

Dans ce mode nous avons la représentation suivante :
S 31 30 29 28 23 22 21 1 0
S S Exposant Mantisse (M)

La mantisse (partie fractionnaire)

Bit de signe : 0 --> positif

1 --> négatif
Sous forme mathématique l’expression globale du nombre représenté en notation scientifique binaire
est alors :

Où : S est le bit de signe 0 ou 1

1,M correspond au nombre binaire en notation scientifique binaire comme 1,010111010
donne le déplacement de la virgule afin d’obtenir la nombre final.
Le nombre 127 sert de biais étant donné que l’on peut aussi faire la représentation d’un nombre plus
petit que 1 ce qui donne alors un exposant de 2 qui sera négatif d’où la coupure de notre plage en deux.
Prenons un exemple concret et élaborons la démarche.
Exemple de conversion d’un nombre décimal à virgule flottant en notation IEEE 754.
Reprenons le nombre décimal 2534.625 vu précédemment, sa traduction en binaire à virgule fixe nous
donne le code 1001 1110 0110.101 et sa représentation en virgule flottante normalisée donne :
1.0011 1100 1101 0100 x 211
Le nombre 11 sera représenté par le symbole exprimant l’exposant de la base 2 et sera égal au terme
(Exposant -127) de l’équation globale.
Donc
Si l’on veut maintenant obtenir la vraie valeur du terme « Exposant » dans l’équation globale, il nous
suffit de connaître et d’isoler le terme « Exposant » nous obtenons l’équation suivante :

Effectuons maintenant toutes les opérations dans notre équation globale :

Transcription de notre résultat en code de 32 bits :

S Exposant Mantisse
0 1 0 0 0 1 0 1 0 0 0 1 1 1 1 0 0 1 1 0 1 0 1 0 0 0 0 0 0 0 0 0

Finalement si nous exprimons en hexadécimal ce que représente ce nombre en point flottant, nous
obtenons 0x451E6A00

André Touchette Page 3/10

243-616-EM Intégration de systèmes Cégep Édouard-Montpetit

Exemple 2 : Traduire en binaire le nombre 35.3467 en virgule flottante simple précision.

Étape 1 : Exprimer en binaire le nombre 35

35 --> 0010 0011
Étape 2 : Exprimer en binaire la partie fractionnaire 0.3467
0.3467 --> 01011000110000010101010
Ce qui donne comme calcul : 0.25 + 0.0625 + 0.03125 + …
Étape 3 : Combiner le résultat du nombre 35 et sa partie fractionnaire
Ce qui donne : 0010 0011. 01011000110000010101010
Étape 4 : Exprimer le nombre binaire à virgule fixe en un nombre binaire en notation scientifique
5
Ce qui donne : 1.0001101011000110000010101010 x 2
Étape 5 : Appliquer sur l’équation globale de la page 3 les éléments de l’étape 4

Étant donné que le nombre est positif, le bit de signe sera S = 0

donc « Exposant » sera égal à

« M » sera égal à la mantisse, ce qui nous donne finalement :

0 1 0 0 0 0 1 0 0 0 0 0 1 1 0 1 0 1 1 0 0 0 1 1 0 0 0 0 0 0 1 0

S exposant mantisse

En hexadécimal cela donne : 0x420D6305

Comme vous pouvez le remarquer, les 23 bits de la mantisse ne sont pas suffisant pour bien
représenter avec précision le nombre 35.3467, à l’étape 4, le contenu de la mantisse est supérieur à
23 bits et je n’ai pas obtenu le nombre exact correspondant à 0.3467. Si je faisais l’impression du vrai
résultat à partir du code hexadécimal 0x420D6305 j’obtiendrais le nombre 35.346699. Donc même
pour de petit nombre comme 35.3467 si l’on désire obtenir une meilleure précision pour la
représentation de ce nombre, il serait préférable de le traduire en mode double précision.
Question que vous vous posez sûrement, comment faire pour déterminer la séquence des bits
représentant la partie fractionnaire comme 0.3467, et bien c’est ce que nous allons voir à l’instant.

Représentation en binaire de la partie fractionnaire d’un nombre décimal :

Prenons un exemple simple pour montrer la mécanique de calcul pour déterminer la séquence des bits
représentant la partie fractionnaire d’un nombre en point flottant. Premièrement lorsque l’on se décale
vers la gauche dans un binaire, on double la valeur du poids de ce bit, il se produira le même principe
lorsque l’on va se décaler vers la droite, mais cette fois le poids du bit diminuera de moitié à chaque
déplacement. Ce qui signifie que si j’ai le code 0.1111 sa valeur sera alors :

André Touchette Page 4/10

243-616-EM Intégration de systèmes Cégep Édouard-Montpetit

Il est facile de faire le calcul à partir du code binaire, mais comment faire dans le cas contraire, soit de
partir de la valeur décimale fractionnaire. Il suffit de prendre le nombre fractionnaire, ici 0.9375 et de le
multiplier par 2, si le résultat donne un chiffre fractionnaire supérieur à 1 alors on conserve le 1 puis on
multiplie la nouvelle partie fractionnaire par 2 mais sans le 1. Si par contre le résultat de la
multiplication donne un nombre inférieur à 1, alors on conserve le 0 et ainsi de suite jusqu’à ce que le
calcul donne 1.0 ce qui mettra fin à l’itération. Voici comment ça fonctionne.
On veut traduire 0.9375 en binaire :
0.9375 X 2 = 1.875 on conserve le 1
0.875 X 2 = 1.750 on conserve le 1
0.750 X 2 = 1.500 on conserve le 1
0.500 X 2 = 1.000 on conserve le 1
0.000 on arrête ici. Donc le nombre binaire fractionnaire représentant 0.9375 est 0.1111

Effectuons maintenant le calcul avec l’exemple complet de la page 4 soit celui avec 35.3467
Commençons avec la partie fractionnaire soit 0.3467 :

0.3467 X 2 = 0.6934 on conserve le 0 --> ce bit est le MSB

0.6934 X 2 = 1.3868 on conserve le 1
0.3868 X 2 = 0.7736 on conserve le 0
0.7736 X 2 = 1.5472 on conserve le 1
0.5472 X 2 = 1.0944 on conserve le 1 Le résultat de cette suite de chiffres nous donne :
0.0944 X 2 = 0.1888 on conserve le 0 0.01011000110000010101010 voir le résultat de
0.1888 X 2 = 0.3776 on conserve le 0 la page 4.
0.3776 X 2 = 0.7552 on conserve le 0
0.7552 X 2 = 1.5104 on conserve le 1
0.5104 X 2 = 1.0208 on conserve le 1
0.0208 X 2 = 0.0416 on conserve le 0
0.0416 X 2 = 0.0832 on conserve le 0
0.0832 X 2 = 0.1664 on conserve le 0
0.1664 X 2 = 0.3328 on conserve le 0
0.3328 X 2 = 0.6656 on conserve le 0
0.6656 X 2 = 1.3312 on conserve le 1
0.3312 X 2 = 0.6624 on conserve le 0
0.6624 X 2 = 1.3248 on conserve le 1
0.3248 X 2 = 0.6496 on conserve le 0
0.6496 X 2 = 1.2992 on conserve le 1
0.2992 X 2 = 0.5984 on conserve le 0

André Touchette Page 5/10

243-616-EM Intégration de systèmes Cégep Édouard-Montpetit

Nombres particuliers :
Le chiffre 0 sera exprimé de deux manières soit ±0 lorsque le bit de signe est 0 ou 1 et que tous les
autres bits sont à 0. Comme le montre le code suivant :

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

S exposant mantisse
Ou

1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

S exposant mantisse

L’infini : Est exprimé par le code 0x7F800000

0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

S exposant mantisse
et : Est exprimé par le code 0xFF800000

1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

S exposant mantisse

Le plus gros nombre positif : Tous les bits sont à 1 sauf le bit de signe à 0 donne le code 0x7FFFFFFF

0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

S exposant mantisse
Calcul :

Le plus gros nombre négatif : Tous les bits sont à 1 ainsi que le bit de signe donne le code 0xFFFFFFFF

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

S exposant mantisse
Calcul :

Voir le texte « Aide mémoire et base du langage C » à la page 4 où le tableau indique les valeurs
maximales positives et négatives pour les types de variables.

André Touchette Page 6/10

243-616-EM Intégration de systèmes Cégep Édouard-Montpetit

Traduction d’un code hexadécimal représentant un nombre en point flottant :

Prenons maintenant un code hexadécimal sur 32 bits et trouvons à quel nombre en point flottant celui-
ci correspond.
Le nombre : 0x46BAE580
Transposons ce nombre sous forme binaire :

0 1 0 0 0 1 1 0 1 0 1 1 1 0 1 0 1 1 1 0 0 1 0 1 1 0 0 0 0 0 0 0

S exposant mantisse

Le signe est 0 donc c’est un nombre positif.

L’Exposant est 0x8d ce qui donne 141
Remplaçons le tout dans notre équation :

Limites de la représentation en simple précision 32 bits :

Si nous désirons effectuer des calculs en simple précision 32 bits et que l’on travail avec des nombres
relativement gros et que ceux-ci possèdent en plus des chiffres après la virgule, il se peut que nous
perdions ces fameux chiffres après la virgule et ainsi nous conduire à des résultats erronés. Nous
pourrons observer que plus le nombre à représenter est petit plus nous pourrons obtenir de chiffres
après la virgule en conservant une bonne précision et au contraire, si le nombre est très grand nous ne
pourrons plus obtenir de chiffres après la virgule. Je vous en fais la démonstration.
Supposons que notre nombre est grand et qu’il occupe tous les bits de la mantisse en étant à 1 et aussi
que l’exposant fasse en sorte que le déplacement de la virgule donne une valeur entière.

Donc si mon nombre est 1.111 1111 1111 1111 1111 1111 X 223 nous aurons donc le code binaire
suivant : 1111 1111 1111 1111 1111 1111 ce nombre binaire exprimé en décimal donne 16 777 215 soit
le plus gros nombre pouvant être fait avec 24 bits. On voit que si la partie entière de mon nombre
occupe toute la mantisse je ne pourrai être en mesure de lui ajouter des chiffres après la virgule. Le
nombre en hexadécimal est 0x4b 7f ff ff

0 1 0 0 1 0 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

S exposant mantisse
Ici « l’exposant » vaut 0x96 soit 150 en décimal car

Si mon nombre est 16 777 215.5 nous aurions sous forme binaire à virgule fixe le code suivant :
16 777 215.5 --> 1111 1111 1111 1111 1111 1111.1

André Touchette Page 7/10

243-616-EM Intégration de systèmes Cégep Édouard-Montpetit

Faisons la conversion en notation scientifique binaire, nous obtenons :

1.111 1111 1111 1111 1111 1111 1 X 223
Remarquez que le nombre total de bits de la mantisse contient 24 bits et ma représentation finale ne
peut contenir plus de 23 bits dans celle-ci, notre nombre final sera alors modifié comme le montre le
calcul suivant :
L’équation globale donne :

23
Ce qui se traduit par 1.111 1111 1111 1111 1111 1111 X 2 = 1 1111 1111 1111 1111 1111 111
La valeur finale donne 16 777 215 au lieu de 16 777 215.5. Il se peut que lors de l’impression du
nombre, la fonction comme « printf » fera un arrondi si la valeur du chiffre après la virgule est
supérieure à 0.5. Donc l’affichage de 16 777 215.5 donnera 16 777 216.0
Quelle sera alors le nombre maximal que l’on peut écrire tout en pouvant obtenir une valeur après la
virgule. Étant donné que le premier bit après la virgule vaut 0.5 il nous faudra donc retrancher un bit de
notre fameux nombre, nous prendrons le bit le plus significatif ce qui va couper notre plage en deux, ce
qui donne 8 388 607 qui correspond en binaire à la valeur 0111 1111 1111 1111 1111 1111 , exprimée
22
en notation scientifique binaire nous avons 1.11 1111 1111 1111 1111 1111 X 2 . Il nous reste alors un
bit de libre dans la mantisse nous pourrons donc l’utiliser pour notre 0.5.
Si j’écris le nombre 8 388 607.5 celui-ci sera alors représenté en notation binaire à virgule fixe comme
0111 1111 1111 1111 1111 1111.1 et ce dernier traduit en notation scientifique binaire nous donne le
code 1.111 1111 1111 1111 1111 1111 X 222 . Donc avec le nombre 8 388 607 nous ne pourrons ajouter
qu’un seul chiffre après la virgule et si celui-ci est inférieur à 0.5 le résultat sera arrondi vers le bas par
exemple 8 388 607.25 la réponse sera 8 388 607.0 tandis que si le nombre est 8 388 607.75 nous aurons
8 388 608.0 donc arrondi vers le haut.

Traduction d’un nombre inférieur à 1 :

Prenons le chiffre 0.2578125 quelle sera sa conversion en point flottant sur 32 bits ? Faisons le calcul.
Nous effectuons la même démarche qu’à la page 5, soit :
0.2578125 X 2 = 0.515625 on conserve le 0
0.515625 X 2 = 1.03125 on conserve le 1
0.03125 X 2 = 0.0625 on conserve le 0
0.0625 X 2 = 0.125 on conserve le 0
0.125 X 2 = 0.250 on conserve le 0
0.250 X 2 = 0.500 on conserve le 0
0.500 X 2 = 1.000 on conserve le 1
0000 X 2 = 0.000 on arrête là
Le code binaire est : 0.0100001 La réponse en hexa sur 32 bits est : 0x3E840000
Notation binaire scientifique : 1.00001 X 2-2 « Exposant » = -2 + 127 = 125 = 0x7D

0 0 1 1 1 1 1 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

S exposant mantisse

André Touchette Page 8/10

 243-616-EM Intégration de systèmes Cégep Édouard-Montpetit

Norme IEEE 754 : Double précision sur 64 bits

Dans ce mode nous avons la représentation suivante :
S 63 62 61 60 .. 52 51 50 1 0
S S Exposant 11 bits Mantisse (M) 52 bits

La mantisse (partie fractionnaire)

Bit de signe : 0 --> positif

1 --> négatif
Sous forme mathématique l’expression globale du nombre représenté en notation scientifique binaire
est alors :

Où : S est le bit de signe 0 ou 1

1,M correspond au nombre binaire en notation scientifique binaire comme 1,010111010
donne le déplacement de la virgule afin d’obtenir la nombre final.
« Exposant » peut valoir entre 0 et 2047

Nombres particuliers :
Le chiffre 0 sera exprimé de deux manières soit ±0 lorsque le bit de signe est 0 ou 1 et que tous les
autres bits sont à 0. Comme le montre le code suivant :

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 . . . 0 0 0 0 0 0 0 0

S exposant mantisse
Ou

1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 . . . 0 0 0 0 0 0 0 0

S exposant mantisse

L’infini : Est exprimé par le code 0x7FF0000000000000

0 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 . . . 0 0 0 0 0 0 0

S exposant mantisse
et : Est exprimé par le code 0xFFF0000000000000

1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 . . . 0 0 0 0 0 0 0

S exposant mantisse

André Touchette Page 9/10

243-616-EM Intégration de systèmes Cégep Édouard-Montpetit

Le plus gros nombre positif : Tous les bits à 1 sauf le bit de signe à 0 donne le code 0x7FFFFFFF

0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 . . . 1 1 1 1 1 1 1

S exposant mantisse
Calcul :

Le plus gros nombre négatif : Tous les bits sont à 1 ainsi que le bit de signe, donne le code 0xFFFFFFFF

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 . . . 1 1 1 1 1 1 1 1

S exposant mantisse
Calcul :

Voir le texte « Aide mémoire et base du langage C » à la page 4 où le tableau indique les valeurs
maximales positives et négatives pour les types de variables.

Tous les calculs et la démarche pour déterminer les codes binaires fractionnaires ou les valeurs entières
se font de la même manière. Donc il n’est pas pertinent ici de vous refaire ce qui a été expliqué
précédemment. Voici quelques questions qui vous permettront de vous faire la main à ce sujet.

Exercices
1) Exprimez le nombre 42.75 sous la forme d’un nombre en hexadécimal du type point flottant simple
précision.
2) Idem mais pour le nombre -315.8525
3) Si j’ai la représentation en hexadécimal suivante 0x3D800000 d’un nombre en point flottant 32 bits,
quelle alors sa vraie valeur en décimal.
4) Si j’ai la représentation en hexadécimal suivante 0x44846800 d’un nombre en point flottant 32 bits,
quelle alors sa vraie valeur en décimal.
5) Quel est le code hexadécimal sur 32 bits du nombre en point flottant -0.2356
6) Exprimer sous la forme hexadécimale le nombre suivant en point flottant double précision sur 64
bits, 50.1875
7) Quel est le nombre représenté par le code hexadécimal de 64 bits en point flottant double précision
suivant : 0x40A0D9C020C49BA6
8) Faites l’addition en point flottant de ces deux nombres exprimés sur 32 bits simple précision.
0x42FB8000 et 0x4242147B effectuez votre calcul en transformant vos deux nombres en
représentation scientifique en base 2. Par exemple 100110.010111 + 111101.11101 Ensuite vous
pourrez retraduire en dans la forme finale comme le sont les deux nombres du début.
Vous avez sur LÉA le programme exécutable « point_flottant.exe » pour valider vos réponses et si vous
voulez voir le fichier source ouvrez-le avec CodeBlocks. Ce programme ce nomme « point_flottant.c »

André Touchette Page 10/10