Résolution d'une equation.

Version imprimable

Bonsoir

Je débute tout juste dans le langage C. Pour un projet info, on doit resoudre une equation de degré 4 par la methode dichotomique. Je connais cette methode sur le papier mais je n'arrive pas à la traduire en C.

Quelqu'un pourrait il m'aiguiller à ce sujet ?

Autre question, j'ai essayé de résoudre une equation de degré 4=0 de façon linéaire. Je défini un plage de recherche ( par exemple de -10 à 10 ), ensuite je defini une précision( combien de chiffre àprès la virgule ) et je met tout ça dans le boucle for en disant de calculer pour chaque valeur comprise dans la plage.
Un exemple :
Je demande de calculer de -2 à 2 avec une précision de 0.1. il va calculer avec les valeurs -2, -1.9, -1.8, 1.7..............................1.9, 2.
Ayant très peu de chance de tombé sur une valeur juste, je ne trouve pas comment faire pour afficher les solutions de l'équation avec la précision?

Voici le bout de code que j'ai commencé :
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 #include <stdio.h> #include <stdlib.h> #include <math.h> void resoudre() { float a,b,c,d,e,borne_inf,borne_sup,precision,x,resultat; a=2; b=5; c=6; d=8; e=4; borne_inf=-4; borne_sup=6; precision=0.0001; x=borne_inf; for(x=borne_inf; x<borne_sup; x+=precision) { if(resultat<precision&&resultat>(0-precision)) { printf("%f est un resultat\n",x); } resultat=(a*(pow(x,4))+b*(pow(x,3))+c*(pow(x,2))+d*x+e); } } int main () { resoudre(); system("PAUSE"); return 0; }
Merci d'avance à tous !

Pierre

15/11/2007, 21h45
salseropom
salut, bienvenue sur le forum
Concernant la précison, ce n'est pas comme ça qu'il faut faire : tu calcules 2 itéres x1 et x2 et si |x1-x2| < eps tu t'arrêtes, où eps est la précision de ton résultat. Dans ton cas, tu peux poser eps = 0,1 par exemple (en général, on s'arrête avec eps = 1e-13)

utilises des doubles et non des floats

tu as écrit
Code:

1 2 if(resultat<precision&&resultat>(0-precision))
autant écrire :
Code:

1 2 if(fabs(resultat-precision)<eps) /* tu te donnes une valeur pour eps */
15/11/2007, 22h00
piieerre

Je ne suis pas sur d'avoir tout compris........:(
J'ai essayé de remplacer ce que tu m'a donné mais ça me sort des valeurs bizarre.
fabs() c'est une fonction ?

Merci d'avance

Pierre
15/11/2007, 22h23
exhortae

Citation:

Envoyé par piieerre

Je ne suis pas sur d'avoir tout compris........:(
J'ai essayé de remplacer ce que tu m'a donné mais ça me sort des valeurs bizarre.
fabs() c'est une fonction ?

Merci d'avance

Pierre

quand tu fais eps = |x1 - x2| tu calcule la précision en faisant la différence entre la dernière valeur obtenue et l'avant dernière, plus tu t'approches de cette précision plus celà veut dire que tu es proche de la solution

fabs () est une fonction de math.h c'est la valeur absolue d'un double.
16/11/2007, 09h18
piieerre

Bonjour et merci de vos reponses.

J'ai bien compris votre solution, mais je n'arrive pas à la traduire en C.
Mon problème est que comment donner au dernier et avant dernièr resultat afin de les comparer et ensuite arrèter le calcul et afficher les resultats?
Quelqu'un peut il me conseiller sur la démarche a suivre en partant sur le bout de code de départ.

Merci d'avance

Pierre

Code:

1 2 3 4 5 6 7 8 9 for(x=borne_inf; x<borne_sup; x+=precision) { if(resultat<precision&&resultat>(0-precision)) { printf("%f est un resultat\n",x); } resultat=(a*(pow(x,4))+b*(pow(x,3))+c*(pow(x,2))+d*x+e); }
Une petite remarque en passant. Il me semble plus logique de calculer "resultat" puis de rechercher à l'afficher s'il est suffisamment proche de zéro et non l'inverse !!! En plus, dans ton code, comme "resultat" n'est pas initialisée, le premier test if n'a pas de sens.

