Discussion :

[Melem]

Il est, de meme, dangeureux de partir de l'hypothèse qu'un char fasse 8 bits

Du tout. La taille d'un char est toujours de 1 octet soit 8 bits, c'est dans la norme.

[Jean-Marc.Bourguet]

Du tout. La taille d'un char est toujours de 1 octet soit 8 bits, c'est dans la norme.

Je te suggere de relire 5.2.4.2.1 Sizes of integer types <limits.h>. Un char fait au moins 8 bits, pas exactement 8 bits.

[Emmanuel Delahaye]

Du tout. La taille d'un char est toujours de 1 octet soit 8 bits, c'est dans la norme.

Chapitre et verset ?

La taille d'un char est toujours 1 (char), parce que c'est l'unité de compte.

La largeur d'un char en bit est d'au moins 8.

[sandball22]

Comment fait-on pour representer 1.5 en binaire?

Merci.

[Jean-Marc.Bourguet]

Comment fait-on pour representer 1.5 en binaire?

Il y a plusieurs representations possible. La plus naturelle est 1.1.

[sandball22]

comment on fait d'une facon générale? Je veux faire une fonction qui me fasse cette representation

[Jean-Marc.Bourguet]

comment on fait d'une facon générale? Je veux faire une fonction qui me fasse cette representation

Comment fais-tu pour faire une représentation en base dix d'un flottant? Si le code est correct, la seule chose a faire c'est de changer une constante base de 10 a 2.

[Thierry Chappuis]

frexp puis des multiplications par 2.

Je ne voix pas comment m'en servir pour afficher la représentation binaire d'une variable de type double. Soit le programme basique suivant:

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
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
int main(void)
{
 
    double nombre = 0.15625;
    double mantisse;
    int exposant;
 
    mantisse = frexp(nombre, &exposant);
    printf("nombre: %f\nmantisse: %f\nexposant: %d\n", nombre, mantisse, exposant);
 
    return EXIT_SUCCESS;
}

qui me retourne:

Code :

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

1
2
3
nombre: 0.156250
mantisse: 0.625000
exposant: -2

par multiplication par 2 successives de la valeur de la mantisse, j'arrive à déduire la représentation binaire du nombre flottant 0.156250 en supposant que les double sont représentés selon la norme IEEE 754 double précision (64 bits).

Est-il possible d'écrire une fonction qui affiche la représentation binaire d'un nombre à virgule flottante, à l'aide de frexp(), sans faire la supposition que cette représentation suit IEEE 754?

EDIT: Je raconte n'importe quoi (je dois pas être très réveillé aujourd'hui)! L'écriture de la fonction est relativement triviale.

Thierry

[Jean-Marc.Bourguet]

Est-il possible d'écrire une fonction qui affiche la représentation binaire d'un nombre à virgule flottante, à l'aide de frexp(), sans faire la supposition que cette représentation suit IEEE 754?

Qu'est-ce que tu entends par la representation binaire. La representation naturelle de
0.15625 en binaire c'est quelque chose comme 0.101E-10 et elle est accessible par ce que j'ai donne. Decris moi la representation que tu veux.

[DaZumba]

C'est requis par le langage C, qui ne sait pas fonctionner sur des machines autres que binaires.

C'est requis par la norme ? Je ne vois pas ce qui empeche le langage C d'etre porte sur un ordinateur ternaire...

[Thierry Chappuis]

Qu'est-ce que tu entends par la representation binaire. La representation naturelle de
0.15625 en binaire c'est quelque chose comme 0.101E-10 et elle est accessible par ce que j'ai donne. Decris moi la representation que tu veux.

J'ai raconté n'importe quoi (je dois être fatigué). Je cherchais à afficher la représentation mémoire du flottant, mais cela n'a aucun sens. Oui, la représentation binaire de 0.15625 est 0.101E-10 et l'écriture d'une fonction qui effectue cette tâche est triviale. Mille excuses!

Thierry

[sandball22]

j'aimerais representer un flottant en binaire et l'inverse aussi. Je n'arrive pas à le faire. Quelqu'un pourrait-il m'aider? Merci.

[Emmanuel Delahaye]

j'aimerais representer un flottant en binaire et l'inverse aussi. Je n'arrive pas à le faire. Quelqu'un pourrait-il m'aider? Merci.

