You are on page 1of 14

UNIVERSITE de BRETAGNE du SUD Ecole Nationale Supérieure Des Ingénieurs De Bretagne Du Sud

Compte Rendu TP1 : Analyse Numérique

 AL ECHCHEIKH EL ALOUI Adnane
Réalisé par

Année Universitaire 2010/2011

Encadré par

 Mr Coer J

Exercice n°1 : Création de scripts et manipulation d’objets matriciels
Méthode optimisée (temps d’exécution est presque nul) U=[1:2:13];V=[2:2:14]; >> U'*V ans = 2 4 6 8 10 12 14 6 12 18 24 30 36 42 10 20 30 40 50 60 70 14 28 42 56 70 84 98 18 36 54 72 90 108 126 22 44 66 88 110 132 154 26 52 78 104 130 156 182 Méthode itérative (le temps d’exécution 0.0160s) %permet enregistre l'heure de debut de l'exécution Tstart=cputime; M=U*V; Tstop=cputime; %permet enregistre l'heure de la fin de l'exécution disp('M='); disp(M); %c'est une façon d'afficher le résultat on affiche d'abord le texte Mopti = puis le résultat DELAY=abs(Tstop-Tstart); function [iterative]=produit(U,V) U=[1:2:13]; V=[2:2:14]; for i=1:1:7 for j=1:1:7 M(i,j)=(U(i))*V(j) end end Résolution de problème X=M/F >> X=M/F X= 0.8205 2.4615 4.1026 5.7436 7.3846 9.0256 10.6667 ans = 2 4 6 12 10 20 14 28 18 36 22 44 26 52

 Partie 1 : Premiers contacts avec Matlabe

6 8 10 12 14 18 24 30 36 42 30 40 50 60 70 42 56 70 84 98 54 72 90 108 126 66 88 110 132 154 78 104 130 156 182

Remarque : On remarque clairement que la méthode Optimisée et plus rapide de la méthode itérative Exercice n°2 : Utilisation des fonctions
function y = fonction_f(x) y = x.^2 +3*x-4; >> fonction_f(-4) ans = 0 Corroborer ces résultats >> y = inline('x^2 +3*x-4') y= Inline function: y(x) = x^2 +3*x-4 >> fonction_f(-3/2) ans = -6.2500 >> fonction_f(1) ans = 0

Remarque :

Pour définir des fonctions dépendantes d’un ou plusieurs paramètres nous utilisons la fonction inline Exercice n°3 : Utilisation des objets graphiques
DX=1; x=[-20:DX:20];

figure(1) y=fonction_f(x); plot(x,y,'-sb') xlabel('abscisse','FontSize',15,'FontName','arial'); ylabel('ordonnée','FontSize',11,'FontName','times'); legend('courbe test'); title('exercice sur les graphiques');

La méthode de dichotomie un algorithme de recherche d'un zéro d'une fonction qui consiste à répéter des partages d’un intervalle en deux parties puis à sélectionner le sous-intervalle dans lequel existe un zéro de la fonction. function [RACINE,NITE]=dichotomie(a,b,EPSILON) fa=f(a); fb=f(b); RACINE=(a+b)/2; NITE=0; if (fa*fb>0) RACINE=-Inf; return; end; while (b-a)>EPSILON NITE=NITE+1; RACINE=(a+b)/2; fx=f(RACINE); if(sign(fx)==sign(fa)) a=RACINE; fa=fx; else b=RACINE; fb=fx; end; end; %déclaration de fonction function y=f(x) y=x^2-3*x-4;

Méthode dichotomie

 Partie 2 : Résolution d’équations

Remarque :

Dans cette exempte la fonction f(x) est déclaré dans le fichier dichotomie.m Mais il est possible aussi d’utiliser str2func('fonction_f'); pour appeler f(x) a partir d’un autre fichier donc on peut écrire :

function [racine,NITER] = dichotomie(A,B, epsi, NMAX) % appelle de fonction str2func('fonction_f'); NITER=0; precis=1; for i=1:1:NMAX NITER=NITER+1; while (fonction_f(A)*fonction_f(B)<0)&&(precis>epsi) nd x=(A+B)/2; if(fonction_f(A)*fonction_f(x)<0) A=A; B=x; else A=x; B=B; end precis=abs((B-A)/(2*x)); end e x

