Conversion double binaire vers décimal

Version imprimable

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:

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 ?

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:

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; }

05/12/2008, 23h53
mess-mate

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.

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:

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;
}

06/12/2008, 07h52
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.
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.

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

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
 
#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...

06/12/2008, 11h32
mess-mate

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.
06/12/2008, 11h48
mayayu

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.

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:

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

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

Code:

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

Essaye un peu avec ceci pour voire:

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
#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.

06/12/2008, 15h20
mayayu

L'essentiel c'est que tu aies trouvé mais je ne comprends pas trop la logique.
C'est quel type d'encodage?
06/12/2008, 16h12
mess-mate

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.

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

Ca donne :

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
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.

06/12/2008, 18h12
nicroman

Citation:

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...

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:

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;
}

:yaisse2:

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:

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; }
Je savais qu'il fallait décoder à l'envers, mais pas qu'il fallait le faire par 4 bits :?

Pour répondre à nicroman: le 7E était une faute de frappe, il fallait bien du 7B. Ce code binaire vient de la ram.

Encore merci pour l'aide.

07/12/2008, 00h44
mess-mate

1 pièce(s) jointe(s)

Citation:

Envoyé par nicroman

Oui mais:
"0111101100010100101011100100011111100001011110101001010000111111"
vient d'ou ?

Voici d'où ça vient. A compter à partir du point rouge.