truc bizarre dans une boucle

Voici le code suivant

Code:

---

1 2 3 4 5 6 7

int main(){ double min_ws=1; double ws,dws=exp(0.1); for (ws = min_ws; ws <= min_ws*dws;ws*=dws) {cout<<ws<<","; }}

---

il est tout a fait normal qu'il me renvoie 1,1.10517, puisque j'initialise a min_ws, puis je parcours la boucle jusqu'a min_ws*dws en incrémentant ws de dws.

Par contre:

Code:

---

1 2 3 4 5 6 7

int main(){ double min_ws=1; double ws,dws=exp(0.1); for (ws = min_ws; ws <= min_ws*dws*dws ;ws*=dws) {cout<<ws<<","; }}

---

renvoie la meme chose, alors que j'ai repoussé la limite a min_ws*dws*dws au lieu de min_ws*dws

Enfin:

Code:

---

1 2 3 4 5 6 7

int main(){ double min_ws=1; double ws,dws=exp(0.1); for (ws = min_ws; ws <= min_ws*dws*dws*dws ;ws*=dws) {cout<<ws<<","; }}

---

Il me renvoie 4 nombres, ce qui est correcte. En gros il y a un problème au deuxieme programme
JE ne vois pas du tout d'ou vient l'erreur???
J'avoue etre perdu la!!!
merci de m'aider.

en rajoutant à la fin du deuxième code :

Code:

---

1 2	cout<<endl<<ws<<" "<<min_ws*dws*dws<<" "<<ws-min_ws*dws*dws;

---

ça donne :

Code:

---

1 2 3 4 5

$ ./a.exe 1.2214 1,1.10517, 1.2214 1.2214 4.91144e-017

---

donc le fait qu'il s'arrête est tout à fait normal,

pour régler le problème, je te conseille soit d'utiliser des entiers pour tes indices de boucle (en tout cas on m'a toujours déconseillé de faire le contraire)
soit de comparer la valeur absolue de l'écart à un epsilon comme fait pour savoir si une valeur est nulle

ok, j'ai vu.
mais pourquoi bug til à la deuxieme boucle, alors qu'il bug pas dans les autres?

parce que pour la deuxième boucle de delta est "légèrement positif" alors que dans les autres cas le delta "légèrement négatif"
donc en gros tu as une chance sur deux que le dernier test soit bon parce que les deux valeurs sont très proches

un truc comme ca serait il bon:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

int main(){ double min_ws=1,ws; double i,dws=exp(0.1); i=0; ws=min_ws; for (i=1; i <= 18;i++) {   cout<<ws<<"'";   ws=ws*dws; } }

---

tout a fait parce que car tu utilises un entier comme indice de boucle
donc la il n'y aura pas de problème avec un delta infiniment petit

Bonjour,

Citation:

---

Envoyé par cboudy

tout a fait parce que car tu utilises un entier comme indice de boucle
donc la il n'y aura pas de problème avec un delta infiniment petit

---

?? alors que le code donne

Code:

---

1 2 3 4 5 6 7 8 9 10 11

int main(){ double min_ws=1,ws; double i,dws=exp(0.1); i=0; ws=min_ws; for (i=1; i <= 18;i++) { cout<<ws<<"'"; ws=ws*dws; } }

---

S'il est utilisé comme un entier, pourquoi ne pas l'avoir défini comme int ?

c'est vrai, mais changer le type de double en int ne doit pas changer grand chose.

Bonjour,

Citation:

---

Envoyé par deubelte

c'est vrai, mais changer le type de double en int ne doit pas changer grand chose.

---

Ça assure qu'il n'y aura pas d'approximation lors du +1.

Il faut toujours faire attention quand on utilise des nombres réels.

Citation:

---

Envoyé par deubelte

c'est vrai, mais changer le type de double en int ne doit pas changer grand chose.

---

Tu peux avoir des écarts de calculs carrément non négligeables. Surtout sur des plate-formes où les ints sont 64 bits.

j'avais pas fais attention 8O , effectivement il vaut mieux déclarer i en tant que integer pour éviter les approximations