disfonctionnement floor avec double

Version imprimable

Bonjour,
je voudrais créer un constructeur de fraction à partir d'un double.
Voici le code en question :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ZFraction::ZFraction(double decimal) { int compteur(0); while(floor(decimal)!=decimal) { decimal*=10.0; compteur++; } m_numerateur=decimal; m_denominateur=pow(10.0,compteur); simplifier(); }
Quand je teste avec un double valant 0.401, la valeur de floor(decimal) vaut 400 au lieu de 401 quand j'arrive au troisième tour de boucle, ce qui est surprenant.
Merci pour vos réponses.

19/05/2019, 18h20
wolinn

Bonjour
0.401 n'a pas de représentation exacte en type 'double' (=IEEE-754 64 bits).
Affiche les résultats successifs avec 17 chiffres de précision, et tu verras qu'à la troisième itération, decimal=400.99999...., produisant 400 par floor().
C'est un problème de représentation des nombres et d'algorithme, la fonction floor() fonctionne correctement.
19/05/2019, 20h34
sgu35

Mais comment palier à ce problème?
Peut-être en convertissant le double en string, et en calculant le nombre de chiffres après la virgule?
19/05/2019, 22h28
droggo

Bonjour,

Citation:

Envoyé par sgu35

Mais comment palier à ce problème?
Peut-être en convertissant le double en string, et en calculant le nombre de chiffres après la virgule?

Tu ne peux pas éviter ce problème, dû à la représentation des flottants.

Tu peux le réduire quand même en utilisant une bibliothèque muli-précision,
la plus connue est GMP, je te laisse chercher, c'est facile à trouver.