Peux-tu montrer une représentation binaire d'un flottant ?

[Neitsa]

Trois pages de discussion et le posteur original repose la question

En fait sandball22, il existe diverses manières de représenter un nombre à virgule en binaire. Donc dans un premier temps, il faudrait que tu nous dises clairement quelle est la représentation que tu souhaiterais...

Deux représentations sont notamment plus utilisées que les autres :

1 ) La représentation binaire à virgule fixe :

10,5 (base 10) = 1010,1 (base 2)

pourquoi /comment 1010,1 ?

1010,1 = 1*2^3 + 0*2^2 + 1*2^1 + 0*2^0 + 1*2^-1 = 8 + 0 + 2 + 1/2

2) La représentation binaire à virgule flottante (IEEE 754).
Il en existe 3 courante : une à 32 bits (dite simple précision), une à 64 bits (double précision) et une à 80 bits (double précision étendue).

Mujigka l'a expliquée dans un précédent post et c'est assez simple à comprendre.

Un exemple :

10,5 (base 10) = 1*2^3 * 1.3125 = 1*2^3 * (1 + 0.250 + 0.0625) =
1*2^3 * (1 + 1*2^-2 + 1*2^-4) = 01000001001010000000000000000000 (base 2)

Soit :

signe : 0
exposant : 10000010 (3 en base 10)
Mantisse : 01010000000000000000000 (1.3125)

représentation finale : 01000001001010000000000000000000

Pour plus de précisions, tu peux voir : http://perso.orange.fr/arsene.perez-...tion/reels.htm

[David.Schris]

[...]
Pour plus de précisions, tu peux voir : http://perso.orange.fr/arsene.perez-...tion/reels.htm

Et pour voir ce que cela donne "en direct" pour le format IEEE754 (32 bits), tu as une applet java ici.

[Thierry Chappuis]

Voilà une tentative de proposition:

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
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <math.h>
 
/**
 * Fournit la représentation binaire d'un entier de type int.
 *
 * @param s_buffer tampon dans lequelle est placé la représentation binaire
 *                 sous la forme d'une chaîne de caractères.
 * @param buffsize taille du tampon
 * @param number entier à représenter sous forme binaire
 *
 * @return code d'erreur valant -1 si la taille du tampon fourni est
 *         insuffisante, et 0 sinon
 */
int int_to_binary_repr(char *s_buffer, size_t buffsize, int number)
{
    int err = 0;
    size_t i;
 
    /* Calcul du nombre de bits nécessaires pour représenter l'entier 
        considéré */
    int n = number;
    size_t int_bits = (n >= 0) ? 0 : sizeof(int) * CHAR_BIT;
 
    if (n >= 0)
    {
        do
        {
            n /= 2;
            int_bits++;
        }
        while (n > 0);
    }
 
    if (buffsize > int_bits)
    {
 
        s_buffer[int_bits] = 0;
 
        for (i = 0; i < int_bits; ++i)
        {
            s_buffer[int_bits-(i+1)] = (number & (1 << i)) ? '1' : '0';
        }
    }
    else
    {
        err = -1;
    }
    return err;
}
 
 
/**
 * Fournit la représentation binaire d'un nombre flottant de type double comme
 * décrit dans la norme IEEE 754.
 *
 * @param s_buffer tampon dans lequelle est placé la représentation binaire
 *                 sous la forme d'une chaîne de caractères.
 * @param buffsize taille du tampon
 * @param x nombre flottant à représenter sous forme binaire
 * @param prec précision utilisée pour représenter la mantisse (max = 52). Si
 *             vaut -1, la précision est maximale.
 *
 * @return code d'erreur valant -1 si la taille du tampon fournit est
 *         inférieure à (prec + 16), et 0 sinon
 */
