convergence fonction (classique)

Version imprimable

Bonsoir,

Je vous propose un programme (classique et plutôt scolaire) pour tester la convergence d'une fonction:
je pose : Un+1 = Un – (function1(d1 ;d2)/function2(d1 ;d2))
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 Extended function1(double d1,double d2) ; Extended function2(double d1,double d2) ; #include <iostream> #include <maths.h> int main() { int i; double du0=10; double du1=0 ; for(i=0 ;i<30 ;i++) { if(function2(du1 ;5) !=0) { du0= du1-(function1(du1 ;5)/function2(du1 ;5)) ; } if(fabs(du0-du1)=0) { break ; } du1=du0 ; } if(i<30) { std :: cout << Ås the suites converge to Åt << du1 ; } else { std :: cout << “the suites don’t converge”; } return 0; }
comment l'améliorer/le rendre plus robuste ?

Je vous remercie de votre aide.

01/03/2011, 09h24
Meseira
Code:

1 2 3 4 5 6 ... if(fabs(du0-du1)=0) { break ; } ...
Cette façon de comparer des doubles n'est pas super. En effet, tu n'auras (presque) jamais zéro et donc tu n'exécuteras pas break. Il vaut mieux comparer l'écart de du0 à du1 à une valeur EPSILON fixée.
01/03/2011, 15h08
sandrine_87

Citation:

Envoyé par Meseira

Il vaut mieux comparer l'écart de du0 à du1 à une valeur EPSILON fixée.

Absolument, c'est la définition même de la limite d'une suite (de point de vue séquentiel)
on génère un epsilon petit ou on le fixe nous même? et on introduit une boucle if? j'avoue ne vois pas trop comment faire

je vous remercie encore.
01/03/2011, 15h28
dragonjoker59

tu peux utiliser std::numeric_limits<float>::epsilon, qui représente le plus petit float donnant ceci : 'a + epsilon > a'

Ah d'accord je ne savais pas que ça existait, Merci :)
c'est bon si je le rédige de cette sorte ? ou break n'a pas sa place ici carrément.
Citation:
Envoyé par sandrine_87
Bonsoir,

Je vous propose un programme (classique et plutôt scolaire) pour tester la convergence d'une fonction:
je pose : Un+1 = Un – (function1(d1 ;d2)/function2(d1 ;d2))
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 Extended function1(double d1,double d2) ; Extended function2(double d1,double d2) ; #include <iostream> #include <maths.h> int main() { int i; double du0=10; double du1=0 ; for(i=0 ;i<30 ;i++) { if(function2(du1 ;5) !=0) { du0= du1-(function1(du1 ;5)/function2(du1 ;5)) ; } std::numeric_limits<float>::epsilon; if(fabs(du0-du1)<= epsilon) { break ; } du1=du0 ; } if(i<30) { std :: cout << Ås the suites converge to Åt << du1 ; } else { std :: cout << “the suites don’t converge”; } return 0; }

en fait il s'agit d'une constante donc il faut l'utiliser de la manière suivante:

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
 
Extended function1(double d1,double d2) ;
Extended function2(double d1,double d2) ;
#include <iostream>
#include <maths.h>
int main()
{
   int i;
   double du0=10;
   double du1=0 ;
   for(i = 0 ; i < 30 ; i++)
   {
      if(function2(du1 ;5) !=0)
      {
         du0= du1-(function1(du1 ;5)/function2(du1 ;5)) ;
      }
      if(fabs(du0-du1) < std::numeric_limits<double>::epsilon)//double car tu fais des comparaisons sur des double
      {
         break ;
      }
      du1=du0 ;
   }
   if(i<30)
   {
      std :: cout << Ås the suites converge to Åt << du1 ;
   }
   else
   {
      std :: cout << “the suites don’t converge”;
   }
   return 0;
}

01/03/2011, 18h52
sandrine_87

okioki je vois, effectivement, c'est bon à savoir! je vous en remercie.
j'ai une autre question sur le même code, en effet j'aimerais pouvoir rajouter des fonctions (très similaires!) mais au lieu de les recoder de la même façon serait t il possible d'aller plus vite que la méthode "bulldozer" ?

voici les deux fonctions:

Un+1=Un – (function3(d1 ;d2)/function4(d1 ;d2))
Un+1=Un – (function5(d1 ;d2)/function5(d1 ;d2))
donc c'est vraiment la même définition mais aussi

merci encore pour vos propositions.
02/03/2011, 09h40
dragonjoker59

Pour cela il te suffit de créer une fonction 'convergence' qui prendrait en paramètre les fonctions que tu veux utiliser

Bonjour,

Je vous remercie pour votre réponse, j'avoue que c'est la première fois que j'ai à manipuler ce genre de chose, voici donc ma tentative après avoir lu un poly disponible sur le net.
pointeur sur la fonction qui ne retourne rien (mais juste indique que tout se passe bien) et prend en paramètre deux double, code que je traduit de la sorte.
Code:

1 2 3 4 5 6 7 void convergence(void (*ptSFonc)(double, double)) { std::cout << (*ptSFonc)(d3, d4); << endl; std::cout << (*ptSFonc)(d3, d4); << endl; // correct ou suis-je à côté de la plaque? merci encore. }

Si je ne me trompe pas c'est correct, mais je l'écris généralement ainsi, pour la lisibilité :
Code:

1 2 3 4 5 6 7 8 9 typedef void (SFonc) ( double, double); typedef SFonc * PSFonc; void convergence(PSFonc ptSFonc) { std::cout << ptSFonc(d3, d4); << endl; std::cout << ptSFonc(d3, d4); << endl; }

Super merci!
Pour récapituler, et afin de tout mettre dans l'ordre voici l'intégralité du code.

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
 
#include <iostream>
#include <maths.h>
 
typedef void (SFonc) ( double, double);
typedef SFonc * PSFonc;
 
void convergence(PSFonc ptSFonc)
{
   std::cout << ptSFonc(d3, d4); << endl;
   std::cout << ptSFonc(d3, d4); << endl;
}// Prendre une fonction qui prend en argument une autre fonction.
 
Extended function1(double d1,double d2) ;
Extended function2(double d1,double d2) ;
Extended function3(double d1,double d2) ;
Extended function4(double d1,double d2) ;
Extended function5(double d1,double d2) ;
Extended function6(double d1,double d2) ;
 
int main()
{
   int i;
   double du0=10;
   double du1=0 ;
   for(i = 0 ; i < 30 ; i++)
   {
      if(function2(du1 ;5) !=0)
      {
         du0= du1-(function1(du1 ;5)/function2(du1 ;5)) ;
      }
      if(fabs(du0-du1) < std::numeric_limits<double>::epsilon)//double car tu fais des comparaisons sur des double 
//en fait Cette façon de comparer des doubles n'est pas très élégante, car on n'aura (presque) jamais //zéro et donc le "break" ne sera pas exécuté. il est donc mieux de comparer l'écart de du0 à du1 à une //valeur EPSILON fixée (en revenant à la définition même de la limite) ce qui se traduit par 
 
if(fabs(du0-du1) < std::numeric_limits<double>::epsilon)
      {
         break ;
      }
      du1=du0 ;
   }
   if(i<30)
   {
      std :: cout << Ås the suites converge to Åt << du1 ;
   }
   else
   {
      std :: cout << “the suites don’t converge”;
   }
   return 0;
}

Est-ce encore bon ?