condition pas respectée et atof :(

Bonjour tous,

je viens vous soumettre un de mes problèmes, j'espère que vous pourrez me débloquer car là je ne sais plus trop quoi faire...

je vous explique :

j'ai un fichier texte qui contient des données : "0.1 45.458 0.2 452.5 ...Etc"
je viens lire ces données ligne par ligne et je stock chacun de ces nombres dans un vecteur de string "vector<string> myNb"

ensuite je viens faire un conversion de ces composantes de "string" vers "double" avec la commande "atof".

Code:

---

mesDoubles.push_back((atof(myNb[i].c_str())));

---

ensuite dans mon code je viens faire un test sur ces nombres :

Code:

---

if(45.458==mesDoubles[i])

---

mon soucis :

tout ceci fonctionne parfaitement excepté lors du test "if"
même si dans mon fichier texte j'ai le nombre "45.458" il ne sera transformé par atof en "45.457999999999999999999999"
et du coup ma condition

Code:

---

if(45.458==mesDoubles[i])

---

qui devrait être vrai ne l'ai jamais...

Question :

du coup, je voudrais savoir comment dois je faire pour que ce test soit vrai lorsque 45.458 est enregistré dans le code en
temps que "45.457999999999999999999999" ??

est il possible que "atof" m'enregistre automatiquement la valeur exacte "45.458" ???

je vous remercie pour l'aide que vous pourrez m'apportez !!!

double & float. tout est dit.

Les nombres flottants ne sont pas une suite de digits après une virgule, mais une suite de bits après une virgule (et avec uniquement 1 avant la virgule), multipliée par une puissance de 2 (ou 10, je n'arrive pas à le retenir).

Il s'agit d'une somme limitée de puissance négative de 2:

1 = 1/1 + 0/2 + 0/4 + 0/8 …
1,5 = 1/1 + 1/2
45.457999999999999999999999 = des choses...
45.458 n'est pas possible avec cette écriture.
renseigne toi sur l'erreur flottante.

En tout état de cause, l'égalité est impossible entre nombres flottants.

suppose les fichiers suivants:

Code:

---

double unite();

---

Code:

---

double unite(){return 1.0;}

---

Code:

---

1 2 3 4 5

#include "autre.h" #include <iostream> int main(){ std::cout << ( ( (unite()+0.1)==1.1 ) ? "vrai" : "faux" ) <<std::endl; }

---

Une fois compilés, on obtient "faux", parce que 1.1 = 1 + 1/16 + 1/32 + 1/256 + 1/512 + ...

Bonjour,

Citation:

---

du coup, je voudrais savoir comment dois je faire pour que ce test soit vrai lorsque 45.458 est enregistré dans le code en
temps que "45.457999999999999999999999" ??

---

Tu peux faire la différence entre ta valeur à tester et ta variable et vérifier qu'elle est inférieure à une marge d'erreur (nommée ici EPSILON).

Code:

---

1 2 3 4 5 6

double temp = (45.458 - mesDoubles[i]); if (abs(temp) < EPSILON) { // Code... }

---

La valeur que tu choisiras pour EPSILON dépendra de tes besoins en précision.

Citation:

---

est il possible que "atof" m'enregistre automatiquement la valeur exacte "45.458" ???

---

Non, comme l'a très bien expliqué Leternel, les unités de calculs à virgule flottante ne comptent pas en décimal, mais en binaire et ne peuvent représenter exactement le nombre 45,458.

merci de ta réponse leternel mais je n'ai pas tout saisi.... que veux tu dire par pas de test possible sur des flottants ? et sur la différence flottant / double ?

Precision = voici les étapes de ce bout de code :
------------------------------------------------------------
1°) je lis dans un fichier une base de donnée rentrée par un utilisateur,
j'enregistre ceci dans des string puis des double (avec atof) et j'ai ma base de donnée de référence.
2°) je fais des conversions d'unités de ma base de donnée (toujours en double)
3°) je test si ces nombres qui appartiennent à la base de donnée sont bien égaux au résultat d'un calcul enregistré dans un autre fichier texte.
==> je n'ai pas le choix j'ai forcement quelque chose qui peut être différent d'un entier
==> comment savoir si un nombre de ma base de donnée existe dans un fichier si je ne peux pas le tester ?

Citation:

---

Envoyé par Niark13

Tu peux faire la différence entre ta valeur à tester et ta variable et vérifier qu'elle est inférieure à une marge d'erreur (nommée ici EPSILON).

---

OK merci. Je vois ce que tu veux dire :)

=> par contre est il possible de définir EPSILON egale à l'incertitude de mes variables facilement ?

=> pour des doubles c'est 1e-15 la précision ? je peux donc mettre EPSILON=1e-14 ?

tu as un numeric_limits<double>::epsilon(), je crois.

merci l'éternel ! c'est exactement ce que je cherchais !

Salut,

Pour information, std::numeric_limits<float ou double>::epsilon() représente, pour une machine donnée, la plus petite valeur pour le type en question qui ferait que x - epsilon = x = x + epsilon.

Le problème, c'est que c'est dépendant de l'implémentation :aie:

Ne t'en fais quand meme pas trop, ceci dit : tu as normalement plus que très largement de quoi assurer une plus que correcte pour chaque type envisagé ;)

Mais ce qui importe surtout, c'est que tu peux, à tout moment, décider d'utiliser une précision moindre que celle indiquée par epsilon : il est toujours possible de dire "voilà, je sais que je dispose de X chiffres derrières la virgule avec epsilon, mais je me contenterai de Y chiffres (ou Y < X )".

Pour autant, bien sur, que tu aies des raisons d'agir de la sorte :aie:

Et, ceci dit, si tu pars sur l'utilisation d'un double, je présume que c'est parce que tu as besoin d'un maximum de leur précision... Il serait donc dommage d'agir ainsi :aie: ;)

merci pour ces compléments 8-)