C’est l’algo utiliser dans Q1 et Q2 Méthode newton

L'algorithme consiste à linéaires une fonction f en un point et à prendre le point d'annulation de cette linéarisation comme approximation du zéro recherché. On réitère cette procédure en l'approximation obtenue. Dans les cas favorables, les approximations successives obtenues convergent avec une vitesse quadratique. De manière informelle, le nombre de décimales correctes double à chaque étape. function [x,nb]=newton(x0,eps) err=1; xt=x0;x=x0; nb=0; while (err>eps) nb=nb+1; x=x-f(x)\df(x); err=norm(x-xt); xt=x; end function y=f(x) y=x^2-3*x-4; function y=df(x) y=2*x+3;

>> dichotomie(-3/2,-100,0.0001,1000) x= -4.0002

Ici on doit déclarer la fonction f(x) mais aussi ça drivée df(x) Q1) vérification de R1

>> dichotomie(-3/2,100,0.0001,1000) x= 0.9999

Q2) vérification de R2

>> [x,nb]=newton(-1.5,0.0001) x= -1.5000

Q3) si on remplace x0 par -1.5 on tombe directement sur x Q4)

Avec la fzero(inline('x.^2+3*x-4'),x0) 0.0 360s Pour le calcule de temps dans un des algo on ajoute t0 = cputime; fonction…. t1= cputime; t2=t1-t2 Si non on utilise REPS = 1000; ; tic; ici fonction averageTime = toc/REPS pour le nombre d’itération exemple Tdeb_dicho=cputime; %enregistrement de l’heure de début de l’execution de la fonction [racine_dicho,niter_dicho]=dichotomie(a,b,epsilon,nmax,str2func('fonction_f')); Tfin_dicho=cputime; %enregistrement de l’heure de la fin de l’execution de la fonction T= Tfin_dicho-Tdeb_dicho

>> [x,nb]=newton(-16.5,0.01) x= -1.5024 nb = 111

Q1) Ecriture de fonction qui permet de calculer la table des différences divisées
function [tab]=diff_div1(N,x,y) n=N+1 tab=zeros(n,n) for k=1:n tab(k,1)=y(k) end for j=2:n for i=j:n tab(i,j)=(tab(i,j-1)-tab(i-1,j-1))/(x(i)-x(i-j+1)) end end t=diag(tab) fi=t'

 Partie 3 : Interpolation & Approximation polynomiales

diff_div1(3,X,Y) ans =

Q2) On a n=3 et >> X=[-3,-1,1,3] >> Y=[-27,-1,1,27] -27 0 0 0 -1 13 0 0 1 1 -3 0 27 13 3 1

Q3)Fonction polynôme
mult=1; for i=2:N+1 mult=mult.*(U-X(i-1)); PN=PN+A(i)*mult; end

function [PN] = polynome(N,U,A,X) PN=A(1);

Q4) N=4; X=[-3;-1;1;3]; U=[-10:1:10];

A=[-27;13;-3;1]

PN=polynome(N,U,A,X) figure(1) hold on g=inline('x.^3'); plot(U,PN,'-sr',U,g(U),':*b')

Représentation graphique

Interpolation polynomiale de Lagrange-Phénomène de Runge Q5) fonction échantillonnage
function [x] = echantillonnage(n,borneinf,bornesup) dif=bornesup-borneinf; for i=0:1:n x(i+1)=borneinf+dif*i/n; end

Q6)fonction_runge Q7)

function [y] = fonction_runge(x) y=1./(1+50*x.*x);

Y=fonction_runge(X); Arunge2=diag(diff_div(N,X,Y)) U=[-1:0.01:1]'; p2=polynome(N,U,Arunge2,X); figure(2) plot(U,p2,U,fonction_runge(U))

N=2

N=9

N=24

Q9)les évolutions de l’ordre n

N=2; Arunge2=diag(diff_div(N,X,Y)); pn=polynome(N,U,Arunge2,X); e=abs(fonction_runge(U)-pn); figure(3) plot(U,e)

Pour n=2

function S=racines_tchebychef(N) for I=0:N ARG=(pi/2)*(2*I+1)/(N+1); S(I+1)=cos(ARG); end

