Discussion :

[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 :

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

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.

[Meseira]

Code :

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

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.

[sandrine_87]

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.

[dragonjoker59]

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

[sandrine_87]

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.

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 :

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

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

[dragonjoker59]

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

Code :

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

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

[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.

[dragonjoker59]

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

[sandrine_87]

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 :

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

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

[dragonjoker59]

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

Code :

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

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

[sandrine_87]

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

Code :

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

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 ?