int double_to_binary_repr(char *s_buffer, size_t buffsize, double x, int prec)
{
    int err = 0;
 
    /* La mantisse est au maximum représentée sur 52 bits */
    int precision = (prec < 0 || prec > 52) ? 52 : prec;
 
    if (buffsize >= precision + 16u)
    {
        size_t i;
        int exp;
        double mantissa;
 
        /* On initialise le tampon */
        for (i = 0; i < buffsize; ++i)
        {
            s_buffer[i] = 0;
        }
        /* On récupère la valeur de la mantisse et de l'exposant */
        mantissa = frexp(x, &exp);
 
        i = 0;
        /* Représentation du signe */
        if (mantissa < 0)
        {
            mantissa = -mantissa;
            s_buffer[i++] = '-';
        }
        else
        {
            s_buffer[i++] = '+';
        }
 
        /* Représentation de la mantisse */
        mantissa *= 2, exp--;
 
        s_buffer[i++] = ((int) mantissa) ? '1':'0';
        mantissa -= floor(mantissa);
        s_buffer[i++] = '.';
 
        while (i < buffsize - 1 && precision > 0 && mantissa != floor(mantissa))
        {
            mantissa *= 2;
            s_buffer[i++] = ((int) mantissa) ? '1':'0';
            mantissa -= floor(mantissa);
            precision--;
        }
 
        /* Représentation de l'exposant */
        if (i < buffsize -1)
        {
            s_buffer[i++] = 'e';
        }
        int_to_binary_repr(s_buffer + i, buffsize - i, exp + 1023);
    }
    else
    {
        /* Erreur: la taille du tampon est insuffisante (< prec + 16) */
        err = -1;
    }
    return err;
}
 
 
int main(void)
{
    /* La taille du tampon doit être au moins de: precision demandée + 16 */
    char s_buffer[68] = {0};
 
    double_to_binary_repr(s_buffer, sizeof s_buffer, 1.0/3, -1);
    puts(s_buffer);
 
    return 0;
}

Thierry

[sandball22]

Et cela va donner quoi? Peux tu m'envoyer un exemple car je ne peux créer facilement un nouveau projet pour tester les différents codes. Il y a toute une procédure.

Sinon , moi j'ai fait de la fàçon suivante, je passe en virgule fixe, cela me donne un nombre entier. Ensuite, je représente ce nombre entier en binaire.

Par exemple: si j'ai 1.5. Si je ceux coder ce chiffre sur 16bits, avec 2 bits d'entier et 14bits parties décimales.


J'aurai 24576 à la sortie de ma fonction en virgule fixe et ensuite j'aurai 0110000000000000. Esce que c'est bon?

[Thierry Chappuis]

Et cela va donner quoi? Peux tu m'envoyer un exemple car je ne peux créer facilement un nouveau projet pour tester les différents codes. Il y a toute une procédure.

Sinon , moi j'ai fait de la fàçon suivante, je passe en virgule fixe, cela me donne un nombre entier. Ensuite, je représente ce nombre entier en binaire.

Par exemple: si j'ai 1.5. Si je ceux coder ce chiffre sur 16bits, avec 2 bits d'entier et 14bits parties décimales.


J'aurai 24576 à la sortie de ma fonction en virgule fixe et ensuite j'aurai 0110000000000000. Esce que c'est bon?

Le code:

Code :

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

1
2
3
4
5
6
7
8
9
10
int main(void)
{
    char s_buffer[26] = {0};
 
    double_to_binary_repr(s_buffer, sizeof s_buffer, 1.0/3.0, 10);
    printf("La représentation binaire de 1.0/3.0 est:\n");
    printf("%s\n", s_buffer);
 
    return 0;
}

me donne:

Code :

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

1
2
La représentation binaire de 1.0/3.0 est:
+1.0101010101e1111111101

Avec une précision de 10 bits pour la mantisse.

Pour une représentation stictement selon la norme IEEE 754:

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
62
63
64
65
66
67
int double_to_ieee754_repr(char *s_buffer, size_t buffsize, double x);
 
int main(void)
{
    char s_buffer[65] = {0};
 
    double_to_ieee754_repr(s_buffer, sizeof s_buffer, 1.0/3.0);
    printf("La représentation IEEE 754 de 1.0/3.0 est:\n");
    printf("%s\n", s_buffer);
 
    return 0;
}
 