Voici le code modifié avec vos information.
La seul chose que j'ai pas modifié car je n'ai pas encore compris pour le traduire en C, c'est la variable "eps" et |x1-x2]. Je ne sais pas trop ou placer ceci.

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
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
void resoudre()
      {
      double a,b,c,d,e,borne_inf,borne_sup,precision;
      double x;
      double resultat;
      a=2;
      b=5;
      c=6;
      d=8;
      e=4;
      borne_inf=-10;
      borne_sup=10;
      precision=0.001;
      resultat=0;
      x=borne_inf;
      for(x=borne_inf; x<borne_sup; x+=precision)
      {
       resultat=(a*(pow(x,4))+b*(pow(x,3))+c*(pow(x,2))+d*x+e);            
 
       if(fabs(resultat<precision)&&fabs(resultat>(0-precision)))
       {
       printf("%lf est un resultat\n",x);
       }
 
      }
}
 
int main ()
{
    resoudre();
 
    system("PAUSE");
    return 0;
}

Merci d'avance

Pierre

16/11/2007, 11h51
corentin59
A vrai dire, je ne comprend pas trop la solution de salseropom :

Citation:

Concernant la précison, ce n'est pas comme ça qu'il faut faire : tu calcules 2 itéres x1 et x2 et si |x1-x2| < eps tu t'arrêtes, où eps est la précision de ton résultat. Dans ton cas, tu peux poser eps = 0,1 par exemple (en général, on s'arrête avec eps = 1e-13)

Mais dans ton cas,
Code:

1 2 if ( resultat < precision && resultat > (0-precision) )
c'est pareil que (en supposant que precision est positif;))
Code:

1 2 if ( fabs(resultat) < precision )
C'est toi qui définit la variable "eps", au même titre que "precision" ou "x", ... eps est le nom couramment utilisé pour désigner la précision ou plus précisemment que l'on recherche un résultat à espilon près.

Enfin, deux petites remarques. Dans
Code:

1 2 3 x=borne_inf; for(x=borne_inf; x<borne_sup; x+=precision)
la première ligne est inutile car tu le fais juste après. Ensuite, peut-être vaut-il mieux aller jusqu'à la borne sup : x<=borne_sup. Mais c'est vraiment du détail.
16/11/2007, 12h23
salseropom
Citation:

Envoyé par corentin59

A vrai dire, je ne comprend pas trop la solution de salseropom :

je prends par exemple la méthdoe de dichotomie (ou newton, ou lagrange etc...)
au début du pose
a=x1 et b = xn et m = (a+b)/2
puis tu calcules f(a)*f(m) et suivant le signe de ce produit tu modifie a ou b et tu recommences. Donc en gros ça donne
Code:

1 2 3 4 5 while(un certain critère) { faire la dichotomie }
et donc tu arrêtes tes itérations quand |a-b| < epsilon (et tu te fixes epsilon).
Toi, tu calcules ta fonction f pour x1, x2, x3 etc... et c'est toi qui te donnes l'"écart" entre ces points de discrétisation. Ce n'est pas la même chose.

J'espère que c'est un peu plus clair...
16/11/2007, 13h31
corentin59

OK pour la méthode par dichotomie. En fait, piieerre voulait implémenter cette méthode mais il n'y arrivait pas, il a donc proposé un code pour faire une résolution linéaire. C'est sur ce code que j'ai réagi et pour lequel je ne comprenais pas ce que tu proposais. Nn fait, tu étais directement passé à la dichotomie.
18/11/2007, 11h17
piieerre

Bonjour

