Anda di halaman 1dari 8

LES ALGORITHMES DAPPROXIMATION

INTRODUCTION :
Les algorithmes dapproximation peuvent tre utiliss pour dterminer les valeurs
approches de la solution de certains problmes dont on ne peut pas dterminer la valeur
exacte de la solution.
Dans certains problmes la variation du pas amne un ensemble de solutions ralisables,
nanmoins il existe toujours une meilleur solution.
Un problme doptimisation consiste trouver la meilleure solution dite optimale dans
un ensemble de solutions ralisables.
ICALCUL DE VALEURS APPROCHEES DE CONSTANTES CONNUES
Dans cette partie du chapitre, nous allons prsenter des algorithmes permettant de calculer des
valeurs approches pour les constants :
pi
e
1) calcul de pi

Voici quelques formules permettant de calculer avec plus ou moins de vitesse.


Formule de Leonhard Euler (1707-1783)
2

= 6 * (1 + 1/22 + 1/32 + 1/42 + 1/52 ......)

Dveloppement en srie de arctg x avec x=1


Gregory 1638- 1675)

(W.Leibniz 1646-1716 ou James

= 4 * (1 - 1/3 + 1/5 - 1/7 + 1/9 ......)


Formule de John Wallis (1616-1703)
= 2 * (2/1 * 2/3 * 4/3 * 4/5 * 6/5 * 6/7 * ...)
********************************************************
program calcul_pi;
USES wincrt;
const
EPS=1E-10;
VAR
S,Si, P,Pi : real;
i : LONGINT;
Signe : SHORTINT;
{==========================================}
procedure EULER(var s :real);
BEGIN
S:=0;

i:=0;

Si:=1;

WHILE (Si>=eps) DO
BEGIN
i:=i+1;
Si:=1/SQR(i);
S:=S+Si;
END;
S:=SQRT(S*6);
WRITELN('Par la formule de Euler (',i,' termes):
end;

{==================
===================
=====}
procedure DEv_ARCG(var
s :real);
BEGIN
S:=0;i:=-1;Si:=1;Signe:=-1;
WHILE (Si>1E-6) DO
BEGIN
i:=i+2;
Si:=1/i;
Signe:=-Signe;
S:=S+Si*Signe;
END;
S:=4*S;
WRITELN('Par dvelop en srie
de arctg x avec x=1 (',i DIV 2,'
termes): ',S:9:7);
end;

',S:9:7);

{=========================================}
procedure Wallis(var p :real);
var dif:real;
BEGIN
p:=1;i:=0;dif:=1;
WHILE (dif>=1E-8) DO
BEGIN
i:=i+2;
pi:=SQR(i)/((i-1)*(i+1));
dif:=ABS(p*pi-p);
p:=p*pi;
END;
p:=p*2;
WRITELN('Par la formule de Wallis (',i DIV 2,' termes):
',p:9:7);

writeln('============
=============');
EULER(s);
DEV_ARCG(s);
WALLIS(p);
end.

end;
{==============================}
BEGIN
writeln('p=3.141 592 653 589 793
238.............................................');

La mthode des trapzes permet de calculer avec une certaine prcision


En appliquant la formule suivante :

program calcule_air_rectangle_trapeze;
uses wincrt;
var
a,b:real;
n:integer;
{=================================}
procedure Lecture ( var a,b:real; var n:integer);
begin
write(' taper la borne infrieur: '); readln(a);
repeat
write(' taper la borne suprieur: '); readln(b);
until (b>a);
repeat
write(' taper le nombre d''intervalles: '); readln(n);
until (n>0);
end;
{===============================}
Function f (x:real):real;
begin
f:=
;
end;
{===============================}
Function rectangles ( a,b:real;n:integer):real;
var
som,h,x:real;
k:integer;
begin
som:=0;
h:=(b-a)/n; { h est la largueur d'un intervalle}
x:=a+h/2; { pourquoi h/2}
for k:=1 to n do
begin
som:=som+f(x);
x:=x+h;
end;
rectangles:=som*h;
end;
{================================}
Function trapezes (a,b:real;n:integer):real;
var
k:integer;
h,x,som:real;
begin
h:=(b-a)/n;
{ largueur d'un intervalle}
som:=(f(a)+f(a+h))/2;
x:=a;
for k:=1 to n-1 do
begin
x:=x+h;
som:=som+(f(x)+f(x+h))/2;
end;
trapezes:=h*som;
end;
{================================}
BEGIN
repeat
Lecture (a,b,n);
writeln(' calcul air :meth des rectangles=
',rectangles(a,b,n):9:8);
writeln(' calcul air :meth des trapzes=

program integral;
uses wincrt;
var
h,a,b,j:real;
n:integer;
{===============================}
Function f (x:real):real;
begin
f:=
;
end;
{===============================}
Function somme (a,b:integer):real;
var
x,s:real;
i:integer;
begin
s:=0;
for i:=a to b do
begin
s:=s+F(1+i*h);
end;
somme:=s;
end;
{===============================}
procedure saisie (var x:real; var y:integer);
begin
repeat
write (' taper un rel > ',a:5:2, ' '); readln(x)
until (x>=a);
repeat
write (' taper le nombre d''intervalles '); readln(y)
until (y>0);
end;
{===============================}
begin
a:=1;
saisie (b,n);
h:= (b-a)/n;
j:=h*( (f(a)+f(b))/2 +somme(1,n-1));
writeln (' la valeur de l''intgrale = ', j:9:2);

end.

',trapezes(a,b,n):9:8);
until keypressed;
end.

Remarque : il existe dautres formules bases sur le dveloppement en srie pour


calculer une valeur approche de

Exemples :

Dveloppement en srie de arctgx avec x=1

/4 =

i=1

(-1)i-1/(i-1)*2+1

=4*(1-1/3+1/5-1/7+1/9) =4*
Dveloppement en srie de arctgx avec x=3/3
=2*3*(1-1/3*1/31+1/5*1/32-1/7*1/33+)

Formule de John Machin partir de arctg 1/5-1/239

=16*(1/5 -1/3*1/53 + 1/5*1/55 - 1/7*1/57 +.)- 4*(1/2391-1/3*1/2393+ 1/5*1/2395 1/7*1/2397 +.)

Formule de Franois Vite :


2/=(1/2)* (1/2+1/2*(1/2))*
1) Calcul de e

La constante de Nper e est dfinie

Application ( travail la maison)


ex = 1 +x/1+x2/2!+x3/3!+ +xn/n!
x

e=

i=0

i
X
i!

Ecrire un programme pascal permettant de calculer puis dafficher la valeur


approche de ex en faisant appel aux fonctions factoriel et puissance.
IIRECHERCHE DUN POINT FIXE DUNE FONCTION
En mathmatiques, pour une application f dun ensemble E, un lment X de E est un
point fixe de f si f(x)=x.
Soit la suite (Un) rcurrente dfinie par : U0 et Un+1= f(Un).
Si Un converge alors un converge vers un point fixe de f.
Dans la suite nous allons crire lalgorithme dun programme PT_FIXE qui permet de trouver
la valeur du point fixe et le nombre ditrations pour le trouver.
Exp : f(x)=sin(x)=1-x
Algo du PP
0) dbut PT_FIXE
1) i0, Xact1
2) Rpter
xpreXact
Xactf(Xact)
ii+1
jusqu (ABS(XactXpre)<Epsilon)
3) Ecrire ( pt
fixe= ,Xact, trouv
aprs,i , itrations)
4) Fin PT_FIXE

III-

CALCUL DAIRES

program calcule_air_rectangle_trapeze;
uses wincrt;
var
a,b:real;
n:integer;
{=================================}
procedure Lecture ( var a,b:real; var n:integer);
begin
write(' taper la borne infrieur: '); readln(a);
repeat
write(' taper la borne suprieur: '); readln(b);
until (b>a);
repeat
write(' taper le nombre d''intervalles: '); readln(n);
until (n>0);
end;
{===============================}
Function f (x:real):real;
begin
f:=
;

program integral;
uses wincrt;
var
h,a,b,j:real;
n:integer;
{===============================}
Function f (x:real):real;
begin
f:=
;
end;
{===============================}
Function somme (a,b:integer):real;
var
x,s:real;
i:integer;
begin
s:=0;
for i:=a to b do

end;
{===============================}
Function rectangles ( a,b:real;n:integer):real;
var
som,h,x:real;
k:integer;
begin
som:=0;
h:=(b-a)/n; { h est la largueur d'un intervalle}
x:=a+h/2; { pourquoi h/2}
for k:=1 to n do
begin
som:=som+f(x);
x:=x+h;
end;
rectangles:=som*h;
end;
{================================}
Function trapezes (a,b:real;n:integer):real;
var
k:integer;
h,x,som:real;
begin
h:=(b-a)/n;
{ largueur d'un intervalle}
som:=(f(a)+f(a+h))/2;
x:=a;
for k:=1 to n-1 do
begin
x:=x+h;
som:=som+(f(x)+f(x+h))/2;
end;
trapezes:=h*som;
end;
{================================}
BEGIN
repeat
Lecture (a,b,n);
writeln(' calcul air :meth des rectangles=
',rectangles(a,b,n):9:8);
writeln(' calcul air :meth des trapzes=
',trapezes(a,b,n):9:8);
until keypressed;
end.

Calcul de lintegrale
program integral;
uses wincrt;
var
h,a,b,j:real;
n:integer;
function f (x:real):real;
begin
f:=1/x;
end;
function somme (a,b:integer):real;

begin
s:=s+F(1+i*h);
end;
somme:=s;
end;
{===============================}
procedure saisie (var x:real; var y:integer);
begin
repeat
write (' taper un rel > ',a:5:2, ' '); readln(x)
until (x>=a);
repeat
write (' taper le nombre d''intervalles '); readln(y)
until (y>0);
end;
{===============================}
begin
a:=1;
saisie (b,n);
h:= (b-a)/n;
j:=h*( (f(a)+f(b))/2 +somme(1,n-1));
writeln (' la valeur de l''intgrale = ', j:9:2);

end.

var
s:real;
i:integer;
begin
s:=0;
for i:=a to b do
s:=s+ f(1+i*h);
somme:=s;
end;
procedure saisie (var x:real; var y:integer);
begin
repeat
write (' taper un rel > ',a:5:2, ' '); readln(x)
until (x>=a);
repeat
write (' taper le nombre d''intervalles '); readln(y)
until (y>0);
end;
begin
a:=1;
saisie (b,n);
h:= (b-a)/n;
j:=h*( (f(a)+f(b))/2 +somme(1,n-1));
writeln (' la valeur de l''intgrale = ', j:9:2);
end.