int double_to_ieee754_repr(char *s_buffer, size_t buffsize, double x)
{
    int err = 0;
 
    size_t double_bit = sizeof(double) * CHAR_BIT;
    int precision = double_bit - 12;
 
    if (buffsize >= double_bit + 1)
    {
        size_t i;
        int exp;
        double mantissa;
 
        /* On initialise le tampon */
        for (i = 0; i < buffsize; ++i)
        {
            s_buffer[i] = 0;
        }
        /* On récupère la valeur de la mantisse et de l'exposant */
        mantissa = frexp(x, &exp);
 
        i = 0;
        /* Représentation du signe */
        if (mantissa < 0)
        {
            mantissa = -mantissa;
            s_buffer[i++] = '1';
        }
        else
        {
            s_buffer[i++] = '0';
        }
 
        /* Représentation de la mantisse */
        mantissa *= 2, exp--;
        mantissa -= floor(mantissa);
 
        while (precision > 0)
        {
            mantissa *= 2;
            s_buffer[i++] = ((int) mantissa) ? '1':'0';
            mantissa -= floor(mantissa);
            precision--;
        }
 
        int_to_binary_repr(s_buffer + i, buffsize - i, exp + 1023);
    }
    else
    {
        /* Erreur: la taille du tampon est insuffisante (< double_bit + 1) */
        err = -1;
    }
    return err;
}

qui affiche:

Code :

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

1
2
La représentation IEEE 754 de 1.0/3.0 est:
001010101010101010101010101010101010101010101010101011111111101

Thierry

[Médinoc]

Je ne lis que 63 bits dans ton nombre, est-ce normal ?

Code :

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

1
2
3
4
001010101010101010101010101010101010101010101010101011111111101
 
123456789012345678901234567890123456789012345678901234567890123
000000000111111111122222222223333333333444444444455555555556666

[Thierry Chappuis]

Je ne lis que 63 bits dans ton nombre, est-ce normal ?

Code :

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

1
2
3
4
001010101010101010101010101010101010101010101010101011111111101
 
123456789012345678901234567890123456789012345678901234567890123
000000000111111111122222222223333333333444444444455555555556666

Bug! Il ne représente l'exposant que sur 10 bits, lorsqu'il n'a pas besoin de 11. Je fixe au plus vite...

EDIT: Little update

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
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <ctype.h>
 
/**
 * Fournit la représentation binaire d'un entier non signé de type int unsigned
 * int.
 *
 * @param s_buffer tampon dans lequelle est placé la représentation binaire
 *                 sous la forme d'une chaîne de caractères.
 * @param buffsize taille du tampon
 * @param number entier non signé à représenter sous forme binaire
 * @param nbits nombre de bits utilisés par la représentation. Si nbits est
 *              inférieur au nombre de bits nécessaires, le nombre minimal de
 *              bits nécessaires est utilisé. nbits est majoré par le nombre de
 *              bits utilisés pour représenter un entier de type int.
 *
 * @return code d'erreur valant -1 si la taille du tampon fourni est
 *         insuffisante, et la longueur de la chaîne écrite dans s_buffer sinon.
 */
int uint_to_binary_repr(char *s_buffer, size_t buffsize, unsigned int number, size_t nbits)
{
    int ret = 0;
    size_t i;
 
 
    unsigned int n = number;
    const size_t MAX_BITS = sizeof number * CHAR_BIT;
    size_t MIN_BITS = 0;
 
    /* Calcul du nombre minimal de bits nécessaires pour représenter
       l'entier considéré */
 
    do
    {
        n /= 2;
        MIN_BITS++;
    }
    while (n > 0u);
 
 
    nbits = (nbits > MAX_BITS) ? MAX_BITS :
            (nbits < MIN_BITS) ? MIN_BITS : nbits;
 
    if (buffsize > nbits)
    {
 
        s_buffer[nbits] = 0;
 
        for (i = 0; i < nbits; ++i)
        {
            s_buffer[nbits-(i+1)] = (number & (1 << i)) ? '1' : '0';
        }
 
        ret = nbits;
    }
    else
    {
        ret = -1;
    }
    return ret;
}
 
/**
 * Converti la représentation binaire d'un nombre en un nombre non-signé de
 * type unsigned int. La fonction analyse au plus sizeof(unsigned int) * CHAR_BIT
 * bits à partir du bit de poids fort (MSB). Les espaces (caractères
 * reconnus comme tels par isspace()) de tête sont ignorés, et la lecture
 * s'arrête à la rencontre du 1er caractère invalide.
 *
 * @param s_buffer tampon dans lequelle se trouve la représentation binaire à
 *                 convertir en unsigned int
 * @param endptr si endptr n'est pas NULL, l'adresse du 1er caractère invalide
 *               est placée dans *endptr. Si aucun catactère n'est valide,
 *               l'adresse de s_buffer est placée dans *endptr.
 *
 * @return entier non-signé correspondant à la représentation bianire fournie.
 *         Si la valeur 0 est retournée alors que *endptr pointe sur s_buffer,
 *         aucun caractère n'a été lu.
 */