MAIS, ce n'est pas la panacée, ça ne fait que reculer le problème,
tout en augmentant notablement le temps de calcul. :(
20/05/2019, 07h53
wolinn

sgu35 :
Tu peux en effet passer par des conversions en chaines de caractères, en contrôlant bien la précision, et laisser à la conversion standard le soin de gérer les arrondis.
Mais ce n'est pas très élégant, surtout si le nombre provient à l'origine d'une saisie par l'utilisateur (conversion chaine -> double, et ensuite reconversion en chaine...).
On peut aussi gérer explicitement les arrondis 'au plus proche', après avoir fixé une précison a priori, c'est souvent la méthode retenue : floor(400.999...) = 400, mais floor(400.999.... +0.5) = 401

Mais le plus propre est de reconnaitre que 0.401 (par exemple) n'existe pas en double/IEEE-754, tout comme d'ailleurs la plupart des nombres non entiers que pourrait saisir un utilisateur, et manipuler directement la bonne représentation, c'est à dire en général une suite de chiffres décimaux dans une chaine de caractères.
Ton constructeur devrait accepter et traiter une chaine.
En entrée : chaine = aaaaa.ddddd
Fractionner la chaine et convertir en deux entier n1=(aaaaa) et n2=(ddddd)
Ensuite, traiter ces deux entiers, sans utiliser le type 'double'.
Il faut bien sûr faire attention aux dépassements de capacité, traiter correctement les nombres négatifs si applicable, etc.
On peut également définir une classe pour traiter directement les nombres en virgule flottante en représentation décimale, ça existe déjà certainement si tu ne veux pas le faire toi-même.

Voir aussi les caractéristiques des différents types numériques, pour faire attention à la portabilité :
http://www.cplusplus.com/reference/l...umeric_limits/

Complément : vérifie quand même si ton compilateur favori implémente la nouvelle version de la norme IEEE-754 (2008), qui inclut les nombres décimaux. Ca parait être le cas en gcc, comme extension non standardisée (mais peut-être pas en C++).
26/05/2019, 21h21
sgu35

Bonjour,
j'ai utilisé des strings pour récupérer la partie décimale et la partie entière. Avec cela, le numérateur est correct, mais le dénominateur pose problème. En effet si on teste avec 0.32 ou 0.56, 10 à la puissance 2 retourne 99...

Après quelques essais, j'ai trouvé que si je mettais 10.0000001 à la puissance n, pow retourne 100 pour ces double.
J'ai aussi essayé de tester avec des double avec beaucoup de chiffres après la virgule mais il me met au maximum 6 chiffres après la virgule, peut-être est-ce qu'on atteint la limite de précision du langage c++.
27/05/2019, 08h16
wolinn

Bonjour

Tu ne t'en sortiras pas comme ça sans comprendre les propriétés des nombres définis en virgule flottante. Et le nombre de chiffres affichés se règle avec std::setprecision (si on utilise les flux), ou des formats % (avec les formats C).

Tout d'abord, il faudrait savoir d'où provient le nombre passé en paramètre au constructeur de ta classe, la démarche n'est pas la même suivant qu'il s'agit d'une saisie utilisateur ou d'un résultat de calcul.
Mais j'ai l'impression que tu testes avec des saisies utilisateur. Donc partons de ce principe.
Dans ce cas, pour ce que tu veux faire, il ne faut pas utiliser le type 'double'.

1ère étape : le nombre est saisi en tant que chaine de caractère
std::string x;
std::cout << "x = ";
std::cin >> x;

Cela assure qu'il n'y a aucune erreur d'arrondi caché, x contiendra "0.32", et non pas 0.3199999999.... si x était un 'double'.

2ème étape : cette chaine est transmise au constructeur de ta classe
La partie décimale contient 2 caractères => dénominateur = 100 (et il ne faut évidemment pas utiliser la fonction "pow" standard pour déduire cela, cette fonction travaille sur des flottants).
Uniquement par du traitement de chaine de caractère, en repérant le ".", cette chaine est fractionnée en deux entiers : n=0 et dec=32
La fraction est (n*denominateur + dec, denominateur)

Avec cette procédure, qui utilise uniquement des entiers et du traitement de chaines, il n'y a aucun problème d'arrondi, il faut juste tester correctement la validité de la chaine et faire attention aux limites des entiers fixes standards (ou utiliser des entiers de longueur arbitraire comme on en trouve dans une bibliothèque comme gmp).
27/05/2019, 09h37
Bktero

Si tu veux te faire du mal et du bien à la fois, tu peux lire (au moins le début de) cet article : https://www.itu.dk/~sestoft/bachelor...54_article.pdf

Wikipedia est déjà aussi une bonne lecture pour comprendre ce qu'implique la représentation floating point : https://en.wikipedia.org/wiki/Floating-point_arithmetic

J'ai utilisé les string pour résoudre ce problème, voici le code final :

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
ZFraction::ZFraction(double decimal)
{
 
    string chaineDecimal("");
    ostringstream oss;
    oss.precision(10);//précision de 10 chiffres significatifs
    oss<<decimal;
    chaineDecimal=oss.str();
 
    int positionPoint=chaineDecimal.find('.',0);
    if(positionPoint==-1)
    {
        int longueurChaineDecimal=chaineDecimal.length();
        string exposant=chaineDecimal.substr(chaineDecimal.length()-1);
 
        char premierChiffre;
        int indicePremierChiffre(0);
 
        if(chaineDecimal[0]=='-')
        {
            indicePremierChiffre=1;
        }
        else
        {
            indicePremierChiffre=0;
        }
 
        premierChiffre=chaineDecimal[indicePremierChiffre];
        chaineDecimal[indicePremierChiffre]='0';
        chaineDecimal[indicePremierChiffre+1]='.';
 
        for(int i(2+indicePremierChiffre);i<longueurChaineDecimal;i++)
        {
            chaineDecimal[i]='0';
        }
 
        for(int i=longueurChaineDecimal;i<stol(exposant)+1+indicePremierChiffre;i++)
        {
            chaineDecimal+='0';
        }
        chaineDecimal+=premierChiffre;
 
        positionPoint=chaineDecimal.find('.',0);
    }
 
    chaineDecimal.erase(positionPoint,1);
 
    m_numerateur=stol(chaineDecimal);
 
    int nbChiffresApresVirgule=chaineDecimal.length()-positionPoint;
 
    string chaineDenominateur("1");
    for(int i=0;i<nbChiffresApresVirgule;i++)
    {
        chaineDenominateur+='0';
    }
 
    m_denominateur=stol(chaineDenominateur);
 
 
}

Le code est un peu long mais il gère les nombres avec un chiffre significatif à plus de 4 zéros après la virgule comme 0.00001. Il gère aussi les décimaux négatifs comme -0.00001.