Représentation des rationnels en binaire

Version imprimable

23/05/2014, 19h40
manu1818

Représentation des rationnels en binaire

Bonjour,

Je cherche à comprendre comment représenter en base deux un nombre rationnel.

On me dit que :
1/10 = 0.01111011.10011001100110011001100

Je comprends qu'en écrivant :
0.1*2 = 0.2
0.2*2 = 0.4
0.4*2 = 0.8
0.8*2 = 1.6
0.6*2 = 1.2
0.2*2 = 0.4
et on reboucle...

J'en retire donc comme mantisse : 00011001100110011001100

Mais déjà, cette mantisse est différente de celle donnée ci-dessus : mon premier chiffre est un 0 au lieu d'un 1. Pourriez-vous m'expliquer cette divergence ?
Ensuite, comment calculer l'exposant ?

Merci d'avance
24/05/2014, 00h20
Obsidian
Bonjour et bienvenue,

Ton raisonnement est bien le bon. Ce que tu vois à la première ligne est en fait la valeur « 0,1 » écrite au format IEEE 754, c'est-à-dire le format standard en mémoire des float sur 32 bits, utilisés par le C et par le coprocesseur mathématique des Intel. C'est un format composite artificiel qui ne reflète pas directement le binaire naturel et qui demande un peu de travail aux routines chargées de le traiter (ou à la circuiterie des puces dédiées à cette tâche) mais qui reste néanmoins ce qu'on a trouvé de mieux pour représenter les nombres à virgule. Il s'agit tout simplement de la bonne vieille notation scientifique, mais avec des puissances de deux plutôt que dix.

Concrètement, et de gauche à droite, tu vas trouver :
- Un bit de signe ;
- Huit bits pour l'exposant, signé, et en tenant compte du « biais ». Un « 1.0 » aura 7F pour exposant, soit à peu près la moitié de la plage représentable ;
- Le reste pour la mantisse, en tenant compte du fait que le premier chiffre significatif est forcément un « 1 » en binaire et est donc implicite, ce qui résout pas mal de problèmes. Il n'est donc pas inclus dans cette mantisse.
Un nombre écrit dans ce format est toujours représenté en valeur absolue, mais accompagné de son signe (complètement à gauche) qui peut varier indépendamment du reste.
Si tu poses le premier « 1 » et que tu ajoutes la suite, tu obtiens bien une suite alternée de paires de uns « 11 » et de zéros « 00 », et l'exposant qui ici vaut 7B pousse bien le tout de quatre colonnes vers la droite, donc après la virgule.
25/05/2014, 01h35
manu1818

Salut et merci pour la réponse

Je me demande comment trouver que 1.0 a pour exposant 7F : comment le deviner ? Du coup je me pose la même question pour mon cas, où il vaut 7B.

Ensuite, pourquoi poser 1 comme premier chiffre ? Si c'est pour signifier le premier chiffre significatif qui est systématiquement le 1, alors pourquoi donc puisqu'il est implicite ? Et cela signifierait que j'écrase le premier zéro par le 1 : comment expliquer ça ?
25/05/2014, 12h52
Médinoc

Ça ne se devine pas, l'auteur de la spécification IEEE754 l'a écrit dedans.

Le but, c'est de ne pas avoir à inclure un bit de signe, ou un complément, pour l'exposant. Ainsi, plus la valeur des bits d'exposant est élevée, plus le nombre est grand, c'est aussi simple que ça.
25/05/2014, 12h58
Obsidian
Citation:

Envoyé par manu1818

Salut et merci pour la réponse
Je me demande comment trouver que 1.0 a pour exposant 7F : comment le deviner ? Du coup je me pose la même question pour mon cas, où il vaut 7B.

On le fait en ajoutant 7F à l'exposant normal, tout simplement, et en laissant le champ déborder si nécessaire (et revenir à zéro s'il dépasse FF).

Le format IEEE 754 est normalisé et très documenté, notamment sur Wikipédia : http://fr.wikipedia.org/wiki/IEEE_754
Ces valeurs sont posées par convention. Il ne faut donc pas chercher à les « deviner », sous peine de faire des erreurs dans l'interprétation même des valeurs des flottants. Par contre, il est important de comprendre pourquoi les « biais » ont été introduits.