Recours aux points d’interpolation de Tchebychev Q10)

Q11) N=2 N=9

N=24

>> S=racines_tchebychef(2) S= 0.8660 0.0000 -0.8660 >> S=racines_tchebychef1(9) S= Columns 1 through 7 0.9877 0.8910 0.7071 0.4540 0.1564 -0.1564 -0.4540 Columns 8 through 10

-0.7071 -0.8910 -0.9877 >> S=racines_tchebychef1(24) S= Columns 1 through 7 0.9980 0.9823 0.9511 0.9048 0.8443 0.7705 0.6845 Columns 8 through 14 0.5878 0.4818 0.3681 0.2487 0.1253 0.0000 -0.1253 Columns 15 through 21 -0.2487 -0.3681 -0.4818 -0.5878 -0.6845 -0.7705 -0.8443 Columns 22 through 25

Une approximation au sens des moindres carrés Q15) x=[0.0 212 507 698 992 1200]'; y=[0.0 42.7 109.2 151.9 193.3 235.4]'; Q16)

-0.9048 -0.9511 -0.9823 -0.9980

function[SORTIE]=approximation(X,Y,degre) Nech=length(X); K=degre; M=zeros(K+1); B=zeros(K+1,1); if length(Y)~=Nech disp('vecteurs de tailles differentes:abandon'); return end for I=1:K+1 for J=1:K+1 M(I,J)=sum(X.^(I+J-2)); end end for I=1:K+1 B(I)=sum(X.^(I-1).*Y); end SORTIE=M\B;

Q17)

function[POLYNOME]=polynome_approximation(A,X) N=length(A); POLYNOME=A(1); for K=2:N POLYNOME=POLYNOME+A(K)*X.^(K-1); end

function f=f(x); f=x.^6;

 Partie 4 : Intégration Numérique

méthode : méthode du trapèze
%fonction : f=x.^6;

function [inum,delay]=trapez(fonction_f,a,b,n);

% a et b : les borne de l’intervalle % n : le nombre de point

delay=Ts

Ts1=cputime*1e6; n=n; hold off; h=(b-a)/n; x=a+(0:n)*h; f=feval('fonction_f',x); inum=h/2*(f(1)+f(n+1)); Ts2=cputime*1e6;
% pour donner le temps d’exécution

if n>1 inum=inum+sum(f(2:n))*h end h2=(b-a)/100; xc=a+(0:100)*h2; fc=feval('fonction_f',xc);
%presentation

plot(xc,fc,'r'); hold on; title('Méthode des trapèzes'); xlabel('x'); ylabel('y'); grid on; plot(x,f,'m'); plot(x,zeros(size(x)),'c') for i=1:n; plot([x(i),x(i)],[0,f(i)],'g'); end

[inum,delay]=trapez('fonction_f',1,1,20); inum = 0.1000 delay = 140000

Nombre de point 20

inum =0.0100

Nombre de point 200

delay =1.5600e+005

Nombre de point 2000 inum =0.0010 delay = 16000

Première méthode :méthode du point milieu A=BORNEINF; B=BORNESUP; N=NBPOINT; H=abs(B-A)/(N-1); X=[A:H:B]; Ts=cputime*1e6

function [INUM,DELAY]=point_milieu(BORNEINF,BORNESUP,NBPOINT,NOMFONCTION)

Y=NOMFONCTION(X); Ydemi=NOMFONCTION(X([1:N-1]+H/2); Ts=cputime*1e6; INUM=H*sum(Ydemi); DELAY=cputime*1e6-Ts;

function[INUM,DELAY]=simpson(BORNEINF,BORNESUP,NBPOINT,NOMFONCTION) A=BORNEINF; B=BORNESUP. N=NBPOINT; H=abs(B-A)/(N-1); X=[A:H:B]; Ts=cputime*1e6; Y=NOMFONCTION(X); Ydemi=NOMFONCTION(X([1:N-1])+H/2); Ts=cputime*1e6; INUM=H/6*(2*sum(Y)-Y(1)-Y(N)+4*sum(Ydemi)); DELAY=cputime*1e6-Ts;

Deuxième méthode : méthode de Simpson

Plus l'ordre de la méthode est grand, plus la précision est bonne