Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter
Discussion :
Convertir un nombre décimal fractionnaire négatif en base 2
Bonjour,
Je dois convertir le nombre suivant : -127,635 de la base 10 en base 2. Est-il possible d'utiliser le complément à deux et dans ce cas comment l'appliquer à un nombre binaire fractionnaire.
Si pouviez m'expliquer de façon détaillée la procédure à suivre pour effectuer cette conversion je vous serais très reconnaissant, encore merci pour votre, aide...
Salut!
J'ai retrouvé dans mes archives un sous-programme qui semble correspondre à ce que tu cherches:
Jean-Marc Blanc
Code : Sélectionner tout - Visualiser dans une fenêtre à part
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118C C ********************************************************************** C Subroutine U008(A,J,Bout) C C ********************************************************************** C C Bibliothèque JMBPack C C Série U: Utilitaires C C ********************************************************************** C C Routine U008: Décomposition d'un nombre réel sur 4 octets C C Version 1.0, Jean-Marc Blanc, décembre 2011 C C ********************************************************************** C C Un nombre réel mémorisé sur 4 octets est décomposé en une C suite de 32 entiers valant 0 ou 1. C C ********************************************************************** C Implicit None C Real*4 A Integer*1 J(4,8) Logical Bout C C A l'entrée: C C A Le nombre à décomposer. C C Bout Boutisme C Vrai Grand à la fin (big endian) C Faux Petit à la fin (little endian) C C A la sortie: C C J Les 32 bits contenant le nombre décomposé. C C ********************************************************************** C Real*4 AA Integer*1 K,L(4) Equivalence (AA,L) C AA=A If (Bout) Then Do K=1,8 If (BTest(L(1),8-K)) Then J(1,K)=1 Else J(1,K)=0 End If End Do C Do K=1,8 If (BTest(L(2),8-K)) Then J(2,K)=1 Else J(2,K)=0 End If End Do C Do K=1,8 If (BTest(L(3),8-K)) Then J(3,K)=1 Else J(3,K)=0 End If End Do C Do K=1,8 If (BTest(L(4),8-K)) Then J(4,K)=1 Else J(4,K)=0 End If End Do C Else Do K=1,8 If (BTest(L(4),8-K)) Then J(4,K)=1 Else J(4,K)=0 End If End Do C Do K=1,8 If (BTest(L(3),8-K)) Then J(3,K)=1 Else J(3,K)=0 End If End Do C Do K=1,8 If (BTest(L(2),8-K)) Then J(2,K)=1 Else J(2,K)=0 End If End Do C Do K=1,8 If (BTest(L(1),8-K)) Then J(1,K)=1 Else J(1,K)=0 End If End Do End If C Return End
En fait, quelque soit la base de destination, toute l'astuce consiste à faire passer chaque chiffre, un par un, de l'autre côté de la virgule. Il faut donc distinguer la partie entière de la partie décimale, puis faire des divisions successives par 2 sur la première et des MULTIPLICATIONS sur la deuxième.Envoyé par christian79
D'ailleurs, on peut voir tout de suite que tu pourras facilement convertir « -127,625 » mais que « -127,635 » risque de poser des problèmes. :-)
Enfin, on considère que tu ne travailles pas en binaire naturel, mais avec la valeur absolue de ton nombre, fût-il écrit en binaire, et un bit de signe distinct à côté.
Bonjour,
Je m'excuse, et ne le prenez pas mal, mais je ne comprends pas votre explication... Dans quel sens faut-il faire passer un par un les chiffres ? De la partie entière à la partie décimale ou l'inverse ? Pourriez-vous en partant de mon nombre -127,635 appliquer votre méthode de façon à me permettre de voir comment la mettre en oeuvre ?
Je comprends par contre l'explication relative à l'opération de conversion. En effet, il faut diviser la partie entière par 2 et multiplier par 2 la partie fractionnaire, pas de problème de ce côté là.
Enfin j'observe que le fait de faire passer les chiffres de l'autre coté de la virgule, et ce quelque soit le sens, modifie la valeur absolue de la partie entière et de la partie fractionnaire de mon nombre de départ et donc la conversion ne correspondra plus à ce nombre de départ.
En m'excusant de vous solliciter à nouveau et en vous remerciant d'avance pour votre aide...
En fait, dans n'importe quelle base n, chaque rang est n fois plus lourd que son voisin de droite. Par exemple, en base dix, le premier chiffre (à droite) est celui des unités, le suivant celui des dizaines, puis celui des centaines, etc. Cela fait donc « … 1000 100 10 1 » ou « … 10³ 10² 10¹ 10⁰ ».
En binaire, c'est exactement la même chose mais avec un facteur 2 plutôt que 10, soit « … 8 4 2 1 » ou « … 2³ 2² 2¹ 2⁰ ».
Lorsque tu poursuis vers la droite et que tu passes la virgule, le processus reste exactement le même : tu divises le poids par n. Donc passé les unités, tu as les dixièmes, les centièmes, les millièmes, etc. soit « 0,1 0,01 0,001 … » ou « 10⁻¹ 10⁻² 10⁻³ … ».
Là encore, c'est pareil en binaire : « 0,5 0,25 0,125 0,0625 … » ou « 2⁻¹ 2⁻² 2⁻³ … », ce qui correspond aux demis, aux quarts, aux huitièmes, aux seizièmes, etc.
Première observation : un nombre fini dans une base peut ne pas l'être dans une autre. Par exemple « 1 ÷ 3 » s'écrit exactement « 0,3 » en base 9 mais « 0,3333333… » en décimal. Dans le même esprit « 1,5 » en décimal (soit « un » plus « un demi) s'écrit « 1,1 » en binaire mais « 1,2 » en décimal s'écrit en binaire « 1,0011001100110011… ».
Ensuite, pour savoir comment on écrit un nombre entier dans une base donnée, il faut déterminer la valeur du premier chiffres, puis celle des suivants. On comprend assez vite que le « modulo 10 » nous donne la valeur du chiffre des unités en décimal. Or ce modulo 10 n'est autre que le reste de la division par 10. En outre, pour passer au chiffre suivant, il faut « éliminer » le chiffre des unités et décaler les autres vers la droite, pour que le rang des dizaines prenne la place des unités et que l'on puisse faire la même opération. On poursuit ensuite le processus jusqu'à ce que le dividende soit nul (ce qui signifie que l'on a « mangé » tous les chiffres).
Il se trouve que le reste d'une division est forcément ce qui passe de l'autre côté de la virgule puisque c'est par définition ce qui est inférieur à l'unité. Par exemple, si je divise « 139 » par 10, j'obtiens « 13,9 » et je peux dire « j'obtiens 13, il reste 9 ». Si je divise à nouveau ce résultat par dix, j'obtiens « 1,3 », soit « 1, reste 3 ». Si je divise encore une fois, j'obtiens « 0,1 », soit « zéro, reste 1 ». Et comme mon quotient est nul, je m'arrête.
Mes trois restes mis bout à bout forment donc « 9 » , « 3 » et « 1 », soit 139 dans le sens inverse.
Par ailleurs, le fait que l'on puisse décaler les chiffres d'un nombre vers la gauche ou vers la droite respectivement en le multipliant ou le divisant par 10 n'est pas propre au décimal. Cela se produit chaque fois qu'on multiplie ou divise par la base en vigueur. Ça veut dire que je peux décaler mes bits de la même façon en multipliant ou divisant un nombre binaire par 2.
Ce qui est intéressant, c'est que le résultat numérique d'une telle opération reste le même quelque soit la base dans laquelle je travaille. « 10 ÷ 2 = 5 », que je l'écrive en décimal, ou en binaire « 1010 ÷ 10 = 101 », ou en base 3 « 31 ÷ 2 = 12 », etc. Donc, je peux toujours déterminer la valeur de mes chiffres même si je ne travaille pas dans la base concernée. C'est comme cela que je peux faire une conversion d'une base à une autre.
Une fois que c'est fait, et en suivant le même modèle, tu peux faire « franchir la virgule » à tes chiffres décimaux en les poussant vers la gauche, donc en multipliant la partie non entière par dix. La partie entière du résultat est à chaque fois un des chiffres que tu cherches. Par exemple, si je pars de « 0,635 », en multipliant par dix, j'obtiens « 6,35 ». Je retire « 6 », il reste « 0,35 ». Multiplié par dix, j'obtiens « 3,5 ». Je retire « 3 », j'obtiens « 0,5 ». Multiplié par dix, j'obtiens « 5 » et je n'ai plus de partie décimale, donc j'ai fini.
J'obtiens donc « 6 » , « 3 » et « 5 », soit 635, dans le bon sens cette fois puisque je les ai poussés de l'autre côté.
Pour obtenir l'écriture en binaire, il suffit donc de faire la même chose mais en multipliant par deux. Par exemple avec « 0,625 » :
0,625 × 2 = 1,250 ; Je retire 1 ;
0,250 × 2 = 0,500 ; Je retire 0 (donc rien) ;
0,500 × 2 = 1,000 ; Je retire 1 ;
Ma partie non entière est nulle : j'ai fini. « 0,625 » en décimal s'écrit donc « 0,101 » en binaire.
C'est de cette manière que tu vas t'apercevoir que « 0,635 », en revanche, n'est pas un nombre fini en binaire et que ton calcul va se perpétuer ad vitam æternam.
Complément à deux d'un nombre fractionnaire
Bonjour,
Merci beaucoup pour vos explications très détaillées. Vous proposez une méthode de représentation possible, du type : SIGNE + VALEUR ABSOLUE pour représenter le nombre négatif proposé. (Je retiens la méthode).
Mais comment procéder pour représenter le nombre négatif -127,635 en Complément à Deux ? (Autre méthode de représentation d'un nombre signé).
Prendre le Complément à Deux de 127 (entier) ne me pose aucun problème, mais par contre prendre le Complément à Deux de 127,635 là je ne sais pas faire ... En effet comment procéder pour prendre le Complément à Deux d'un nombre fractionnaire ?
Note : Quand je dis prendre le Complément à Deux de 127 j'entends prendre le Complément à Deux de 127 écrit en base 2 soit le Complément à Deux de (1111111).
En vous remerciant...
Ok, mea maxima culpa, j'ai complètement omis le fait que tu parlais de complément à 2 dès le départ.
Il faut dans ce cas travailler en virgule fixe, mais le problème reste le même : si +127,635 ne peut pas être représenté de manière exacte et finie en binaire, alors -127,635 ne peut pas l'être non plus. Par contre, « ±127,625 » est un nombre qui tombe juste.
Pour trouver l'opposé en binaire naturel d'un nombre représenté par un signe suivi de sa valeur absolue, on commence par déterminer la représentation binaire de cette valeur absolue puis on applique le complément à 2. En virgule fixe, le principe est exactement le même qu'avec un nombre entier, sauf que l'unité ne correspond pas au bit de poids faible.
On complémente donc tous les bits et on incrémente le registre normalement, c'est-à-dire qu'on lui ajoute la valeur correspondant au bit de poids faible (et pas spécialement celle de l'unité).
On sait depuis le précédent commentaire que « +127,625 » vaut « 1111111,101 » en binaire. Pour trouver son opposé, on fait donc ce qui suit :
On vérifie en faisant une addition en binaire naturel, qui doit normalement donner « 0 ».1111111,101 ~ 0000000,010 ← Complément à 1 + 0000000,001 ← Incrémentation du bit de poids faible et des suivants ---------------- 0000000,011 ← « -127,625 » en binaire naturel
1111111,101 ← +127,625 + 0000000,011 ← -127,625 ---------------- 0000000,000
Répondre avec citation
Partager