1. L'exposant sur huit bits est la puissance à laquelle tu vas élever le « 2 » multiplicateur. Un flottant à exposant nul correspondra donc à « 1,mantisse × 2⁰ » et donc, techniquement, à zéro décalage, que ce soit vers la gauche ou vers la droite ;

2. On a introduit le 1 implicite pour deux raisons : d'abord parce qu'on sait que c'est forcément un 1. Le rendre implicite à gauche permet déjà de gagner un bit à droite et donc de gagner en précision mais ça permet également et surtout d'éliminer de fait les zéros non significatifs et de résoudre un problème assez génant : s'ils apparaissaient dans la mantisse, il y aurait plusieurs façons de représenter un même nombre. Par exemple : « 10 × 2⁵ » = « 5 × 2⁶ ». Ce serait très ennuyeux parce qu'on ne pourrait plus se contenter de comparer les registres bits à bits pour savoir s'ils sont égaux (les circuiteries électroniques sont directement faites pour, donc ça se passe « en dessous » du niveau logiciel). Il faudrait systématiquement faire des réalignements pour savoir si, en fin de compte, il s'agit du même nombre ou pas. En outre, comme les float sont toujours codés sur 32 bits, le nombre total de valeurs différentes représentables reste le même que celui des entiers, et avoir des synonymes réduit d'autant cet ensemble. Apparemment, le « 1 » implicite est donc une idée providentielle ;

3. Tout cela serait parfait si ce concept n'introduisait pas un défaut absolument rédhibitoire : le 1 implicite interdit de fait de représenter le zéro ! Il est clair que ce format quasi-parfait deviendrait totalement inutilisable s'il ne pouvait pas représenter les valeurs nulles. Pour ce faire, il va donc falloir réserver une configuration fixe (une sorte de magic number) qui vaudra zéro par convention.

Bien entendu, la configuration idéale pour représenter le zéro serait « 00 00 00 00 », soit tous les bits du registre à zéro. Pas seulement parce que c'est intuitif et naturel, mais également parce que le nombre resterait alors compatible avec les détecteurs de zéro codés dans les micro-processeurs et les unités de traitement numérique en général. Il s'agit d'un gros NON-OU logique reliés à tous les bits d'un registre à la fois et qui passe donc à 1 lorsque tous ces bits sont nuls. C'est ce câblage qui forme le bit « Z » des flags de tous les micro-processeurs et il est fondamental pour tous les calculs. Non seulement il permet de vérifier facilement une condition logique, par exemple, mais il permet aussi de détecter la fin d'un décompte (quand on décrémente un registre avec DEC sans faire explicitement une soustraction) et surtout, c'est sur lui que s'appuient toutes les comparaisons : lorsque l'on compare électroniquement deux nombres entiers (avec CMP en assembleur par exemple), on effectue en fait une soustraction et on vérifie si le résultat est nul.

C'est là qu'intervient le biais : si l'exposant était codé en binaire naturel signé, alors « 00 00 00 00 » donnerait en binaire « 0.00000000.00000000000000000000000 », soit littéralement « 1,0000000 × 2⁰ » = « 1 ». Si on réserve 00 00 00 00 pour les valeurs nulles, on ne peut plus coder le « 1 ». C'est tout aussi inacceptable.

Ce qui est intéressant, c'est que cela ferait également un « trou » en plein milieu de l'intervalle des exposants qui, de [-128;+127], passerait à [-128;-1] ∪ [+1;+127].

Justement, « décaler » toutes les valeurs de champ de l'exposant de 7F unités fait en sorte que « 00 » corresponde à -127 et soit donc le plus petit exposant représentable. Non seulement, ça le relègue du milieu de l'intervalle à son extrémité gauche, ce qui permet de garder celui en un seul morceau, mais cet exposant correspondrait alors aux nombres les plus « faibles », c'est-à-dire les plus proches de zéro. À dire vrai, tous les nombres dont l'exposant se retrouvent en dessous de cette limite sont déjà considérés comme « infiniment faibles », en tout cas trop faibles pour être représentés et sont donc arrondis à zéro dans les calculs. Il suffit donc de faire de même pour juste un nombre de plus et le problème est résolu.

