Discussion :

[Lucie Mor]

salut

j'ai un probleme
je dois resoudre une equation du quatrieme degre. J'ai trouver sur Internet une methode qui s'appel la methode de Vieta...
Mon programme est en C. Je vous le montre :

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
typedef struct  s_eq
{
  double        a;
  double        b;
  double        c;
  double        d;
  double        e;
  double        b0;
  double        b1;
  double        b2;
}               t_eq;
 
# define        VALEUR_ABS(x)           (((x) >= 0) ? x : -x)
# define        TIERS                   0.333333333333
 
double          second(double a, double b, double c)
{
  double        delta;
  double        k1;
  double        k2;
 
  delta = ((b * b) - (4 * a * c));
  if (delta < 0)
    return (-1);
  k1 = (-b - (sqrt(delta))) / (2 * a);
  k2 = (-b + (sqrt(delta))) / (2 * a);
  printf("y'a deux solutions qui sont %f, et %f\n", k1, k2);
  return (0);
}
 
double          troisieme_unique(double delta, double q, double r, double c)
{
  double        s;
  double        res;
 
  s = pow((pow(-delta, 0.5) + VALEUR_ABS(r)), TIERS);
  if (r < 0)
    res = s + (q / s) - (c / 3);
  else
    res = -s - (q / s) - (c / 3);
  printf("ya une unique solution qui est : %f\n", res);
  return (res);
}
 
double          my_choose_root(double *res)
{
  double        res_final;
  int           i;
 
  i = 0;
  res_final = -1;
  while (i < 3)
    {
      if (res[i] > 0)
        res_final = res[i];
      i++;
    }
  i = 0;
  if (res_final == -1)
    return (-1);
  while (i < 3)
    {
      if (res[i] > 0 && res[i] < res_final)
        res_final = res[i];
      i++;
    }
  printf("bonjour res_final = %f\n", res_final);
  return (res_final);
}
 
double          troisieme_trois(double q, double r, double c)
{
  double        s;
  double        delta_prime;
  double        teta;
  int           i;
  double        cmpt;
  double        res[3];
 
  i = 0;
  cmpt = 0;
  delta_prime = r / (pow(q, 1.5));
  teta = acos(delta_prime) / 3;
  s = -2 * (pow(q, 0.5));
  while (i <= 2)
    {
      res[i] = s * (cos(teta + ((2 * M_PI * cmpt) / 3))) - (c / 3);
      i++;
      cmpt++;
    }
  printf("ya 3 resultat qui sont : %f, %f, %f\n", res[0], res[1], res[2]);
  return (my_choose_root(res));
}
 
double          troisieme(double a, double b, double c, double d)
{
  double        q;
  double        r;
  double        delta;
  double        res;  
 
  a /= d;
  b /= d;
  c /= d;
  d = 1;
  q = ((c * c) - (3 * b)) / 9;
  r = (c * ((c * c) - (4.5 * b)) + 13.5 * a) / 27;
  delta = (q * q * q) - (r * r);
  if (delta < 0)
    res = troisieme_unique(delta, q, r, c);
  else
    res = troisieme_trois(q, r, c);
  return (res);
}
 
double          quatre_to_trois(t_eq *eq)
{
  double        res;
 
  eq->b2 = (3 * (eq->d * eq->d) / 8 - eq->c) / 2;
  eq->b1 = 3 * ((eq->d * eq->d * eq->d * eq->d) / 256) - ((eq->d * eq->d * eq->c) / 16) + ((eq->d * eq->b) / 4) - eq->a;
  eq->b0 = eq->b2 * eq->b1 - pow((((eq->d * eq->d * eq->d) / 16) - (eq->d * eq->c / 4) + (eq->b / 2)), 2);
  printf("eq->b0 = %f, eq->b1 = %f, eq->b2 = %f\n", eq->b0, eq->b1, eq->b2);
  res = troisieme(eq->b0, eq->b1, eq->b2, 1);
  return (res);
}
 
double          calc_root(double delta, double delta_prime, t_eq *eq, double res)
{
  double        alpha;
  double        res_tab[4];
  int           i;
 
  i = 0;
  while (i <= 4)
    res_tab[i++] = -1;
  alpha = delta - 4 * (res - delta_prime);
  printf("premier alpha = %f\n", alpha);
  if (alpha == 0)
    res_tab[0] = -(pow(delta, 0.5)) / 2 + eq->d / 4;
  else if (alpha > 0)
    {
      res_tab[0] = -(pow(delta, 0.5) + pow(alpha, 0.5)) / 2 - eq->d / 4;
      res_tab[1] = -(pow(delta, 0.5) - pow(alpha, 0.5)) / 2 - eq->d / 4;
    }
  alpha = delta - 4 * (res + delta_prime);
  printf("deuxieme alpha = %f\n", alpha);
  if (alpha == 0)
    res_tab[2] = (pow(delta, 0.5)) / 2 + eq->d / 4;
  else if (alpha > 0)
    {
      res_tab[2] = (pow(delta, 0.5) + pow(alpha, 0.5)) / 2 - eq->d / 4;
      res_tab[3] = (pow(delta, 0.5) - pow(alpha, 0.5)) / 2 - eq->d / 4;
    }
  printf("J'ai tout plein de solution qui sont : %f et %f et %f et %f\n", res_tab[0], res_tab[1], res_tab[2], res_tab[3]);
  return (0);
}
 
