Concludiamo questa Appendice, riportando alcuni programmi scritti in linguaggio

Transcript

1 0.1. PROGRAMMI MATLAB Programmi MATLAB Concludiamo questa Appice, riportando alcuni programmi scritti in linguaggio MATLAB, relativi ad algoritmi visti nei capitoli del Testo. Il lettore è incoraggiato, oltre che a provarli, a modificarli per ottenere delle versioni più generali. 1. Capitolo 2: Metodo di Bisezione function [xs,scarto,iter,x] = bisezione(fname, a, b, toll, nmax) Metodo di bisezione per calcolare la radice di una equazione f(x)=0. Sintassi: [xs,scarto,iter,x] = bisezione(fname,a,b,toll) fname : stringa che contiene il nome della funzione f(x) a,b : definiscono l intervallo [a,b], f(a)f(b) <= 0 toll : tolleranza prefissata (sullo scrto) nmax : numero mssimo di iterazioni x : successione x(iter) convergente alla radice x*, t.c. f(x*)=0 xs : approssimazione finale della radice scarto: ampiezza dell intervallo ESEMPIO fname = inline( exp(-2*x)+x-1 ); a=0.65; b=0.8; toll=1.e-06; nmax=100; format long [xs,scarto,iter,x]= bisezione(fname,a,b,toll,nmax); FINE ESEMPIO x(1) = a; x(2) = b; fa = feval(fname,a); fb = feval(fname,b); scarto = abs(b-a); if fa*fb > 0 la funzione assume in entrambi gli estremi dell intervallo [a,b] valori dello stesso segno. disp( L intervallo iniziale non e accettabile ) iter = []; x = []; xs = []; else

2 2 inizio il ciclo iterativo iter = 0; while ( scarto>=toll & iter<nmax ) calcolo una nuova approssimazione iter = iter+1; x(iter) = (a+b)/2; fxk = feval(fname,x(iter)); if fa*fxk <=0 b = x(iter); else a = x(iter); fa = fxk; scarto = abs(b-a); xs = (a+b)/2;

3 0.1. PROGRAMMI MATLAB 3 2. Capitolo 2: Metodo di Newton-Raphson function[xs,x,scarti,rapp,m]=n_raphson(fname,f1name,f2name,x0,toll,maxi) Metodo di Newton-Raphson per calcolare la radice di una equazione non lineare f(x)=0 mediante costruzione di una successione {x(k)} convergente alla radice x ( x(0) stima iniziale assegnata ). Caso della radice semplice. Modificare il codice nel caso di radici multiple. Sintassi [xs,x,scarti,rapp,m]=n_raphson(fname,f1name,f2name,x0,toll,maxi) fname : stringa che contiene il nome della funzione f(x) f1name: stringa che contiene il nome della derivata prima f (x) f2name: stringa che contiene il nome della derivata seconda f (x) x0 : approssimazione iniziale della radice toll : criterio di arresto (sullo scarto) x(k+1)-x(k) < toll maxi : numero massimo di iterazioni xs : approssimazione finale della radice x : successione x(k) convergente a x, t.c. f(x)=0 scarti: vettore degli scarti d(k), k=1,... rapp : stime della costante asintotica M attraverso gli scarti M : stima finale di M usando la f (x) e la f (x) ESEMPIO fname = inline( x- exp(-x) -0.5*cos(x) ); f1name = inline( 1+exp(-x) +0.5*sin(x) ); f2name = inline( - exp(-x) +0.5*cos(x) ); x0 = 0.5; toll = 1.e-06; maxi = 50; [xs,x,scarti,rapp,m]=n_raphson(fname,f1name,f2name,x0,toll,maxi) FINE ESEMPIO scarti0 = 1.0e5; x(1) = x0; fxk = feval(fname,x0); f1xk = feval(f1name,x0); k = 0; scarto = 2*toll; while ( scarto >= toll & k < maxi )

4 4 calcolo una nuova stima della radice k = k+1; x(k+1) = x(k)-fxk/f1xk ; scarti(k) = abs(fxk/f1xk); rapp(k) = scarti(k)/scarti0^2; fxk = feval(fname,x(k+1)); f1xk = feval(f1name,x(k+1)); scarto = abs(x(k+1)-x(k)); if abs(f1xk) < toll*abs(fxk) derivata prima troppo piccola ==> esco dalla routine error( La derivata f (x(d)) e nulla,k); scarti0 = scarti(k); xs = x(k+1); f1xk = feval(f1name,xs); f2xk = feval(f2name,xs); M = 0.5*abs(f2xk/f1xk);

