Comment obtenir la représentation binaire ?

Version imprimable

21/01/2011, 10h09
mouthana22

Comment obtenir la représentation binaire ?

Bonjour à tous je suis un nouveau sur le site mais aussi dans le monde fascinant des représentations binaires8O et donc voila je suis tomber sur une valeur ou il m'est difficile de trouvé sa représentation il s' agit de 0.001 tenez par exemple pour 0.125 il suffit de voir que ça correspond a 1/8 et donc 1* (2)expo -3
d'ou un signe a 0 un exposant de 01100 et une mantisse nulle 0000000000
ce qui donne 0 01100 0000000000 mais pour 0.001 ... j'ai essayé mainte fois j'y arrive pas:cry:car la mantisse et difficile a obtenir vu que c'est de la forme (1+ mantisse) j'arrive pas à sortir le 1 donc à l'aide SVP

Salut!
J'ai retrouvé un petit programme que j'avais écrit il y a quelques années pour résoudre des problèmes comme le tien. Pour 0.001, ou 1./1000. ce qui revient au même, il me donne:

Code:

00111010 10000011 00010010 01101111

A tout hazard, je te joins le code du sous-programme utilisé:

Code:

1
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
C
C **********************************************************************
C
      Subroutine AS0121    
C
C     Représentation d'une variable de type Real*4
C
C **********************************************************************
C
C     Déclarations
C
      Implicit None
C
      Character*80 S
      Real*4 R,Ra,Rb
      Integer*1 I1(4),I1a(4),I1b(4),K
      Equivalence (I1,R),(I1a,Ra),(I1b,Rb)
C
C **********************************************************************
C
C     Instructions exécutables
C
      Open (4,File='AS0121.txt')
   10 Write (*,*) ' '
      S='Tapez le numérateur'
      Call U003(S,Len_Trim(S))
      S='(Ctrl-Z pour quitter)'
      Call U003(S,Len_Trim(S))
      Read (*,*,End=99,Err=20) Ra
      Go To 30
C
   20 S='Donnée incorrecte'
      Call U003(S,Len_Trim(S))
      Go To 10
C
   30 S='Tapez le dénominateur'
      Call U003(S,Len_Trim(S))
      Read (*,*,End=99,Err=40) Rb
      Go To 50
C
   40 S='Donnée incorrecte'
      Call U003(S,Len_Trim(S))
      Go To 30
C
   50 R=Ra/Rb
      Write (*,'(//2F8.3,E16.9)') Ra,Rb,R
      Write (*,'(/1X,A)') 'Adr+3    Adr+2    Adr+1    Adr'
      Write (*,'(4(1X,8I1))')
     *  (-BTest(I1(4),K),K=7,0,-1),(-BTest(I1(3),K),K=7,0,-1),
     *  (-BTest(I1(2),K),K=7,0,-1),(-BTest(I1(1),K),K=7,0,-1)
C
      Write (4,'(//2F8.3,E16.9)') Ra,Rb,R
      Write (4,'(/1X,A)') 'Adr+3    Adr+2    Adr+1    Adr'
      Write (4,'(4(1X,8I1))')
     *  (-BTest(I1(4),K),K=7,0,-1),(-BTest(I1(3),K),K=7,0,-1),
     *  (-BTest(I1(2),K),K=7,0,-1),(-BTest(I1(1),K),K=7,0,-1)
      Go To 10
C
   99 Close (4)
      Return
      End

Jean-Marc Blanc

Si tu veux le faire "à la main" :

Code:

1
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
0.001*2 = 0.002 --> 0
0.002*2 = 0.004 --> 0
0.004*2 = 0.008 --> 0
0.008*2 = 0.016 --> 0
 
0.016*2 = 0.032 --> 0
0.032*2 = 0.064 --> 0
0.064*2 = 0.128 --> 0
0.128*2 = 0.256 --> 0
 
0.256*2 = 0.512 --> 0
0.512*2 = 1.024 --> 1   <-- 1 * 2^-10
0.024*2 = 0.048 --> 0   <-- début mantisse : 2^-11
0.048*2 = 0.096 --> 0
 
0.096*2 = 0.192 --> 0
0.192*2 = 0.384 --> 0
0.384*2 = 0.769 --> 0
0.769*2 = 1.536 --> 1   
 
0.536*2 = 1.072 --> 1
0.072*2 = 0.144 --> 0
0.144*2 = 0.288 --> 0
0.288*2 = 0.576 --> 0
 
0.576*2 = 1.152 --> 1
0.152*2 = 0.304 --> 0
0.304*2 = 0.608 --> 0
0.608*2 = 1.216 --> 1
...

Code:

1
2
3
signe = positif -------------> 0
exp   = -11 = -128 + 117 ----> 01110101
mantisse --------------------> 00000110001001...

et on retrouve bien la valeur donnée par Jean-Marc.

23/01/2011, 14h14
mouthana22

représentation binaire de 0.001

merci a toutes et à tous je ne conteste absolument pas vos réponse notamment celle de la resolution à "la main" qui est très efficace toutefois il me semble que la representation obtenue est trop longue dans le sens ou l'exposant a + de 5 chiffre et la mantisse + de 10 tenez par exemple pour représenter "binarement" 0.125 on obtient : 0.125 = 1/8= 0 01100 0000000000 donc je ne comprend pas :?

@pseudocode: la resolution à "la main" est incontestable toute fois la mantisse ainsi que l'exposant me semblent être un peu long car pour la valeur que j'ai eu a résoudre au préalable (0.125) sa représentation était:0.125= 1/8 = 0 (signe) 01100(exposant 5 chiffres) 0000000000(mantisse 10 chiffres) donc ...par contre je m'excuse de ne pas avoir précisé que je travaille en demi-précision sous la norme IEEE 754
23/01/2011, 14h40
FR119492

Salut!
Le nombre 0.001 n'est pas un entier. Pour le stocker en mémoire, il faut donc le considérer comme un réel en virgule flottante. Regarde donc la norme ANSI/IEEE Std 754-1985 où tout ça est expliqué.
Jean-Marc Blanc
23/01/2011, 18h56
pseudocode
Citation:

Envoyé par mouthana22

par exemple pour représenter "binarement" 0.125 on obtient : 0.125 = 1/8= 0 01100 0000000000 donc je ne comprend pas :?

Citation:

je travaille en demi-précision sous la norme IEEE 754

Ah, c'est sur que ca change tout. En demi-précision, la réprésentation est sur 16 bits:

s eeeee mmmmmmmmmm

decimal = (-1)^s * 1*2^(eeeee-15) * (mmmmmmmmmm)*2^(eeeee-16)
Code:

1 2 3 4 5 6 7 0.125 * 2 = 0.25 --> 0 0.25 * 2 = 0.5 --> 0 0.5 * 2 = 1.0 --> 1 <-- 1 * 2e-3 0 *2 = 0 --> 0 <-- début mantisse : 2^-4 0 ...
Code:

1 2 3 4 signe = positif ----------> 0 exp = -4 = -16 + 12 ----> 001100 mantisse -----------------> 0000000000
0.125 --> 0 001100 0000000000
31/01/2011, 18h15
on2101
Bonjour,

Une bonne idée serait, je pense, d'utiliser un debugger (gdb par exemple) afin d'accéder au codage binaire des variables en mémoire. Par exemple, un code C du type
Code:

1 2 3 4 5 6 7 8 9 10 #include( ... ) main() { float x, y; x = 0.001; y = 0.125; }
pourrait faire l affaire.