double          res_quatre(t_eq *eq, double res)
{
  double        delta;
  double        delta_prime;
 
  delta = 2 * (res + eq->b2);
  printf("delta = %f\n", delta);
  if (delta < 0)
    {
      printf("j'ai pas de racine reelle =(\n");
      return (-1);
    }
  else if (delta > 0)
    delta_prime = sqrt((eq->b2 * eq->b1 - eq->b0) / delta);
  else
    {
      delta_prime = ((res * res) + eq->b1);
      if (delta_prime < 0)
        {
          printf("j'ai pas de racine reelle =(\n");
          return (-1);
        }
      else
        delta_prime = pow(((res * res) + eq->b1), 0.5);
    }
  printf("delta_prime = %f\n", delta_prime);
  calc_root(delta, delta_prime, eq, res);
  return (0);
}
 
double          quatrieme(t_eq *eq)
{
  double        res;
 
  eq->a /= eq->e;
  eq->b /= eq->e;
  eq->c /= eq->e;
  eq->d /= eq->e;
  eq->e = 1;
  if (eq->a == 0)
    {
      printf("celui-la c'est la plus mieu et c'est 0\n");
      return (0);
    }
  else
    {
      printf("je ramene au 3eme degres...\n");
      if ((res = quatre_to_trois(eq)) == -1)
        return (-1);
      printf("res = %f\n", res);
      res_quatre(eq, res);
    }
  return (0);
}
 
int     my_resolve_eq(t_eq *eq)
{
  if (eq->d == 0 && eq->e == 0)
    {
      printf("equation du second degres\n");
      second(eq->c, eq->b, eq->a);
    }
  else if (eq->e == 0)
    {
      printf("equation du troisieme degres\n");
      troisieme(eq->a, eq->b, eq->c, eq->d);
    }
  else
    {
      printf("equation du quatrieme degres\n");
      quatrieme(eq);
    }
  return (0);
}
 
int     main(int argc, char **argv)
{
  t_eq  eq;
 
  if (argc != 6)
    {
      printf("Mauvais arguments\n");
      return (EXIT_FAILURE);
    }
  eq.a = atof(argv[1]);
  eq.b = atof(argv[2]);
  eq.c = atof(argv[3]);
  eq.d = atof(argv[4]);
  eq.e = atof(argv[5]);
  printf("Bonjour, je vais resoudre l'equation %f + %fx + %fx^2 + %fx^3 + %fx^4 = 0\n", eq.a, eq.b, eq.c, eq.d, eq.e);
  my_resolve_eq(&eq);
  return (EXIT_SUCCESS);
}

La resolution du 3eme degre marche bien mais pas celle du 4eme... J'ai pourtant verifie chaque calcul a la calculatrice mais je n'ai pas trouve.

Je cherche a recuperer la valeur positive la plus faible.

Merci de votre attention

[FR119492]

Salut !

Pour une équation du quatrième degré, c'est la méthode de Ferrari ou celle de Descartes qu'il faut utiliser.

Jean-Marc Blanc

[acx01b]

salut ça dépend pour quoi faire

si c'est pour utiliser la valeur numérique (si elle doit être le plus précise possible) il faut faire une QR reduction

si tu utilises la méthode de ferrari tu auras une valeur peu précise à cause des arc cosinus et autres racines cubiques

ne pas coder soi même la QR reduction (je ne sais pas comment ça marche et ça a l'air compliqué) --> utiliser une libraire !

[FR119492]

Salut !

Le calcul numérique des zéros d'un polynôme est, par excellence, ce qu'on pourrait appeler un sale problème: deux polynômes ayant des coefficients très voisins peuvent avoir des zéros très différents. Il n'y a pas de bonne méthode générale. La moins mauvaise consiste à construire la matrice compagnon et à calculer ses valeurs propres.

Jean-Marc Blanc

[Alp]

Je confirme que dans un tel cas, c'est l'une des moins mauvaises solutions.
Mais c'est vrai : c'est sale.

(Pourquoi ça marche : car le polynôme caractéristique de la matrice de compagnon associé et (-1)^n * le polynôme dont tu cherches les racines. Les valeurs propres annulent le polynôme caractéristique et tes racines annule ton polynôme. Les valeurs propres annulent donc ton polynôme. Et vice-versa.)

[acx01b]

on parlait de la même chose: dans la librairie gsl ils appellent ça "balanced qr reduction of the companion matrix"

[FR119492]

Salut à tous !

Désolé, mais j'arrive seulement maintenant à la question que j'aurais dû poser dès le début: pourquoi vouloir résoudre une équation du quatrième degré ? Même si ça a l'air idiot, je pense que c'est fondamental.

Jean-Marc Blanc