Merci pour toutes ces informations, je commence à y voir un peu plus clair même si je ne suis toujours pas arrivé à programmer cette méthode. :(

Cependant, une question me reviens :

Donc dans mon cas, il s'agit d'une équation du 4eme degré , donc il peut y avoir 4 solutions à la résolution. Donc comment faire pour utiliser la methode pour trouver plusieurs solutions?

Quelqu'un peut il me faire un petit bout de code afin de me lancer dans la résolution de ce problème?

En vous remerciant tous d'avance, de toute l'attention que vous me porterez.

Pierre

Salut,
petit rappel de maths (et non de C...) : il faut que ta fonction soit bijective et continue sur un intervalle I pour trouver l'unique solution sur cet intervalle (théroème des valeurs intermédiaires). La méthdoe de dichotomie, newton etc te donneras une solution mais pas toute, ni même laquelle (si tu les ranges par ordre croissant).
Tout dépend de la condition initiale (pour newton) et de l'intervalle [a, b] pour la dichotomie.

une 1e idée (non testée !!) (tu trouveras plein d'algos de la dichotomie sur internet)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 double a=1., b=4; /* tu fais la dichotomie sur [a,b] */ double m=(a+B)/2.; double eps=1e-10; /* précision du calcul */ /* ici je suppose que la fonction f est CROISSANTE sur [a, b]. je te laisse le cas ou f est decroissante (tu peux poser g = -f) */ while(fabs(a-b)>eps) { if(f(a)*f(m)<0) /* la racine est dans l'intervalle [a, m] */ { b=m; m=(a+b)/2.; } else /* la racine est dans l'intervalle [m, a] */ { a=m; m=(a+b)/2.; } }
a toi de t'assurer que ta fonction est bijective sur ton intervalle [a, b] initiale. Ceci passe donc par une étude de sa monotonie.

Bonjour et merci pour les infos!
J'ai planché ce week end sur le problème et la division par dichotomie marche.
Cependant, je n'arrive pas retourner les resultats et de les afficher.
Voici mon 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
51
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
double resoudre()
{
double a,b,c,d,e,borne_inf,borne_sup,precision;
double x;
double resultat;
 
double m=(borne_inf+borne_sup)/2;
int nbr_result;
 
resultat=0;
nbr_result=0;
a=1;
b=1;
c=1;
d=3;
e=1;
borne_inf=-1000;
borne_sup=1000;
precision=1e-10;
 
 
/* ici je suppose que la fonction f est CROISSANTE sur [a, b]. je te laisse le cas ou f est decroissante (tu peux poser g = -f) */
while(fabs(borne_inf-borne_sup)>precision)
{
 if((a*(pow(borne_inf,4))+b*(pow(borne_inf,3))+c*(pow(borne_inf,2))+d*borne_inf+e)*(a*(pow(m,4))+b*(pow(m,3))+c*(pow(m,2))+d*m+e)<0) /* la racine est dans l'intervalle [a, m] */
  {
    borne_sup=m;
    m=(borne_inf+borne_sup)/2.;
  }
  else /* la racine est dans l'intervalle [m, a] */
  {
    borne_inf=m;
    m=(borne_inf+borne_sup)/2.;
 
  }
  printf("%lf\n",m);
}
}
 
 
 
int main ()
{
resoudre();
system("PAUSE");
return 0;
}

En vous remerciant tous d'avance

Pierre

Code:

printf("%g\n",m);

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
51
52
53
54
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
double resoudre (void);
 
int main (void)
{
   resoudre ();
   getchar ();
   return 0;
}
 
double resoudre (void)
{
   double a = 1;
   double b = 1;
   double c = 1;
   double d = 3;
   double e = 1;
   double borne_inf = -1000;
   double borne_sup = 1000;
   double precision = 1e-10;
   double m = (borne_inf + borne_sup) / 2;
 
   while (fabs (borne_inf - borne_sup) > precision)
   {
      if ((  a * (pow (borne_inf, 4.0))
           + b * (pow (borne_inf, 3.0))
           + c * (pow (borne_inf, 2.0))
           + d * borne_inf + e
          )
          *
          (  a * (pow (m, 4.0))
           + b * (pow (m, 3.0))
           + c * (pow (m, 2.0))
           + d * m
           + e
          ) < 0)
      {
         borne_sup = m;
         m = (borne_inf + borne_sup) / 2.;
      }
      else
         /* la racine est dans l'intervalle [m, a] */
      {
         borne_inf = m;
         m = (borne_inf + borne_sup) / 2.;
 
      }
      printf ("%g\n", m);
   }
   return m;
}

19/11/2007, 11h07
reptils

que de souffrances pour accoucher de la solution finale !! 8O
19/11/2007, 13h41
salseropom

Citation:

Envoyé par reptils

que de souffrances pour accoucher de la solution finale !! 8O

merci de ton aide... mais avant de penser à l'algo en C, il fallait lui faire qq rappels sur la dichotomie en générale. Et comme le but est d'apprendre à programmer en C (et non pas faire de l'algorithmie car il y a un autre forum dédié à cela), moins on lui donne la réponse "toute faite" et mieux c'est, non ?