5 0.1. PROGRAMMI MATLAB 5 Il seguente script (mainnewton.m) illustra come richiamare un sottoprogramma (la function N Raphson.m, vedi esempio 2), da un programma principale (main). Esso fa uso del Symbolic Math Tool di MATLAB. In particolare, usa la funzione diff per calcolare derivate di funzioni, utile nel caso del metodo di Newton-Raphson. 2. Capitolo 2: Metodo di Newton-Raphson mainnewton: script di chiamata (programma main) alla function N_Raphson.m Usa la funzione diff del Symbolic Math Tool, per calcolare derivate di funzioni. Nell esempio, la derivata di: x - exp(-x) - 0.5*cos(x) sym: costruisce variabili simboliche char: crea stringhe di caratteri func = sym( x- exp(-x) -0.5*cos(x) ); dfunc = diff(func); d2func = diff(dfunc); creazione delle funzioni di input fname = inline(char(func)); f1name = inline(char(dfunc)); f2name = inline(char(d2func)); parametri di input x0 = 0.5; toll = 1.e-06; maxi = 50; chiamata della function N_Raphson.m [xs,x,scarti,rapp,m]=n_raphson(fname,f1name,f2name,x0,toll,maxi)

6 6 3. Capitolo 2: Metodo di Punto fisso function [xs, x, scarto, rapp, n] = pfisso(gname,x0,toll,nmax) Metodo di punto fisso per calcolare la radice della equazione f(x)=0, opportunamente riscritta come x = g(x). Sintassi: [xs, x, scarto, rapp, n]= pfisso(gname, x0, toll, nmax) gname : stringa che contiene il nome della funzione g(x) x0 : approssimazione iniziale della radice toll : tolleranza associata al criterio di arresto (sullo scarto) nmax : numero massimo di iterazioni xs : approssimazione finale della radice x : vettore delle iterate (approssimazioni della radice) scarto: scarto x(n)-x(n-1) rapp : stima finale della costante asintotica tramite gli scarti n : numero di iterazioni impiegate per arrivare a convergenza : (esclusa quella iniziale) ESEMPIO gname = inline( (x+1).^(1/3) ); x0 = 0.5; toll = 1.e-6; nmax = 100; [xs, x, scarto, rapp, n] = pfisso(gname, x0, toll, nmax) FINE ESEMPIO scarto0 = 1.0e5; scarto = 2*toll; x = zeros(nmax); x(1) = x0; n = 1; while ( scarto > toll & n < nmax ) calcolo della iterata (n+1)-esima n = n + 1; x(n) = feval(gname, x0); scarto = abs( x(n)-x0 ); rapp = scarto/scarto0; x0 = x(n); scarto0 = scarto; xs = x(n); x = x(1:n); n = n-1;

7 0.1. PROGRAMMI MATLAB 7 4. Capitolo 3: Metodi iterativi per sistemi lineari ***************************************************************** function seidel.m ***************************************************************** Soluzione di un sistema lineare mediante il metodo iterativo di Gauss-Seidel. Si veda alla fine della sezione??. Per esercizio, si modifichi la function seidel.m modo da implementare i metodi di Jacobi ed SOR.

8 8 5. Capitolo 5: Polinomio di interpolazione di Newton function [fx0, F] = interp_newton(m, x, fx, x0, n) Input: numero m di nodi, loro ascisse x, ordinate fx, il punto x0, grado n del polinomio interpolante: n=[0,...,m-1]. Output: tabella delle differenze divise F e valore fx0 del polinomio interpolante di Newton in x0 Sintassi: [fx0, F]=interp_newton(m, x, fx, x0, n); ESEMPIO m=5; n=4; x0=0.31; x = [ ]; fx = [ ]; [fx0, F]=interp_newton(m, x, fx, x0, n); Si ottiene: fx0 = F = FINE ESEMPIO Porre la variabile di stampa = 1 (uno) per avere una stampa a video della tabella F delle differenze divise e del valore fx0 del polinomio interpolante nel punto x0. stampa = 1; Costruzione della tabella delle differenze divise (in una matrice F triangolare superiore). F = zeros(m); for i=1:1:m F(i,i)=fx(i); for j=2:1:m for i=(j-1):(-1):1 F(i,j)=(F((i+1),j)-F(i,(j-1)))/(x(j)-x(i));

