0.1 Programmi MATLAB

0.1. PROGRAMMI MATLAB 1 

0.1 Programmi MATLAB 

Concludiamo questa Appendice, 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 

% 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 

end 

% inizio il ciclo iterativo 

iter = 0; 

while ( scarto>=toll & iter


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 

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

end 

scarti0 = scarti(k); 

end 

xs = x(k+1); 

f1xk = feval(f1name,xs); 

f2xk = feval(f2name,xs); 

M = 0.5*abs(f2xk/f1xk);


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 

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; 

end 

xs = x(n); 

x = x(1:n); 

n = n-1;


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 

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 = [-4 -1 0 2 5 ]; 

% fx = [1245 33 5 9 1335]; 

% [fx0, F]=interp_newton(m, x, fx, x0, n); 

% Si ottiene: fx0 = 1.1154 

% F = 

% 1245 -404 94 -14 3 

% 0 33 -28 10 13 

% 0 0 5 2 88 

% 0 0 0 9 442 

% 0 0 0 0 1335 

% 

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

end 

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

end 

end 

%


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

end 

fx0=fx(1); 

for j=2:1:(n+1) 

fx0=fx0+F(1,j)*prod(j); 

end 

% 

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

end

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

end 

fprintf(fid,’\r\n’); 

end 

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

legend(’Romberg’,’trapezi’ ) 

grid on 

hold off


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; 

end 

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

end 

Idiag(h) = tab(h,h); 

end 

% migliore approssimazione disponibile per l’integrale 

I = Idiag(m);

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


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

0.1 Programmi MATLAB

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?