Upload
adnaneadnane
View
180
Download
2
Embed Size (px)
Citation preview
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