Vous êtes sur la page 1sur 14

UNIVERSITE de BRETAGNE du SUD Ecole Nationale Suprieure Des Ingnieurs De Bretagne Du Sud

Compte Rendu TP1 : Analyse Numrique

AL ECHCHEIKH EL ALOUI Adnane


Ralis par

Anne Universitaire 2010/2011

Encadr par

Mr Coer J

Exercice n1 : Cration de scripts et manipulation dobjets matriciels


Mthode optimise (temps dexcution 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 Mthode itrative (le temps dexcution 0.0160s) %permet enregistre l'heure de debut de l'excution Tstart=cputime; M=U*V; Tstop=cputime; %permet enregistre l'heure de la fin de l'excution disp('M='); disp(M); %c'est une faon d'afficher le rsultat on affiche d'abord le texte Mopti = puis le rsultat 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 Rsolution de problme 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 mthode Optimise et plus rapide de la mthode itrative Exercice n2 : Utilisation des fonctions
function y = fonction_f(x) y = x.^2 +3*x-4; >> fonction_f(-4) ans = 0 Corroborer ces rsultats >> 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 dnir des fonctions dpendantes dun ou plusieurs paramtres nous utilisons la fonction inline Exercice n3 : 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('ordonne','FontSize',11,'FontName','times'); legend('courbe test'); title('exercice sur les graphiques');

La mthode de dichotomie un algorithme de recherche d'un zro d'une fonction qui consiste rpter des partages dun intervalle en deux parties puis slectionner le sous-intervalle dans lequel existe un zro 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; %dclaration de fonction function y=f(x) y=x^2-3*x-4;

Mthode dichotomie

Partie 2 : Rsolution dquations

Remarque :

Dans cette exempte la fonction f(x) est dclar dans le fichier dichotomie.m Mais il est possible aussi dutiliser str2func('fonction_f'); pour appeler f(x) a partir dun 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

Cest lalgo utiliser dans Q1 et Q2 Mthode newton

L'algorithme consiste linaires une fonction f en un point et prendre le point d'annulation de cette linarisation comme approximation du zro recherch. On ritre cette procdure en l'approximation obtenue. Dans les cas favorables, les approximations successives obtenues convergent avec une vitesse quadratique. De manire informelle, le nombre de dcimales 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 dclarer la fonction f(x) mais aussi a drive df(x) Q1) vrification de R1

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

Q2) vrification 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 ditration exemple Tdeb_dicho=cputime; %enregistrement de lheure de dbut de lexecution de la fonction [racine_dicho,niter_dicho]=dichotomie(a,b,epsilon,nmax,str2func('fonction_f')); Tfin_dicho=cputime; %enregistrement de lheure de la fin de lexecution 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 diffrences divises
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 polynme
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')

Reprsentation graphique

Interpolation polynomiale de Lagrange-Phnomne 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 lordre 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 dinterpolation 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 carrs 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 : Intgration Numrique

mthode : mthode du trapze


%fonction : f=x.^6;

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

% a et b : les borne de lintervalle % 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 dexcution

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('Mthode des trapzes'); 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

Premire mthode :mthode 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;

Deuxime mthode : mthode de Simpson

Plus l'ordre de la mthode est grand, plus la prcision est bonne

Vous aimerez peut-être aussi