Discussion :

[deubelte]

Voici le code suivant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[cboudy]

en rajoutant à la fin du deuxième code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

ça donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[deubelte]

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

[cboudy]

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

[deubelte]

un truc comme ca serait il bon:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}  }

[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

[thewho]

Bonjour,

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[deubelte]

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

[thewho]

Bonjour,

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.

[JolyLoic]

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.

[cboudy]

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