boucle for: indice double

Bonjour,

Je veux afficher les valeurs entre 0 et 359.99, j'ai fait la boucle suivante:

Code:

---

1 2 3 4

for (double i=0; i<360.; i+=0.01) { printf("%f\n", i); }

---

mais j'ai la valeur 360 aussi affichée

Qu'est ce qui ne va pas dans cette boucle?
Merci d'avance

C'est du C, pas du C++ ;)

Sinon, aucun souci en théorie.
Par contre en pratique: bienvenue dans les problèmes de précision et des nombres flottants non représentables (comme 1/3 en décimal) ;)

Exécute ce programme pour mieux comprendre ce qu'il se passe.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

// g++ -Wall -Wextra i_double.cpp -o i_double   # include <iostream> # include <limits>   int main() { std::cout.precision(std::numeric_limits<double>::digits10+1);   for (double i = 0; i < 360.; i += 0.01) { std::cout << i << std::endl; }   for (int i = 0; i < 360 * 100; ++i) { std::cout << double(i) / 100 << std::endl; } }

---

Le deuxième boucle devrait faire ce que tu veux.

En gros, 0.01 + 0.01 + 0.01 + (...) + 0.01 +0.01 (répété 36000 fois) est différent de 360.0
A lire : Les nombres flottants et leurs pièges ainsi que les autres articles de la série (non encore traduit)

Avec les erreurs d'arrondi, je parie que tu te retrouves avec un 359.9999999999 qui est inférieur à 360, mais s'affiche comme tel dans le printf().

Merci tout le monde
effectivement Médinoc, c'est ce que j'ai trouvé lorsque j'ai exécuté pas à pas

Salut, j'ai trouvé le même problème lors de l’écriture dans le fichier

j'ai une valeur de 2,59045392, mais la valeur affichée dans le fichier est 2,59; sachant que le cumul de ces erreurs me donne un mauvais résultat à la fin de mes calculs

j'utilise ce bout de code pour l'ecrture

Code:

---

1 2 3 4 5 6 7 8 9

ofstream fichier2("validation2.csv", ios::out | ios::trunc); // ouverture en écriture avec effacement du fichier ouvert if(fichier2) { for (int i=0; i<vect.size(); i++) { fichier2 << vect.at(i) << endl; } fichier2.close(); }

---

comment je peux résoudre le problème d'affichage
merci d'avance

Si ton vecteur contient des doubles, tu peux jouer avec les manipulateurs d' <iomanip>

Code:

---

1 2 3 4 5 6

for (size_t i=0; i<vect.size(); i++) { //Demande d’afficher 8 chiffres après la virgule fichier2 << std::fixed << std::setprecision(8) << vect.at(i) << std::endl; }

---

Salut,
Ne serait-il pas plus intéressant de travailler en virgule fixe ?

Bonjour,

Je te conseille d'éviter le plus possible de travailler avec des décimaux.
Préfère utiliser des entiers, puis quelques divisions pour atteindre ton résultat.

Citation:

---

Envoyé par Bousk

Bonjour,

Je te conseille d'éviter le plus possible de travailler avec des décimaux.
Préfère utiliser des entiers, puis quelques divisions pour atteindre ton résultat.

---

Justement, si c'était des décimaux son code fonctionnerait. C'est des binaires.

Citation:

---

Envoyé par Hibernatus34

Justement, si c'était des décimaux son code fonctionnerait. C'est des binaires.

---

:koi: pas compris
Bousk parle de ne pas utiliser des nombres décimaux (nombres à virgule flottant), mais des entiers (3DArchi a fait la même remarque)
Tu appelles quoi "des binaires" ?

Hibernatus dit que si c'étaient des décimaux (nombre à virgule flottante en décimal) ça marcherait, mais que malheureusement il s'agit ici de nombres à virgule flottante en binaire.

Ah ok, j'avais pas compris (à force de faire des raccourcis :))

Oui, c'est bien ce que je voulais dire.
Quand on a compris qu'il s'agit de binaire (2^3 + 2^0 + 2^-1 + 2^-5...) on a tout compris.

Juste pour chipoter, la limite vient du fait que c'est une approximation avec une nombre limité de digits, pas de la représentation binaire en elle même (on peut écrire pi en binaire avec une infinité de bits je crois, à confirmer par un vrai matheux) :aie:

Citation:

---

Envoyé par gbdivers

Juste pour chipoter, la limite vient du fait que c'est une approximation avec une nombre limité de digits, pas de la représentation binaire en elle même (on peut écrire pi en binaire avec une infinité de bits je crois, à confirmer par un vrai matheux) :aie:

---

Oui (pour pi)

Il y a deux choses. Premieremement, un nombre fini de bits signifie qu'on n'a qu'un nombre fini de nombres quelque soit la representation. Donc pour les reels on se retrouve limite en intervalle (il y a un plus grand et plus petit reel representable -- les flottants ont parfois une representation pour l'infini, mais ces infinis ne sont plus des reels) et en precision (entre deux reels, il y en a une infinite de reels, entre deux flottants, il y a un nombre fini eventuellement nul de flottants).