unsigned int binary_repr_to_uint(char const *s_buffer, char const **endptr)
{
    unsigned int number = 0;
    char const *pc;
    size_t nbits = 0;
 
    if (s_buffer != NULL)
    {
        /* On ignore les espaces de tête */
        for (pc = s_buffer; isspace(*pc); pc++)
        {
            continue;
        }
        while (nbits < sizeof number * CHAR_BIT && (*pc == '1' || *pc == '0'))
        {
            number = number * 2 + (*pc - '0');
 
            nbits++;
            pc++;
        }
 
        if (endptr != NULL)
        {
            *endptr = (nbits >= 1u) ? pc : s_buffer;
        }
    }
 
    return number;
}
 
/**
 * Fournit la représentation binaire d'un entier de type int.
 *
 * @param s_buffer tampon dans lequelle est placé la représentation binaire
 *                 sous la forme d'une chaîne de caractères.
 * @param buffsize taille du tampon
 * @param number entier à représenter sous forme binaire
 * @param nbits nombre de bits utilisés par la représentation. Si nbits est
 *              inférieur au nombre de bits nécessaires, le nombre minimal de
 *              bits nécessaires est utilisé. nbits est majoré par le nombre de
 *              bits utilisés pour représenter un entier de type int.
 *
 * @return code d'erreur valant -1 si la taille du tampon fourni est
 *         insuffisante, et la longueur de la chaîne écrite dans s_buffer sinon.
 */
int int_to_binary_repr(char *s_buffer, size_t buffsize, int number, size_t nbits)
{
    int ret = 0;
    size_t i;
 
 
    int n = number;
    const size_t MAX_BITS = sizeof(int) * CHAR_BIT;
    size_t MIN_BITS = 0;
 
    /* Calcul du nombre minimal de bits nécessaires pour représenter
       l'entier considéré */
    if (n >= 0)
    {
        do
        {
            n /= 2;
            MIN_BITS++;
        }
        while (n > 0);
    }
    else
    {
        MIN_BITS = MAX_BITS;
    }
 
    nbits = (nbits > MAX_BITS) ? MAX_BITS :
            (nbits < MIN_BITS) ? MIN_BITS : nbits;
 
    if (buffsize > nbits)
    {
 
        s_buffer[nbits] = 0;
 
        for (i = 0; i < nbits; ++i)
        {
            s_buffer[nbits-(i+1)] = (number & (1 << i)) ? '1' : '0';
        }
        ret = nbits;
    }
    else
    {
        ret = -1;
    }
    return ret;
}
 
 
/**
 * Fournit la représentation binaire d'un nombre flottant de type double comme
 * décrit dans la norme IEEE 754.
 *
 * @param s_buffer tampon dans lequelle est placé la représentation binaire
 *                 sous la forme d'une chaîne de caractères.
 * @param buffsize taille du tampon
 * @param x nombre flottant à représenter sous forme binaire
 * @param prec précision utilisée pour représenter la mantisse (max = 52). Si
 *             vaut -1, la précision est maximale.
 *
 * @return code d'erreur valant -1 si la taille du tampon fournit est
 *         inférieure à (prec + 16), et 0 sinon
 */
