Conversion double binaire vers décimal

**mess-mate** · 05/12/2008, 20h38

Bonjour,
j'ai dû faire une faute de codage.
Le but de l'opération étant de convertir un double binaire vers du décimal.
Le nombre décimal est 0.02.
Voici mon code:

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
int main()
{
//char base_bin[64];
char base_bin[]="0111101100010100101011100100011111100001011110101001010000111111";
int pos=strlen((const char*)base_bin)-1;
int pos2=pos+1;
double d1=0;
double d2=0;
int x=0;
int y=12;
char i='1';
 
 
cout << "strlen of pos =" <<pos+1 <<endl;
//cout << "pos start at end of string = " << pos << endl;
cout << "Calculation start at pos : " << y << endl;
 
while ( pos2 > y )
    {
    unsigned char ch = base_bin[y];
    if ( ch == i) {
 
       d1=pow(2,x);
       cout << "bit = " << ch << " at pos = " << y << endl;
       d2=d2+d1;
       cout << "Value at this pos = " << d1 << "and d2 = " << d2 << endl;
    }
        x++;
        y++;
    }
//printf ( "Double d2 final = %.8f\n",d2);
printf ( "Double d2 final = %.2f\n",d2);
cout<<"final d2 = "<<d2<<endl;
return 0;
}

J'ai tenu compte avec le bit de signe et l'exposant. La mantisse devrait donc être 2 et l'exposant e^-2, si j'ai juste

Ce code ne calcule que la mantisse pour commencer.
Et j'arrive pas à trouver ce fameux '.' qui devrait se trouver en dernière position de la mantisse ?

**mayayu** · 05/12/2008, 23h40

Bonsoir,

Je pense que le plus simple est d'utiliser une boucle "for" plutôt que "while", ça évite de rajouter "manuellement" les incrémentations à chaque boucle.
La variable "i" est inutile puisqu'elle contient une constante utilisée une seule fois.
De même d1 n'est pas nécessaire puisqu'on peut utiliser "+=" au lieu de rajouter la puissance en 2 temps.

Voilà pour la transformation pur et dur du binaire vers du décimal, pour la mantisse et autre je te laisse te débrouiller :

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
 
int main()
{
	char base_bin[]="0111101100010100101011100100011111100001011110101001010000111111";
	double d2=0;
	int size = (int)strlen((const char*)base_bin);
 
	for(int pos=size; pos>0; pos--)
	{
		if(base_bin[pos-1] == '1')
			d2+=pow(2,size-pos);
	}
 
	std::cout<<"final d2 = "<<d2<< std::endl;
	return 0;
}

**mess-mate** · 05/12/2008, 23h53

Après réflexion, il faut pas de point dans ce cas puisqu'il y a pas d'unité.

Je vais rectifier un peu le codage comme suggéré, merci.

**Obsidian** · 06/12/2008, 00h44

