Discussion :

[mouthana22]

Bonjour à tous je suis un nouveau sur le site mais aussi dans le monde fascinant des représentations binaires 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 pascar 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

[FR119492]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

00111010 10000011 00010010 01101111

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[pseudocode]

Si tu veux le faire "à la main" :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

[mouthana22]

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

[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

[pseudocode]

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

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
signe = positif ----------> 0
exp   = -4 = -16 + 12 ----> 001100
mantisse -----------------> 0000000000

0.125 --> 0 001100 0000000000

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.