Une representation binaire se retrouve a ne pas pouvoir representer des nombres qui ont une representation simple en decimal (comme 0.1). Si on se contente de lire et de reecrire des nombres avec une addition ou deux, une representation decimale a moins de probleme parce qu'elle partage les limitations du format d'entree. Si on fait un peu plus de calculs, la precision finie va etre limitante avec l'un et l'autre. Et le format decimal offre aussi des surprises que le format binaire n'a pas (p.e. (a+b)/2 peut etre plus grand que a et que b alors que le resultat exact est representable, bon amusement si tu fais une recherche par dichotomie).

En resume, la precision est meilleure avec les flottants binaires mais il y a des cas ou les decimaux donnent une solution exacte et pas les binaires. Ces cas importe peu en pratique, il y aura toujours des resultats inexacts. Dans les cas, comme en comptabilite, ou on est contraint par des regles d'arrondi specifiee en decimal, les flottants decimaux n'aident a ma connaissance pas: ces regles sont specifiees pour des representations en virgule fixe, pas pour des representations flottantes et si on se met a utiliser les flottants decimaux en profitant que ce sont des flottants, c'est fichu. Et meme dans cette zone, il y a des risques de double arrondi, donc il faut se taper exactement la meme analyse de precision qu'avec des flottants binaires -- l'implementation pouvant etre legerement facilitee -- ou utiliser les flottants decimaux comme des entiers , ce qu'on peut faire avec les flottants binaires ou des long long -- a nouveau on peut avoir une implementation legerement facilitee, mais l'analyse est la meme.

Je ne comprends pas ce que tu veux dire sur (a+b)/2...

Citation:

---

Envoyé par Médinoc

Je ne comprends pas ce que tu veux dire sur (a+b)/2...

---

Avec des flottants ayant 3 chiffres significatifs.

9.99E1 + 9.97E1 = 19.96E1 qu'on doit arrondir a 2.00E2

2.00E2/2 = 1.00E2 alors que la moyenne est 9.98E1 et est representable.

eh bien change donc écris plutôt a/2 + b/2 ^^

Citation:

---

Envoyé par germinolegrand

eh bien change donc écris plutôt a/2 + b/2 ^^

---

Tu arrives a 9.97E1 plutot que 9.98E1. C'est a + (b-a)/2 qu'il faudrait ecrire. Mais le point est qu'il faut faire attention des qu'on utilise des flottants, et que les flottants decimaux ne sont pas une solution qui permette d'eviter les analyses.

dans ce cas utilise std::ratio et tout le monde sera content ^^

Citation:

---

Envoyé par germinolegrand

dans ce cas utilise std::ratio et tout le monde sera content ^^

---

J'explique pourquoi à mon avis les types flottants décimaux ne sont pas la panacée que certains croient, on me suggère d'utiliser une classe prévue pour le calcul à la compilation sur rationnels. Il y a quelqu'un qui n'a pas compris quelque chose.

Merci de ton explication.