Pour moi, le code en binaire qui se trouve dans base_bin est erroné (s'il s'agit bien d'un double au format IEEE 754). Sinon, je te propose ceci :

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 <iostream>
 
using namespace std;
 
int main (void)
{
    unsigned long int       x;
//  char                    base_bin[]  = "0111101100010100101011100100011111100001011110101001010000111111";
    char                    base_bin[]  = "0011111110010100011110101110000101000111101011100001010001111011";
    unsigned long long int  d = 0;
 
    for (x=0;x<sizeof(base_bin)-1;++x) { d<<=1; d|=base_bin[x]&1; }
    cout << *(double *)&d << endl;
 
    return 0;
}

**mess-mate** · 06/12/2008, 07h52

Uhh.. ce code binaire (décodage little endian) sur 64 bits vient tout droit d'un fichier dans la ram.

Le khexedit en binaire pointé sur le premier bit donne bien en 64bits 2.000000E-02.
Les bits sont représentés comme dans le décodage de khexedit de gauche à droite.
La proposition avec mon codage et binaire proposé ne marche pas non plus.
Le codage proposé avec le binaire proposé donne un faux résultat.
J'arrive pas à trouver où ça coince.

Il me reste plus qu'une possibilité je pense, c'est de douter de khexedit qui m'a renvoyé le nombre binaire hors normes.

**mayayu** · 06/12/2008, 10h48

Voilà le décodage IEEE 754 64 bits (comme le propose Obsidian) de ta chaîne (sans les exceptions) :

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
 
#include <iostream>
#include <math.h>
 
#define TAILLE_SIGNE	1
#define TAILLE_EXPOSANT	11
#define TAILLE_MANTISSE	52
 
unsigned long long ullExtractNumber(char* szNumber)
{
	unsigned long long ullResult = 0;
	int iSize = (int)strlen(szNumber);
 
	for(int iPos = iSize; iPos > 0; iPos--)
	{
		if(szNumber[iPos-1] == '1')
			ullResult += (int)pow(2, iSize-iPos);
	}
 
	return ullResult;
}
 
int main()
{
	char szBaseBin[]="0111101100010100101011100100011111100001011110101001010000111111";	
	if(strlen(szBaseBin) != (TAILLE_SIGNE+TAILLE_EXPOSANT+TAILLE_MANTISSE)) return 1;
 
	char szSigne[TAILLE_SIGNE+1];
	char szExposant[TAILLE_EXPOSANT+1];
	char szMantisse[TAILLE_MANTISSE+1];
	strncpy(szSigne,	szBaseBin,					TAILLE_SIGNE);
	szSigne[TAILLE_SIGNE] = 0;
	strncpy(szExposant,	szBaseBin+TAILLE_SIGNE,		TAILLE_EXPOSANT);
	szExposant[TAILLE_EXPOSANT] = 0;
	strncpy(szMantisse,	szBaseBin+TAILLE_EXPOSANT,	TAILLE_MANTISSE);
	szMantisse[TAILLE_MANTISSE] = 0;
 
	unsigned long long ullSigne		= ullExtractNumber(szSigne);
	unsigned long long ullExposant	= ullExtractNumber(szExposant);
	unsigned long long ullMantisse	= ullExtractNumber(szMantisse);
 
	std::cout << "Signe = " << ullSigne << std::endl;
	std::cout << "Exposant = " << ullExposant << std::endl;
	std::cout << "Mantisse = " << ullMantisse << std::endl;
 
	double dResult = pow(-1, (int)ullSigne) * ullMantisse * powl(2, (int)(ullExposant-1023));
 
	std::cout << "Result = " << dResult << std::endl;
	return 0;
}

Le résultat donne 1.09722e+304 ce qui est à l'opposé du résultat attendu.
Soit le codage n'est pas le bon, soit le résultat n'est pas codé sur les 64 bits, mais peut-être sur 8 ou autre...

**mess-mate** · 06/12/2008, 11h32

En effet, le résultat n'est pas bon. Par contre ton code c++ je savais pas.

Si je converse le codage en HEX vers le décimal, le résultat est bien exact.
7E14AE47E17A943F --> 0.02
Ce même hex en binaire est bien celui que j'utilise et est le même utilisé dans ton code.
Selon mes tests avec khexedit, c'est bel et bien du 64bits.
J'ai aussi testé avec d'autres éditeurs hex/binaire, tous affichent le même code binaire.

Je me casse la tête depuis quelques jours afin de savoir ce qui cloche.

Il doit s'agir d'un mauvais codage c++, je vois pas d'autre solution.

**mayayu** · 06/12/2008, 11h48

Il est également possible que le chiffre soit tellement important qu'il y est des des retenues du calcul qui soient tronqués... soit dans nos codes ou pourquoi pas dans les logiciels que tu as testé.
Un autre problème est le choix du type (int ou long) et du signe (unsigned ou pas) dans la déclaration des variables intermédiaires.
Il y a aussi la "pow", c'est pas dit qu'elle sache travailler avec des grands nombres.

**mayayu** · 06/12/2008, 11h57

Encore plus troublant, en partant du code héxadécimal en faisant faire le travail par mon PC avec le code suivant, j'arrive à un résultat différent :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <iostream>
#include <math.h>
 
int main()
{
	long long llTest = 0x7E14AE47E17A943F;
	double* pdTest;
 
	pdTest = (double*) &llTest;
 
	std::cout << *pdTest << std::endl;
}

Résultat = 2.16403e+299

**mayayu** · 06/12/2008, 12h17

Et si on part de 0.02, je ne retrouve pas non plus le même code héxadécimal :

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
 
#include <iostream>
#include <math.h>
 
int main()
{
	double dTemp = 0.02;
	long long* pllTest;
	int iTest1, iTest2, iTest3, iTest4;
 
	pllTest = (long long*) &dTemp;
	iTest1 = (*pllTest & 0xFFFF000000000000) >> 48;
	iTest2 = (*pllTest & 0x0000FFFF00000000) >> 32;
	iTest3 = (*pllTest & 0x00000000FFFF0000) >> 16;
	iTest4 = *pllTest & 0x000000000000FFFF;
 
	printf("%x%x%x%x\n", iTest1, iTest2, iTest3, iTest4);
}

Résultat = 0x3f947ae147ae147b

**mess-mate** · 06/12/2008, 14h21

Essaye un peu avec ceci pour voire:

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
#include <math.h>
#include <string.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
 
using namespace std;
 
int main (void)
{
    double          db=0;
    char            c;
    int             x;
    unsigned char   nombre[sizeof(double)];
    string          s("7B14AE47E17A943F");
 
    for (x=0;x<(sizeof(double)*2);++x)
    {
        c = s[x];
 
        if      (c>='0' && c<='9')  c -=  '0'      ;
        else if (c>='A' && c<='F')  c -= ('A' - 10);
        else if (c>='a' && c<='f')  c -= ('a' - 10);
        else break;
 
        if (x & 1)  nombre [x >> 1] += (unsigned char)c;
        else        nombre [x >> 1]  = (unsigned char)c << 4;
    }
    db = *(double *)nombre;
    cout << "Results : " << db << endl;
 
    return 0;
}

le hexadécimal est dans le string.

**mayayu** · 06/12/2008, 15h20

L'essentiel c'est que tu aies trouvé mais je ne comprends pas trop la logique.
C'est quel type d'encodage?

**mess-mate** · 06/12/2008, 16h12

Non, non... j'ai pas trouvé du tout.
Dans le message précédent je démontre tout simplement que la conversion du nombre 0.02 à partir du hexadécimal vers le décimal fonctionne parfaitement.

C'est le même nombre (0.02) mais en binaire dont la conversion ne marche pas vers le décimal.

**mayayu** · 06/12/2008, 17h17

Ça n'est pas très propre mais pourquoi tu ne convertis par ta chaîne binaire en héxadécimal.

Ca donne :

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
 
#include <math.h>
#include <string.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
 
using namespace std;
 
string HexToBin(string s)
{
	string r = "";
 
	for(int i=0; i<s.size(); i=i+4)
	{
		if		(!s.substr(i, 4).compare("0000")) r += "0";
		else if	(!s.substr(i, 4).compare("0001")) r += "1";
		else if	(!s.substr(i, 4).compare("0010")) r += "2";
		else if	(!s.substr(i, 4).compare("0011")) r += "3";
		else if	(!s.substr(i, 4).compare("0100")) r += "4";
		else if	(!s.substr(i, 4).compare("0101")) r += "5";
		else if	(!s.substr(i, 4).compare("0110")) r += "6";
		else if	(!s.substr(i, 4).compare("0111")) r += "7";
		else if	(!s.substr(i, 4).compare("1000")) r += "8";
		else if	(!s.substr(i, 4).compare("1001")) r += "9";
		else if	(!s.substr(i, 4).compare("1010")) r += "A";
		else if	(!s.substr(i, 4).compare("1011")) r += "B";
		else if	(!s.substr(i, 4).compare("1100")) r += "C";
		else if	(!s.substr(i, 4).compare("1101")) r += "D";
		else if	(!s.substr(i, 4).compare("1110")) r += "E";
		else if	(!s.substr(i, 4).compare("1111")) r += "F";
	}
 
	return r;
}
 
int main (void)
{
    double          db=0;
    char            c;
    int             x;
    unsigned char   nombre[sizeof(double)];
//    string          s("7E14AE47E17A943F");
    string          s;
	s = HexToBin("0111101100010100101011100100011111100001011110101001010000111111");
 
    for (x=0;x<(sizeof(double)*2);++x)
    {
        c = s[x];
 
        if      (c>='0' && c<='9')  c -=  '0'      ;
        else if (c>='A' && c<='F')  c -= ('A' - 10);
        else if (c>='a' && c<='f')  c -= ('a' - 10);
        else break;
 
        if (x & 1)  nombre [x >> 1] += (unsigned char)c;
        else        nombre [x >> 1]  = (unsigned char)c << 4;
    }
    db = *(double *)nombre;
    cout << "Results : " << db << endl;
 
    return 0;
}

Mais bon il ne doit pas être si dur de transformer ton algorithme en hexadécimal pour que ça marche en binaire.

**nicroman** · 06/12/2008, 18h12

Envoyé par mess-mate

Uhh.. ce code binaire (décodage little endian) sur 64 bits vient tout droit d'un fichier dans la ram.

Le khexedit en binaire pointé sur le premier bit donne bien en 64bits 2.000000E-02.
Les bits sont représentés comme dans le décodage de khexedit de gauche à droite.

Oui mais:
"0111101100010100101011100100011111100001011110101001010000111111"
vient d'ou ?
D'autre part, il ne correspond pas à 0x7E14AE47E17A943F mais à 0x7B14AE47E17A943F

1 bit de signe: 0 (+)
11 bits d'exposants: 0x7B1 soit 1969 donc: 2^946 => C'est pas bon pour avoir 0,02 !!

Maintenant, si c'est une copie des octets à la suite :
"01111011" "00010100" "10101110" "01000111" "11100001" "01111010" "10010100" "00111111" ?

Alors le nombre binaire n'est pas celui au dessus... mais (en little-endian):
0011111110010100011110101110000101000111101011100001010001111011
soit: 0x3F947AE147AE147B

1 bit de signe: 0 (+)
11 bits d'exposant: 0x3F9 soit 2^-6 (déjà bien plus plausible)
52 bits de mantisse: 1.(fraction) 0x47AE147AE147B soit... 2^-1 + 2^-2 + 2^-4+2^-5...

**mayayu** · 06/12/2008, 18h48

Et oui il suffisait de réorganiser les octets comme le propose nicroman. Je m'en suis rendu compte en reprenant ton algorithme pour faire la conversion directement en binaire.

Ça donne :

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
 
int main (void)
{
    double          db=0;
    char            c;
    int             x, y;
    unsigned char   nombre[sizeof(double)];
    string          s("0111101100010100101011100100011111100001011110101001010000111111");
 
	for(x=0; x<(s.size()/8); x++)
	{
		nombre[x] = 0;
		for(y=0; y<8; y++)
		{
			if(s[x*8+y]=='1')
				nombre[x] |= 1 << (8-y-1);
		}
	}
 
    db = *(double *)nombre;
    cout << "Results : " << db << endl;
 
    return 0;
}

**mess-mate** · 06/12/2008, 23h46

J'y suis arrivé... avec l'appui de nicroman et emiaille.
Merci à tout les deux.

Le code de emiaille est vraiment très fort; direct en décimal !!

J'étais cependant partis pour un détour via hex; donc bin->hex->dec.

Etant donné que j'ai fait le hex, le voici aussi ( pourrait être amélioré bien-sûr, j'aime pas trop les casts non plus)

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
int main (void)
{
//char ref[]="7B14AE47E17A943F";
char base_bin[]="0111101100010100101011100100011111100001011110101001010000111111"; // ram
char hex[]="\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,";
int x=0;
int y=0;
int z=1;
int pos=3;
int i;
unsigned int d1=0;
char c;
 
while ( pos < 64) {
    for (i=pos; i > pos-4; i--)
        {
        if ( base_bin[i] == '1' ) {
        d1=d1+(unsigned int)pow(2,y);
            }
        y++;
        if ( y > 3 ) {
            y=0;
            if (d1>=0 && d1<=9)  c = (char)(d1+48);
            else if (d1>=10 && d1<=15) c = (char)(d1+55);
            hex[z-1]=c;
            z++;
            y=0;
            x++;
            d1 = 0;
            }
        }
    pos=pos+4;
}
cout << "Hex string = " << hex << endl;
return 0;
}