9 0.1. PROGRAMMI MATLAB 9 Vettore PROD (di grado m)=[1,(x0-x(1)),...(x0-x(m-1)]. prod(1)=1; for j=2:1:m prod(j)=(x0-x(j-1))*prod(j-1); fx0=fx(1); for j=2:1:(n+1) fx0=fx0+f(1,j)*prod(j); if stampa eventuale stampa dei risultati ottenuti disp([ m=,num2str(m), n=, num2str(n)]) disp( ) disp( tabella delle differenze divise F= ) disp( ) disp(f) disp([ valore del polinomio di grado n=,num2str(n),,fx0=,num2str(fx0)])

10 10 6. Capitolo 6: Metodo di integrazione di Romberg mainromberg: script di chiamata (programma main) alla function romb.m (integrazione di Romberg). romb.m chiama a sua volta la function trap.m Esempi test tratti dal Testo, cap. 6. funzione da integrare fname = inline( log(x) ); estremi di integrazione a = 1; b = 2; funzione da integrare fname = inline( log(1+x.^4) ); estremi di integrazione a = 0; b = 4; numero (massimo) di sottointervalli n = 2^m m = 7; chiamata alla function di integrazione romb.m [I, Idiag, tab] = romb(fname, a, b, m); stampa della tabella su file di testo: risromberg.txt fid = fopen( risromberg.txt, w ); for i = 1:m+1 fprintf(fid, 5i,i); for j=1:i fprintf(fid, 12.8f,tab(i,j)); fprintf(fid, \r\n ); fclose(fid); grafico della diagonale e della 1 colonna plot(1:m+1,idiag, r, 1:m+1,tab(:,1), b ) hold on plot(1:m+1,idiag, rs, 1:m+1,tab(:,1), bs ) leg( Romberg, trapezi ) grid on hold off

11 0.1. PROGRAMMI MATLAB 11 romb.m: quadratura mediante la formula di Romberg function [I, Idiag, tab] = romb(fname, a, b, m) Sottoprogrammi chiamati: trap.m Sintassi: [I,Idiag,tab] = romb(fname, a, b, m) calcola un approssimazione dell integrale della funzione fname sull intervallo [a,b] mediante la formula di integrazione di Romberg. Il numero massimo di sottointervalli in cui è suddiviso l intervallo [a,b] è 2^m, m >= 0. I e la migliore approssimazione disponibile per l integrale, tab e una matrice (m+1)x(m+1) che contiene la tabella delle approssimazioni di Romberg, Idiag e un vettore di dimensione (m+1) che contiene la diagonale di tab. Gli elementi della matrice tab che non sono calcolati nella approssimazione di Romberg contengono dei NaN. inizializzazione della tabella tab = NaN*ones(m+1); idiag = zeros(m+1,1); calcolo della prima colonna della tabella n = 1; for i = 1:m+1 I = trap(fname,a,b,n); tab(i,1) = I; n = 2*n; Idiag(1) = tab(1,1); calcolo delle successive righe della tabella for h = 2:m+1 for k = 2:h tab(h,k) = ( 4^(k-1)*tab(h,k-1)-tab(h-1,k-1) )/(4^(k-1)-1); Idiag(h) = tab(h,h); migliore approssimazione disponibile per l integrale I = Idiag(m);

12 12 trap.m: quadratura mediante la formula dei trapezi function I = trap(fname, a, b, m) Sintassi: I = trap(fname, a, b, m) Calcola una approssimazione dell integrale della funzione fname sull intervallo [a,b] mediante la formula di integrazione dei trapezi composta. Usa (m + 1) punti equispaziati in [a,b]. h = (b-a)/m; xk = linspace(a,b,m+1); fxk = feval(fname,xk); I = h*( 0.5*fxk(1) + sum(fxk(2:m)) + 0.5*fxk(m+1));

13 0.1. PROGRAMMI MATLAB Capitolo 7: Metodo di integrazione di Eulero ***************************************************************** function euler.m sottoprogramma chiamato: eulero.m ***************************************************************** Metodo di integrazione di un equazione differenziale, mediante il metodo di Eulero in avanti. Si veda l ultimo esempio riportato in sezione??. Per esercizio, implementare altri metodi di integrazione (Eulero indietro, trapezi, punto medio, ecc...), modificando la subfunction chiamata eulero.m.