Concrètement, ça donnerait :
```
…
83 2⁴
82 2³
81 2²
80 2¹
7F 2⁰
7E 2⁻¹
7D 2⁻²
7C 2⁻³
7B 2⁻⁴
…
```
Dernier point : pourquoi avoir choisi 7F et pas directement 80 ? Ça aurait représenté exactement la moitié de l'intervalle et ça aurait permis de n'avoir qu'à inverser le bit 7 pour trouver la bonne valeur. C'est d'ailleurs une opération que l'on fait très fréquent quand on passe du signé au non signé, et avec les formats sonores, notamment.

Ça s'explique par le fait que l'on cherche à conserver un intervalle symétrique [-126;+126], donc au cardinal impair si on tient compte de l'exposant nul, et parce que le format en profite pour définir d'autres valeurs spéciales, comme les nombres dénormalisés, les ± infinis, et les NaN (Not a Number), utile lorsque qu'un résultat sort de l'ensemble des réels, soit parce qu'il n'existe pas, soit par exemple parce qu'il devient un nombre complexe (racine des nombres négatifs).

Citation:

Ensuite, pourquoi poser 1 comme premier chiffre ? Si c'est pour signifier le premier chiffre significatif qui est systématiquement le 1, alors pourquoi donc puisqu'il est implicite ? Et cela signifierait que j'écrase le premier zéro par le 1 : comment expliquer ça ?

Non, justement, je disais que nous posions nous-mêmes le 1 implicite pour retrouver la mantisse que tu cherches. Tu as écrit :

Citation:

Envoyé par manu1818

On me dit que :
1/10 = 0.01111011.10011001100110011001100

et

Citation:

Envoyé par manu1818

J'en retire donc comme mantisse : 00011001100110011001100

Maintenant, si tu poses le 1 :
1

… et que tu juxtaposes la mantisse que l'on t'a donnée, tu obtiens :
1,10011001100110011001100

Si à présent, en vertu de l'exposant, tu décales cette suite de quatre positions vers la droite, tu as :
0,000110011001100110011001100

En retirant enfin la partie entière (ici nulle) tu retrouves bien la séquence que tu avais déterminée seul :
000110011001100110011001100
25/05/2014, 14h10
Iradrille

Hello,

Citation:

Envoyé par manu1818

J'en retire donc comme mantisse : 00011001100110011001100

Mais déjà, cette mantisse est différente de celle donnée ci-dessus : mon premier chiffre est un 0 au lieu d'un 1. Pourriez-vous m'expliquer cette divergence ?
Ensuite, comment calculer l'exposant ?

Merci d'avance

La première étape est d'avoir un nombre entre 0 et 1, tant que ce n'est pas le cas tu le divise par 2.
Tu as un nombre dans cet intervalle donc tu passe cette étape, mais on note "n" le nombre de fois que l'on a du diviser par 2 pour la suite. (Ici n = 0).

La mantisse d'un float est sur 24 bits et non 23.

Tu as maintenant calculé ta mantisse, et tu as une première idée de l'exposant : exposant = n.

Le premier bit est "caché" : il est forcément à 1 pour un nombre normalisé (qui à donc un exposant biaisé > 0).

Il faut que tu normalise ton nombre, tu as actuellement
signe : 0
exposant : 0 (+0x7f = 0x7f)
mantisse : 0 000 1100 1100 1100 1100 1100

Tu comptes le nombre de 0 en tête de ta mantisse : 4, puis tu ajustes ton exposant et shift à gauche ta mantisse :
signe : 0
exposant : 0-4 = -4 (+0x7f = 0x7b)
mantisse : 1 100 1100 1100 1100 1100 => ta mantisse est maintenant trop courte, il faut recalculer 4 bits supplémentaires, elle devient
mantisse : 1 100 1100 1100 1100 1100 1100