int double_to_binary_repr(char *s_buffer, size_t buffsize, double x, int prec)
{
    int err = 0;
 
    /* La mantisse est au maximum représentée sur 52 bits */
    int mantissa_size = (prec < 0 || prec > 52) ? 52 : prec;
 
    if (buffsize >= mantissa_size + 16u) /* mantissa + exp + sign + 4 */
    {
        size_t i;
        int exp;
        double mantissa;
 
        /* On initialise le tampon */
        for (i = 0; i < buffsize; ++i)
        {
            s_buffer[i] = 0;
        }
        /* On récupère la valeur de la mantisse et de l'exposant */
        mantissa = frexp(x, &exp);
 
        i = 0;
        /* Représentation du signe */
        if (mantissa < 0)
        {
            mantissa = -mantissa;
            s_buffer[i++] = '-';
        }
        else
        {
            s_buffer[i++] = '+';
        }
 
        /* Représentation de la mantisse */
        mantissa *= 2, exp--;
 
        s_buffer[i++] = ((int) mantissa) ? '1':'0';
        mantissa -= floor(mantissa);
        s_buffer[i++] = '.';
 
        while (mantissa_size > 0 && mantissa != floor(mantissa))
        {
            mantissa *= 2;
            s_buffer[i++] = ((int) mantissa) ? '1':'0';
            mantissa -= floor(mantissa);
            mantissa_size--;
        }
 
        /* Représentation de l'exposant (nombre minimal de bits */
        s_buffer[i++] = 'e';
        int_to_binary_repr(s_buffer + i, buffsize - i, exp + 1023, 0);
    }
    else
    {
        /* Erreur: la taille du tampon est insuffisante (< prec + 16) */
        err = -1;
    }
    return err;
}
 
/**
 * Fournit la représentation IEEE 754 stricte double précision d'un nombre
 * flottant de type double.
 *
 * @param s_buffer tampon dans lequelle est placé la représentation binaire
 *                 sous la forme d'une chaîne de caractères.
 * @param buffsize taille du tampon
 * @param x nombre flottant à représenter sous forme binaire IEEE 754
 *
 * @return code d'erreur valant -1 si la taille du tampon fournit est
 *         inférieure ou égale au nombre de bits nécessaires pour représenter
 *         un nombre flottant de type double, et 0 sinon
 */
int double_to_ieee754_repr(char *s_buffer, size_t buffsize, double x)
{
    int err = 0;
 
    const size_t DOUBLE_BIT = sizeof(double) * CHAR_BIT;
    int mantissa_size = 52;
 
    if (buffsize >= DOUBLE_BIT + 1)
    {
        size_t i;
        int exp;
        double mantissa;
 
        /* On initialise le tampon */
        for (i = 0; i < buffsize; ++i)
        {
            s_buffer[i] = 0;
        }
        /* On récupère la valeur de la mantisse et de l'exposant */
        mantissa = frexp(x, &exp);
 
        i = 0;
        /* Représentation du signe */
        if (mantissa < 0)
        {
            mantissa = -mantissa;
            s_buffer[i++] = '1';
        }
        else
        {
            s_buffer[i++] = '0';
        }
 
        /* Représentation de la mantisse */
        mantissa *= 2, exp--;
        mantissa -= floor(mantissa);
 
        /* Représentation de l'exposant sur 11 bits */
        int_to_binary_repr(s_buffer + i, buffsize - i, exp + 1023, 11);
        i += 11;
 
        while (mantissa_size > 0)
        {
            mantissa *= 2;
            s_buffer[i++] = ((int) mantissa) ? '1':'0';
            mantissa -= floor(mantissa);
            mantissa_size--;
        }
        s_buffer[i] = '\0';
    }
    else
    {
        /* Erreur: la taille du tampon est insuffisante (< DOUBLE_BIT + 1) */
        err = -1;
    }
    return err;
}

Maintenant, j'obtiens bien une représentation sur 64 bits:

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
 
int main(void)
{
    char s_buffer[68] = {0};
 
    double_to_ieee754_repr(s_buffer, sizeof s_buffer, 1.0/3.0);
    printf("La représentation IEEE 754 de 1.0/3.0 est:\n");
    printf("%s\n", s_buffer);
    printf("La taille de la représentation est de %u bits\n", strlen(s_buffer));
 
    printf("----------------------------------------------------------\n");
 
    double_to_binary_repr(s_buffer, sizeof s_buffer, 1.0/3.0, 10);
    printf("La représentation binaire de 1.0/3.0 avec 10 bits de mantisse est:\n");
    printf("%s\n", s_buffer);
 
    return 0;
}

qui donne

Code :

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

1
2
3
4
5
6
La représentation IEEE 754 de 1.0/3.0 est:
0011111111010101010101010101010101010101010101010101010101010101
La taille de la représentation est de 64 bits
----------------------------------------------------------
La représentation binaire de 1.0/3.0 avec 10 bits de mantisse est:
+1.0101010101e1111111101

Thierry