UNIVERSITE de BRETAGNE du SUD

Ecole Nationale Supérieure Des Ingénieurs De Bretagne Du Sud

Compte Rendu TP1 : Analyse Numérique

Réalisé par Encadré par

AL ECHCHEIKH EL ALOUI Adnane

Mr Coer J

Année Universitaire 2010/2011

Partie 1 : Premiers contacts avec Matlabe 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

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

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

On remarque clairement que la méthode Optimisée et plus rapide de la méthode itérative Remarque :

Exercice n°2 : Utilisation des fonctions

function y = fonction_f(x) y = x.^2 +3*x-4; >> fonction_f(-4) ans = 0

>> fonction_f(-3/2) ans = -6.2500

>> fonction_f(1) ans = 0

Corroborer ces résultats

>> y = inline('x^2 +3*x-4') y = Inline function: y(x) = x^2 +3*x-4

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');

Partie 2 : Résolution d’équations 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.

Méthode dichotomie

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;

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

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.

Méthode newton

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;

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 = -4.0002

Q2) vérification de R2 >> dichotomie(-3/2,100,0.0001,1000) x = 0.9999

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

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

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

Partie 3 : Interpolation & Approximation polynomiales 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'

Q2) On a n=3 et >> X=[-3,-1,1,3] >> Y=[-27,-1,1,27] diff_div1(3,X,Y) ans = -27 0 0 0 -1 13 0 0 1 1 -3 0 27 13 3 1 Q3)Fonction polynôme function [PN] = polynome(N,U,A,X) PN=A(1); mult=1; for i=2:N+1 mult=mult.*(U-X(i-1)); PN=PN+A(i)*mult; end 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 function [y] = fonction_runge(x) y=1./(1+50*x.*x); Q7) 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

Pour n=2

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)

Q10) Recours aux points d’interpolation de Tchebychev

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

S = 0.8660 0.0000 -0.8660

N=9 >> 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

N=24 >> 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

-0.9048 -0.9511 -0.9823 -0.9980

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) 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

Partie 4 : Intégration Numérique function f=f(x); f=x.^6;

méthode : méthode du trapèze

function [inum,delay]=trapez(fonction_f,a,b,n); %fonction : f=x.^6;

% a et b : les borne de l’intervalle % n : le nombre de point 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; delay=Ts % 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

Nombre de point 20

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

Nombre de point 200

inum =0.0100 delay =1.5600e+005

inum =0.0010 Nombre de point 2000

delay = 16000

Première méthode :méthode du point milieu

function [INUM,DELAY]=point_milieu(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*sum(Ydemi); DELAY=cputime*1e6-Ts;

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

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; Plus l'ordre de la méthode est grand, plus la précision est bonne