Si ton exposant biaisé est négatif, alors l'exposant sera 0, et tu shift ta mantisse à droite de -exposant positions.
Si ton exposant biaisé est >= 0xff, alors l'exposant sera 0xff et la mantisse sera 0, tu auras + ou - infini.

Il te reste à assembler ton nombre, le bit caché est supprimé.
0 01111011 10011001100110011001100
25/05/2014, 14h39
manu1818

Obsidian : je n'ai pas compris comment obtenir 7B pour mon exposant : ok pour 7F₁₆ = 127₁₀ = biais pour 32 bits, là je comprends, mais pour 2^-4, je vois que ça fait 1/16 et pas 1/10, et que 2^-3 = 1/8 est plus proche : du coup peut-être arrondit-on par défaut ?

Citation:

Envoyé par Iradrille

La mantisse d'un float est sur 24 bits et non 23.

Mon cours donne, pour 32 bits, 23 bits pour la mantisse, 8 pour l'exposant et 1 pour le signe. Si c'est 24, on passe à 24+8+1=33 ?

Du coup tu arrives à 0 000 1100 1100 1100 1100 1100 en ajoutant un 0 (?) Avec cette méthode, j'ai tout compris sauf ça : le 0 que je n'obtiens pas dans ma mantisse (qui n'a que 3 zéros en tête)
25/05/2014, 15h33
Iradrille

Citation:

Envoyé par manu1818

Mon cours donne, pour 32 bits, 23 bits pour la mantisse, 8 pour l'exposant et 1 pour le signe. Si c'est 24, on passe à 24+8+1=33 ?

Du coup tu arrives à 0 000 1100 1100 1100 1100 1100 en ajoutant un 0 (?) Avec cette méthode, j'ai tout compris sauf ça : le 0 que je n'obtiens pas dans ma mantisse (qui n'a que 3 zéros en tête)

Il y à bien que 23 bits présents, mais un 24eme bit est "caché", sa valeur peut se déduire des 8 bits de l'exposant, il n'est donc pas stocké directement (ça permet d'économiser un bit, et donc de représenter plus de valeurs).

Pour le 0, oui, on l'ajoute simplement, c'est le bit caché qui devra passer à 1 lors de la normalisation.

Une mantisse normalisée représente une valeur entre 1 et 2, le bit caché vaut 1 (2^0 == 1).
En partant d'une valeur entre 0 et 1 pour calculer la mantisse, ce bit caché vaudra donc forcément 0.
25/05/2014, 16h43
Obsidian

Citation:

Envoyé par manu1818

Obsidian : je n'ai pas compris comment obtenir 7B pour mon exposant : ok pour 7F₁₆ = 127₁₀ = biais pour 32 bits, là je comprends, mais pour 2^-4, je vois que ça fait 1/16 et pas 1/10, et que 2^-3 = 1/8 est plus proche : du coup peut-être arrondit-on par défaut ?

« 1÷8 » = « 0,125 », ce qui est supérieur à « 0,1 ». On prend donc le suivant : « 1÷16 » = « 0,0625 » et on complète avec des valeurs plus petites (les bits suivants), jusqu'à approcher au plus précis la valeur à atteindre.

Citation:

Du coup tu arrives à 0 000 1100 1100 1100 1100 1100 en ajoutant un 0 (?) Avec cette méthode, j'ai tout compris sauf ça : le 0 que je n'obtiens pas dans ma mantisse (qui n'a que 3 zéros en tête)

C'est parce que tu commences par faire ta multiplication et donc par pousser un chiffre de l'autre côté de ta virgule. Par conséquent, ton résultat ne contient que la partie fractionnaire (donc la mantisse). Un float avec une mantisse nulle et un exposant de 7F vaut exactement « 1 », si bien que l'on considère que le 1 implicite est entier, et que le reste est défini par ta mantisse : « 1,[mantisse] ». Donc, il faut bien faire quatre décalages.

Citation:

Envoyé par Iradrille

Il y à bien que 23 bits présents, mais un 24eme bit est "caché", sa valeur peut se déduire des 8 bits de l'exposant, il n'est donc pas stocké directement (ça permet d'économiser un bit, et donc de représenter plus de valeurs).

Tout cela est vrai mais c'est ce que l'on explique depuis le départ.
Pensez à recharger le fil de discussion avant de poster ! ;-)
26/05/2014, 11h30
manu1818

Citation:

Envoyé par Iradrille

Si ton exposant biaisé est négatif, alors l'exposant sera 0, et tu shift ta mantisse à droite de -exposant positions.
Si ton exposant biaisé est >= 0xff, alors l'exposant sera 0xff et la mantisse sera 0, tu auras + ou - infini.

Dans quel cas l'exposant biaisé peut-il être négatif ? On est parti de 0 au début, et on enlève à l'exposant autant qu'il y a de zéros en tête de la mantisse. Y a-t-il des cas où l'on ne démarre pas à 0 ? Où l'on rajoute plutôt qu'enlève à l'exposant ?

Citation:

Envoyé par Iradrille

Il y à bien que 23 bits présents, mais un 24eme bit est "caché", sa valeur peut se déduire des 8 bits de l'exposant, il n'est donc pas stocké directement (ça permet d'économiser un bit, et donc de représenter plus de valeurs).

Pour le 0, oui, on l'ajoute simplement, c'est le bit caché qui devra passer à 1 lors de la normalisation.

Une mantisse normalisée représente une valeur entre 1 et 2, le bit caché vaut 1 (2^0 == 1).

Je n'ai pas compris comment déduire le bit caché à partir de l'exposant.

Pourquoi une mantisse normalisée représenterait une valeur entre 1 et 2 ?

Citation:

Envoyé par Iradrille

En partant d'une valeur entre 0 et 1 pour calculer la mantisse, ce bit caché vaudra donc forcément 0.

Donc quand on part d'un nombre en base dix dont le dénominateur est supérieur au numérateur, le bit caché de sa mantisse de sa représentation binaire vaudra forcément 0 ? Je croyais que le bit caché (implicite), valait 1 par défaut.
26/05/2014, 12h43
Iradrille

Citation:

Envoyé par manu1818

Dans quel cas l'exposant biaisé peut-il être négatif ? On est parti de 0 au début, et on enlève à l'exposant autant qu'il y a de zéros en tête de la mantisse. Y a-t-il des cas où l'on ne démarre pas à 0 ? Où l'on rajoute plutôt qu'enlève à l'exposant ?

Avec un petit nombre (< ~1.18*10^-38). Le nombre est entre 0 et 1, on part d'un exposant == 0.
Quant tu vas calculer la mantisse, tu auras quelque chose du genre : 0000 0000 ... 0000 1xxx, avec plus de 127 zéros avant de voir apparaitre le premier '1'.
Lors de la normalisation l'exposant deviendra < -127 (car on cherche à faire passer le bit caché à '1'), et en ajoutant le biais (0x7f = 127), l'exposant restera donc négatif.

Citation:

Envoyé par manu1818

Je n'ai pas compris comment déduire le bit caché à partir de l'exposant.

Si l'exposant ~~(non biaisé)~~ (biaisé) est égal à 0, alors le bit caché est '0' (nombre dénormalisé, mantisse entre 0 et 1).
Sinon le bit caché est '1' (cas général, nombre normalisé, mantisse entre 1 et 2)

Citation:

Envoyé par manu1818

Pourquoi une mantisse normalisée représenterait une valeur entre 1 et 2 ?

Parce que la norme le dit. ;)
La mantisse possède 24 bits représentant les valeurs :
2⁰ (= 1)
2^-1 (= 0.5)
2^-2 (= 0.25)
...
Par définition, le premier bit (caché) est à '1', donc la mantisse vaudra minimum 1. Pour la limite supérieure de 2, il existe une démonstration mathématique (somme des termes d'une suite géométrique ou un truc du genre).

Citation:

Envoyé par manu1818

Donc quand on part d'un nombre en base dix dont le dénominateur est supérieur au numérateur, le bit caché de sa mantisse de sa représentation binaire vaudra forcément 0 ? Je croyais que le bit caché (implicite), valait 1 par défaut.

Si la valeur absolue de ton nombre de départ est inférieur à ~1.18*10^-38, le bit caché sera à 0, sinon il sera à 1.
Dans tous les cas, tu le met à '0' dans un premier temps, et il passera correctement à '1' avec la normalisation.

Citation:

Envoyé par Obsidian

« 1÷8 » = « 0,125 », ce qui est supérieur à « 0,1 ». On prend donc le suivant : « 1÷16 » = « 0,0625 » et on complète avec des valeurs plus petites (les bits suivants), jusqu'à approcher au plus précis la valeur à atteindre.

Whoo, je viens de comprendre, c'est tellement plus simple que la technique que j'essaie d'expliquer. 8O
On récupère directement l'exposant, on a besoin de calculer seulement 23 bits de la mantisse, c'est parfait.

Citation:

Envoyé par Obsidian

Tout cela est vrai mais c'est ce que l'on explique depuis le départ.
Pensez à recharger le fil de discussion avant de poster ! ;-)

J'ai jamais dit le contraire. ;)

edit : correction.
26/05/2014, 12h47
Obsidian

Citation:

Envoyé par manu1818

Dans quel cas l'exposant biaisé peut-il être négatif ? On est parti de 0 au début, et on enlève à l'exposant autant qu'il y a de zéros en tête de la mantisse. Y a-t-il des cas où l'on ne démarre pas à 0 ? Où l'on rajoute plutôt qu'enlève à l'exposant ?

Ben oui, quand tu codes des grands nombres. Si tu écris par exemple « 369 × 2¹⁰⁰ », tu ajoutes bien une centaine de zéros après ta mantisse (en déduisant quand même ceux qui s'y trouvaient déjà).

Citation:

Pourquoi une mantisse normalisée représenterait une valeur entre 1 et 2 ?

Parce qu'avant d'avoir appliqué l'exposant, on a expliqué depuis quelque posts que ton nombre vaut « 1,mantisse ». Ça correspond de fait à l'intervalle [1;2[.

Citation:

Donc quand on part d'un nombre en base dix dont le dénominateur est supérieur au numérateur, le bit caché de sa mantisse de sa représentation binaire vaudra forcément 0 ? Je croyais que le bit caché (implicite), valait 1 par défaut.

Non, non, non. Le bit caché à zéro ne concerne que les nombres dénormalisés, ce qui est un cas particulier (que tu peux laisser de côté pour le moment).

Considérons que tes nombres sont toujours positifs. Si tu pars d'un rationnel au dénominateur supérieur au numérateur, son résultat sera forcément compris dans ]0;1[. Ce sera donc un nombre binaire non nul dont le premier chiffre significatif sera un 1. Rien ne change de ce côté-là. La seule affirmation que tu peux faire est que ton exposant sera forcément négatif (avant application du biais, bien sûr).

(EDIT: Crosspost avec Iradrille).
03/06/2014, 19h29
manu1818

Merci pour votre aide !

Tout est clair maintenant, je me suis donc fait ma propre méthode pour déterminer la représentation IEEE754 des nombres à virgule flottante :
1/ Déterminer le signe (0 : positif, 1 : négatif)
2/ Convertir la partie entière en binaire via des divisions successives par 2 (le résultat est la suite des restes obtenues en commençant par le dernier reste pour le bit de poids fort)
3/ Convertir la partie décimale en binaire via des multiplications sucessives par 2 (comme présenté ci-haut)
4/ Accoler partie entière et partie décimale en les séparant par une virgule
5/ Décaler la virgule de façon à avoir 1,mantisse et compter le nombre de décalages
6/ Si le décalage de la virgule s'est fait vers la gauche, l'exposant est biais + nb. de décalages, sinon il est biais - nb. de décalages
7/ On convertir l'exposant en binaire
8/ On écrit le signe suivi de l'exposant en binaire suivi de la représentation binaire de la mantisse (sans le 1 avant la virgule)

merci et bonne journée