Vous êtes sur la page 1sur 5

Plan de TP

1-But

2-Principe

3-Programme en langue c

4-Algorithme

5-Organigramme

6-L’affichage

7-Conclusion
But :
le problème est de trouver des valeurs approchées des solutions d'une équation F(x) = 0 où est une fonction
non linéaire , le plus souvent continue et dérivable , sur un intervalle I, dans le cas générale ,on utilisation
des méthodes itératives,qui donnent une suite d'approximation successives s’approchant de la solution
exacte.

Principales méthodes de résolutions approchées de f (x)= 0

On considère un intervalle [a, b] et une fonction f continue de [a, b] dans R. On suppose que f(a)*f(b)<0 et

1-La méthode de Newton


La méthode de dichotomie à construire une suite (xn) qui converge vers la racine a de la manière suivant:

Principe:
On prend pour x0 le milieu de intervalle [a, b] (x0 (a+b)/2) .La Racine se trouve alors dans l'un des deux
intervalles] a, x0 [ou]x0, b[ou bien elle est égale à x0.
(1) Si f(x0) 0, c'est la racine de f et le problème est résolu.
(2)Si f(x0), nous regardons le signe de f(a)*f(x0)
(a) Si f(a) *f(x0) <0, alors a[a, x0]
(b) Si f(x0) *f(b) <0, alors a[x, b]

On recommence le processus en prenant l'intervalle [a , x0] au lieu de [a , b] dans le premier cas , et


l'intervalle [x0 ,b] au lieu de [a , b] dans le second cas . De cette manière , on construit par récurrence sur n
trois (an),(bn)et(x0n) telles que a1 a, b1 b et telles que pour tout n> 0,
-Si f(a)*f(x0) <0 alors a ]a , x0[ . On pose a1 = a, b1 = x0.
- Si f(a)*f(x0) =0 alors a = x 0.
-Si f(a)*f(x0)>0 , alors .on pose a1 = x0,b1 = b.
On prend alors pour x1 le milieu de [a1, b1].
On construit ainsi une suit x0 = (a+b)/2, x1 = (a1+b)/2,....xn = (an+b)/2.telle que a-xn< (b-a)/2n+1.
Etant donné une précision £, cette méthode permet d'approcher a en un nombre prévisible d'itérations.
L'algorithme ci-dessus s'appelle algorithme de Newton.
Programme en langue c :
#include<math.h>
#include<stdio.h>
#define f(x) (pow(x,3)-12*pow(x,2)-60*x+46)
#define f1(x) (3*pow(x,2)-24*x-60)
#define f2(x) (6*x-24)
main()
{
float a,b,eps,x1,x0,er;
int i;
scanf("%f%f%f",&a,&b,&eps);
if (f(a)*f2(a)>0)
x0=a;
else
x0=b;
i=0;
do
{
i++;
x1=x0-(f(x0)/f1(x0));
er=fabs(f(x0)/f1(x0));
printf("x0=%f f(x0)=%f er=%f n=%d\n",x0,f(x0),er,i) ;
x0=x1;
}
while (er>=eps);
getchar();
getchar();
}
Algorithme :
var
X,a,b,c,exp , er :reél ;
i: entier ;
f(x)= :x*x*x – 12*x*x -60*x +46 ;
f1(x)= :3*x*x-24*x-60 ;
f2(x)= :6*x-24 ;
debut
lire(a,b,exp) ;
while (er>=exp)
c=(a+b)/2 ;
si f(a)*f(c)<er ;
alors
b=c ;
er=(a-b) ;
sinon
a=c ;
fin si
print(c,c) ;
fin
fin.
Organigramme :

Début

écrier(a,b,exp)

lire(a,b,exp)

tantque non
(er>=ex
p)
écrier(error)

oui

c (a+b)/2

non oui
si
(f(a)*f(c)<er)
b c
er (a-b)
Fin

a c
écrier(c,c)
L’affichage
0.001
X0=1.000000 f(x0)=-25.000000 er=0.308642 n=1

X0=0.691358 f(x0)=-0.886740 er=0.011798 n=2

X0= 0.679560 f(x0)=-0.001382 er=0.000018 n=3

0.000001
X0=1.000000 f(x0)=-25.000000 er=0.308642 n=1

X0=0.691358 f(x0)=-0.886740 er=0.011798 n=2

X0= 0.679560 f(x0)=-0.001382 er=0.000018 n=3

X0= 0.679541 f(x0)=-0.000002 er=0.000000 n=4

0.000000001
Pas d’arête
0.000000000001
Pas d’arête

CONCLUSION :

Résolution de l’équation f(x) =0 par la méthode de Newton est très bien précise à partir de
dichotomie.

Vous aimerez peut-être aussi