Conversion nombre à virgule binaire en decimal

Version imprimable

28/05/2019, 12h33
boboss123

Conversion nombre à virgule binaire en decimal

Bonjour,

Je suis en train de faire une fonction pour convertir un nombre à virgule codé en IEEE754 en ASCII (format decimal).
Actuellement, j'ai réussi à récupérer la partie "entière" et la partie "après la virgule" dans deux variables non signées de 32 bits séparée (le signe étant stocké dans une variable séparée).

Exemple : Val = 0x1234ACBD.EF123456 => partie_entiere = 0x1234ACBD et partie_virgule = 0xEF123456

Pour afficher la partie entière, je n'ai pas de probleme, j'ai créé une fonction de conversion "nombre entier vers ASCII decimal"
=> le problème est que je ne peux pas utiliser tel quel ma fonction de conversion pour afficher la partie à virgule car partie_virgule correspond à la partie après la virgule en base 2 et non en base 10 : comment faire ?
=> je voudrais pouvoir choisir le nombre de chiffres à afficher après la virgule.

Merci d'avance
28/05/2019, 16h11
Flodelarab

Bonjour :coucou:

Citation:

je voudrais pouvoir choisir le nombre de chiffres à afficher après la virgule.

Ce n'est pas tellement que tu veux. Mais tu dois. Tu dois choisir le nombre de chiffres après la virgule car il n'y a pas de correspondance direct.

Je prends un exemple :
1/3 en base 3 s'écrit "0.1"
1/3 en base 10 s'écrit "0.33333333333333333333333333..." 3 à l'infini.
Tu vois par là que tu pourrais écrire des 3 en mémoire jusqu'à la fin des temps.

De la même façon qu'il y a un dépassement de capacité vers le maximum, il y a un dépassement de capacité dans la précision de la mantisse.
Donc tu dois y mettre fin en choisissant le nombre de chiffres de la mantisse.

Comme tu suis une norme IEEE754, retourne voir la description de la norme pour savoir quelle précision est acceptable.

Bonne chance :ccool:

Merci pour la réponse

Je cherche à décoder un nombre codé sur 32 bits (23bits de mantisse et 8 bit d'exposant).

10 chiffres après la virgule serait suffisant.

Je suis parti sur une autre solution : plutôt que de séparer la partie decimale de la partie entière je code tout dans un entier non signé 64 bits (32 premiers bits correspondant à la partie decimale).

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
 
    // *****************************    
    int max_digit_count = 20;
    int digit_count = 0;
 
    int decimal_count = 0;
    uint64_t diviseur = 1000000000; // 10 digits pour la partie entière
    uint64_t diviseur <<= 32; // decalage pour alignement (32 premiers bits correspondent à la partie decimale)
 
    int writeFirstDigit = 0;
    while(digit_count < (max_digit_count-1)){
 
        if(decimal_count){
            decimal_count++;    
        }
 
        uint64_t valTmp = val64b / diviseur;
 
        if(digit_count == 10){
            if(writeFirstDigit == 0){
                *out++ = '0'; 
                writeFirstDigit = 1;
            }
            *out++ = '.';
            decimal_count = 1;
        }
 
        if(valTmp != 0){
            *out++ = valTmp + '0';
 
            //val64b -= diviseur * valTmp;
            val64b = val64b % diviseur;
            writeFirstDigit = 1;
 
        } else {
            if(writeFirstDigit){
                *out++ = '0';
            }
        }
 
        if(diviseur){
            diviseur /= 10;
        }
 
        if(decimal_count >= afterpoint){
            break;
        }
 
        digit_count++;
    }

Mais je ne vois pas comment gérer les arrondis (afterpoint défini le nombre de digit à afficher après la virgule)

02/06/2019, 10h47
valentin03

L'arrondissage, arrondissement, arronditiature
<5=0; >=5=10. Tu peux aussi couper en trois: <2=0; >=3=5; 5=5; <8=5; >=8=10