esercitazione appendice b: modelli di crescita - Digilander

ESERCITAZIONE APPENDICE B: MODELLI DI CRESCITA............................................................................... 2
INTRODUZIONE ............................................................................................................................................................... 2
ANALISI DELL’OBIETTIVO ............................................................................................................................................... 3
RISOLUZIONE .................................................................................................................................................................. 3
SOLUZIONI CON LO SCHEMA DI NEWTON-RAPHSON ....................................................................................................... 5
SOLUZIONI CON LO SCHEMA DELLA SECANTE FISSA ........................................................................................................ 6
SOLUZIONI CON LO SCHEMA DELLA SECANTE VARIABILE ............................................................................................... 6
GRAFICI .......................................................................................................................................................................... 7
CODICE FORTRAN ......................................................................................................................................................... 10
CODICE MATLAB .......................................................................................................................................................... 12
NewtonR.m .............................................................................................................................................................. 12
SecanteFissa.m........................................................................................................................................................ 13
SecanteVariabile.m ................................................................................................................................................. 13
ESERCITAZIONE APPENDICE H: COSTO COMPUTAZIONALE..................................................................... 15
INTRODUZIONE ............................................................................................................................................................. 15
ANALISI DELL’OBIETTIVO ............................................................................................................................................. 15
CODICE MATLAB .......................................................................................................................................................... 16
costoComputazionale.m .......................................................................................................................................... 16
gauss.m.................................................................................................................................................................... 19
jacobi.m................................................................................................................................................................... 19
moltiplicazione.m .................................................................................................................................................... 20
moltMatr.m.............................................................................................................................................................. 20
divisione.m .............................................................................................................................................................. 20
somma.m ................................................................................................................................................................. 20
sommaMatr.m ......................................................................................................................................................... 20
sottrazione.m ........................................................................................................................................................... 21
GRAFICI ........................................................................................................................................................................ 21
ESERCITAZIONE APPENDICE O : SISTEMI HAMILTONIANI......................................................................... 29
INTRODUZIONE ............................................................................................................................................................. 29
ANALISI DELL’OBIETTIVO ............................................................................................................................................. 29
RISOLUZIONE ................................................................................................................................................................ 30
CODICE MATLAB .......................................................................................................................................................... 30
g.m........................................................................................................................................................................... 30
gd.m......................................................................................................................................................................... 31
n_raph.m ................................................................................................................................................................. 31
euleroEsplicito.m .................................................................................................................................................... 31
euleroImplicito.m .................................................................................................................................................... 31
euleroSimplettico.m................................................................................................................................................. 32
GRAFICI ........................................................................................................................................................................ 32
Esercitazione appendice B: modelli di crescita
Introduzione
I modelli di crescita di popolazioni assumono che la densità di una popolazione p sia proporzionale
sia alla popolazione esistente, ossia
dp
= kp
dt
(B.1)
dove k non dipende dalla concentrazione di nutrimento disponibile. Anche quando il nutrimento non
scarseggia, la crescita in ambiente chiuso viene limitata dalle sostanze di rifiuto che gli esseri
viventi producono. Questi prodotti inibiscono la crescita quando la densità raggiunge un valore
massimo pm. In questa situazione la (B.1) si modifica nella
dp
= Kp ( p m − p )
dt
(B.2)
Prendiamo come esempio una popolazione di cellule in un liquido di coltura. Se la dimensione di p
è [p] = cellule/litro, e il tempo è misurato in giorni, K ha dimensione [K]=(litri/cellule)/giorno.
Posto p(0)= p0 , la soluzione di (B.2) è:
p(t ) =
pm
1 + ( p m / p0 − 1) exp(− Kp m t )
(B.3)
2
Questa funzione viene chiamata modello di crescita logistica semplicemente logistica.
Come esempio di applicazione di modello logistico, consideriamo il problema di stimare
l’evoluzione del mercato di un certo tipo di elaboratori.
All’istante t = 0 poniamo p0 = 10 elaboratori venduti. Dopo t = 60 settimane ne sono stati venduti
15000 e K = 2 × 10-6 . Si vuole calcolare il numero di elaboratori venduti pT dopo T = 90 settimane
Analisi dell’obiettivo
Calcolare la quantità pm
•
usando lo schema di Newton Raphson
•
usando lo schema della secante fissa
•
usando lo schema della secante variabile
Sia sk lo scarto relativo alla k-esima iterazione. Arrestare le iterazioni quando sk<τ, τ = 10-2, τ =
10-4 , τ = 10-6. Tabulare il numero di iterazioni effetuate,le approssimazioni intermedie e gli scarti
relativi. Tabulare e graficare le soluzioni intermedie numeriche ottenute.
Risoluzione
Dato il modello di crescita logistica
p(t ) =
pm
1 + ( p m / p0 − 1) exp(− Kp m t )
e i dati iniziali
t = 0, p0 = 10, t = 60, p60 = 15000, K = 2×10-6
si vuole calcolare il numero pT di elaboratori dopo T=90 settimane.
3
Sostituendo i dati forniti per t = 60 otteniamo
1500 =
pm
1 + ( p m / 10 − 1) exp(−2 × 10 −6 p m 60)
ed effettuando alcune esemplificazioni :
pm
− 1500 = 0
1 + ( x / 10 − 1) exp(−1.2 × 10 −4 p m 60)
E’ richiesto di calcolare pm, quindi la funzione sulla quale applicare i tre metodi di approssimazione
è:
f ( x) =
x
− 1500
1 + ( x / 10 − 1) exp(−1.2 × 10 − 4 p m 60)
il cui grafico è:
4
Soluzioni con lo schema di Newton-Raphson
Ricordiamo brevemente la formula utilizzata per applicare l’algoritmo di Newton-Raphson:
x
( k +1)
=x
(k )
f ( x (k ) )
−
f ′( x ( k ) )
Come punto di partenza iniziale è stato deciso un valore molto vicino alla soluzione 60.000.
Nel caso in cui τ = 10 -2 otteniamo le seguenti soluzioni:
Passo
Risultato
1
+63655.35771378
2
+63207.53101795
Come possiamo notare il metodo si ferma al passo 2 poiché
+7.085020E-03 che è minore a τ = 10-2
Scarto relativo
+7.085020E-3
lo scarto relativo risulta pari a
Ripetiamo lo stesso procedimento considerando ora lo scarto τ = 10-4 :
Passo
1
2
3
4
Risultato
+63655.35771378
+63207.53101795
+63200.06151730
+63200.05945184
Scarto relativo
+7.085020E-3
+1.11819E-4
+3.0E-8
In questo caso ci si ferma al passo 4 poiché lo scarto relativo risulta pari a +3.0E-8 che è minore a τ
= 10-4.
Ripetiamo lo stesso procedimento considerando ora lo scarto τ = 10-6 : la tabella viene riportata
solo per completezza perché ovviamente ci si fermerà sempre al passo 4 visto che lo scarto minore
della tolleranza fissata
Passo
1
2
3
4
Risultato
+63655.35771378
+63207.53101795
+63200.06151730
+63200.05945184
Scarto relativo
+7.085020E-3
+1.11819E-4
+3.0E-8
Il valore p(90) richiesto risulta pari a +872044.55286934
5
Soluzioni con lo schema della secante fissa
Ricordiamo brevemente lo schema della variante fissa:
kn =
f ( x1 ) − f ( x0 )
x1 − x0
x n +1 = x n −
f ( xn )
kn
Ponendo x0 = 60000, x1 = 65000 , kn = 1.358858477689318.
Con τ = 10-2 otteniamo i seguenti risultati:
Passo
1
2
Risultato
+62979.43709842
+63209.57029504
Scarto relativo
+3.64080E-3
Ripetendo il procedimento con τ = 10-4 otteniamo i seguenti risultati:
Passo
1
2
3
4
Risultato
+62979.43709842
+63209.57029504
+63199.56438684
+63200.08502846
Scarto relativo
+3.64080E-3
+1.5832E-4
+8.24E-6
Ponendo invece τ = 10-6 otteniamo
Passo
1
2
3
4
5
Risultato
+62979.43709842
+63209.57029504
+63199.56438684
+63200.08502846
+63200.05812996
Scarto relativo
+3.64080E-3
+1.5832E-4
+8.24E-6
+4.3E-7
Il valore p(90) richiesto risulta pari a +872044.34537534
Soluzioni con lo schema della secante variabile
La formula utilizzata per applicare l’algoritmo della secante variabile è il seguente:
kn =
f ( x n ) − f ( x n −1 )
x n − x n −1
x n +1 = x n −
f ( xn )
kn
6
Poniamo x0n = 60000 e x0n-1 =59900.
Con τ = 10 -2 otteniamo i seguenti risultati:
Passo
1
2
Risultato
+63670.91239097
+63139.92379703
Scarto relativo
+8.40971E-3
Calcolando i risultati ponendo invece 10 -4 si ottiene:
Passo
1
2
3
4
Risultato
+63670.91239097
+63139.92379703
+63199.02392071
+63200.06176099
Scarto relativo
+8.40971E-3
+9.351E-4
+1.642E-5
Ponendo invece τ = 10-6 otteniamo:
Passo
1
2
3
4
5
Risultato
+63670.91239097
+63139.92379703
+63199.02392071
+63200.06176099
+63200.05945176
Scarto relativo
+8.40971E-3
+9.351E-4
+1.642E-5
+4E-8
Come possiamo notare al passo 5 il metodo si ferma fornendo l’approssimazione richiesta.
Il valore p(90) richiesto, calcolato sostituendo lo zero trovato per la funzione B.3 è pari a
+872044.55285542.
Grafici
Di seguito vengono riportati i grafici delle approssimazioni intermedie con i tre algoritmi usati per i
tre valori di τ. Come si potrà osservare il metodo che converge più velocemente è quello di NewtonRaphoson seguito dalla secante variabile e da quella fissa. Tutto questo segue fedelmente quanto
studiato in teoria. Infatti il grado di convergenza per Newton-Raphoson è paria 2,per la secante fissa
è pari a 1 ed infine,per la secante variabile (Regula Falsi) è superlineare (1.62).
7
Infine riportiamo un grafico in scala logaritmica degli scarti relativi per poter apprezzare come si
comportano i tre metodi.
8
9
Codice Fortran
In questa sezione viene riportato il codice Fortran relativo all’esercitazione. Il codice comprende
una sezione main utilizzato per la chiamata dei tra algoritmi, il codice relativo ai tre algoritmi e le
funzioni di supporto.
*|-------------------------------------------------------------|
*|MAIN
*|-------------------------------------------------------------|
program es1
real tau
integer scelta
*Lettura dati
write(*,*)'Inserire la soglia per lo scarto relativo'
read(*,*)tau
write(*,*)'Inserire il numero dell'algoritmo:'
read(*,*)scelta
if (scelta .eq. 1) call newtonraphson(tau,60000)
if (scelta .eq. 2) call secfissa(tau,60000)
if (scelta .eq. 3) call secvariabile(tau,60000)
end
*|-------------------------------------------------------------|
*|Algoritmo di Newton Raphson
*|-------------------------------------------------------------|
subroutine newtonraphson(tau,x0)
real sk
real xkf,xk
integer i
*Calcolo dello zero della funzione
sk=100
i=0
xk=x0
do while ((sk .ge. tau) .and. (j .le. 100))
i=i+1
xkf=xk-(f(xk)/f1(xk))
if(i .ge. 2) sk=abs((xkf-xk)/xkf)
xk=xkf
write(*,*)i,xk,sk
end do
*Produzione dei risultati
write(*,*)'\n**************************'
write(*,*)i,' passi di computazione'
write(*,*)p(90,xk),' p(90)\n'
end
*|-------------------------------------------------------------|
*|Algoritmo della secante fissa
*|-------------------------------------------------------------|
subroutine secantefissa(tau,x0)
real sk
real xk,kn,xkf
integer i
*Calcolo dello zero
i=0
10
sk=100
kn=(f(65000)-f(60000))/5000
xk=x0
xkf=xk-(f(xk)/kn)
if(i .ge. 2) sk=abs((xkf-xk)/xkf)
xk=xkf
write(*,*) i,xk,sk
end do
*Produzione dei risultati
write(*,*)'\n**************************'
write(*,*)i,' passi di computazione'
write(*,*)p(90,xk),' p(90)\n'
*|-------------------------------------------------------------|
*|Algoritmo della secante variabile
*|-------------------------------------------------------------|
subroutine secantevariabile(tau,x0)
real sk
real xk1,xk,kn,xkplus1
integer i
xk1=x0-100
xk=x0
*Calcolo dello zero
sk=100
i=0
do while((sk .ge. tau) .and. (i .le. 100))
i=i+1
kn=(f(xk)-f(xk1))/(xk-xk1)
xkplus1=xk-(f(xk)/kn)
if(i .ge. 2) sk=abs((xk-xk1)/xk)
xk1=xk
xk=xkplus1
write(*,*) i,xk1,sk
end do
*Produzione dei risultati
write(*,*)'\n**************************'
write(*,*)i,' passi di computazione'
write(*,*)p(90,xk1),' p(90)\n'
*|-------------------------------------------------------------|
*|Funzioni di supporto
*|-------------------------------------------------------------|
real function f(x)
f=x/(1+(x/10-1)*exp(-1.2E-4*x))-15000
return
end
real function p(t,pm)
p=pm=(((1+(pm/10-1))*exp((-2E-6)*pm*t)))
return
end
real function f1(x)
f1=(100-3/250*exp(-3/25000*x)*x-100*exp(-3/25000*x)+3/2500*exp(3/25000*x)*x^2)/(10+exp(-3/25000*x)*x-10*exp(-3/25000*x))**2
return
end
11
Codice Matlab
Il seguente codice Matlab esegue l’algoritmo di Newton-Raphson eproduce come output una tabella
con riportati i risultati intermedi, gli scarti relativi e il calcolo di p(90).
NewtonR.m
function eser1Newton()
% Funzioni di supporto
x=60000;
pm=x;
t=90;
%funzione f
f='x/(1+(x/10-1)*exp(-1.2E-4*x))-15000'
%derivata di f
df='(100-3/250*exp(-3/25000*x)*x-100*exp(-3/25000*x)+3/2500*exp(3/25000*x)*x^2)/(10+exp(-3/25000*x)*x-10*exp(-3/25000*x))^2'
%popolazione
p='pm/((((1.0+(pm/10.0-1.0))*exp((-2.0E-6)*pm*t))))'
fx=eval(f);
dfx=eval(df);
n=0;
scarto=100;
tolleranza=1e-6;
%esecuzione dell'algoritmo--> produzione dei risultati
fprintf('Elenco dei risultati\n');
while (scarto>tolleranza)
n=n+1;
div=fx/dfx;
xpassoprec=x;
x=x-div;
%ricalcolo delle funzioni fx e dfx con la nuova x
fx=eval(f);
dfx=eval(df);
%calcolo dell scarto
scarto=abs((x-xpassoprec)/x);
%stampa dei risultati
fprintf('%8.0f-%8.8f-%8.8f\n',n,x,scarto);
end
% calcolo di P(90)
%t=90;
pm=x;
fprintf('P(90)=%8.8f\n',eval(p));
end
Il seguente codice invece esegue l’algoritmo della secante fissa. Produce lo stesso output
dell’algoritmo di Newton-Raphson.
12
SecanteFissa.m
%
Funzioni di supporto
x=60000;
f='x/(1+(x/10-1)*exp(-1.2E-4*x))-15000'
p='pm/(((1.0+(pm/10.0-1.0))*exp((-2.0E-6)*pm*t)))'
%Secante fissa
kn='1.358858477689318e+000'
fx=eval(f);
knx=eval(kn);
n=0;
scarto=100;
tolleranza=1e-6;
%
Produzione dei risultati
fprintf('Elenco dei risultati\n');
while scarto>tolleranza
n=n+1;
div=fx/knx;
xprecedente=x;
x=x-div;
fx=eval(f);
knx=eval(kn);
scarto=abs((x-xprecedente)/x);
fprintf('%8.0f - %8.8f - %8.8f\n',n,x,scarto);
end;
%calcolo P(90)
t=90;
pm=x;
fprintf('P(90)=%8.8f\n',eval(p));
Infine qui sotto viene riportato il codice matlab dell’algoritmo della secante variabile
SecanteVariabile.m
% |--------------------------------------|
% | Funzioni di supporto |
% |--------------------------------------|
x=60000;
t=59900;
f='x/(1+(x/10-1)*exp(-1.2E-4*x))-15000';
ft='t/(1+(t/10-1)*exp(-1.2E-4*t))-15000';
p='pm/(((1.0+(pm/10.0-1.0))*exp((-2.0E-6)*pm*t)))';
%Esecuzione secante variabile
div='x-t';
fx=eval(f);
fxt=eval(ft);
fdiv=eval(div);
n=0;
scarto=100;
tolleranza=1e-4;
% |--------------------------------------|
% | Produzione dei risultati |
% |--------------------------------------|
13
fprintf('Risultati\n');
while scarto>tolleranza
n=n+1;
kn=(fx-fxt)/fdiv;
xprec=x;
x=x-(fx/kn);
t=xprec;
fx=eval(f);
fxt=eval(ft);
div='x-xprec';
fdiv=eval(div);
%calcolo lo scarto
scarto=abs((x-xprec)/x);
%stampo i risultati
fprintf('%8.0f %8.8f %8.8f\n',n,x,scarto);
end;
%calcolo P(90)
t=90;
pm=x;
fprintf('P(90)=%8.8f',eval(p));
14
Esercitazione Appendice H: Costo Computazionale
Introduzione
Lo schema di eliminazione di Gauss `e un metodo numerico per la risoluzione di Sistemi Lineari. In
particolare fa parte dei metodi diretti, i quali sono caratterizzati dal fatto che in assenza di errori di
arrotondamento permettono di ottenere la soluzione esatta del sistema in un numero finito di passi.
Il metodo di Gauss trasforma il sistema di partenza Ax = b in un sistema equivalente, con la stessa
soluzione, Ux = c, dove U è una matrice triangolare superiore. Dopo aver ottenuto questo sistema
esso viene risolto facilmente applicando il metodo delle sostituzioni all’indietro.
Il metodo di Jacobi è invece un metodo iterativo, cioè necessita di un numero infinito di passi per
calcolare la soluzione del sistema, anche in assenza di errori di arrotondamento. I metodi iterativi
sono indicati per risolvere sistemi sparsi di grandi dimensioni, inoltre sono autocorrettivi, cioè non
amplificano gli errori di arrotondamenti, ma tendono ad avvicinarsi sempre più alla soluzione
esatta. Sono inoltre metodi ottimi per risolvere sistemi diagonalmente dominanti. Lo schema di
Jacobi viene rappresentato dalla seguente equazione: xk + 1 = (b−(L + U)xk )× D−1 dove le matrici L,
D, U sono uno splitting della matrice A dei coefficienti del sistema. La matrice L è una matrice
triangolare inferiore, la matrice D `e una matrice diagonale, mentre la matrice U è una matrice
triangolare superiore. Il metodo di Jacobi converge se il raggio spettrale della matrice di iterazione
E = −D−1(L+U) è inferiore ad 1 (esistono poi altri criteri pratici di convergenza).
Analisi dell’obiettivo
Si vuole stimare il costo computazionale di due algoritmi numerici per risolvere un sistema lineare
Ax = b di ordine n.
Si prendano in considerazione:
• lo schema di eliminazione di Gauss senzapivoting;
• lo schema di Jacobi
Come valori iniziali abbiamo la matrice tridiagonale à che ha gli elementi tutti nulli eccetto che:
 8, i = j
Ãij = 
i , j=1,…n .
− 1, | i − j |= 1
Infine poniamo A = Ã + 10-6.
Sia s(n) uno schema risolutivo,indichiamo con C[s(n)] il suo costo computazionale,cioè il numero
di operazioni floating point necessarie per risolvere il sistema.
Abbiamo che:
• C[G(n)] = O(2n3/3) , dove G rappresenta l’algoritmo di Gauss, in quanto occorrono n3/3
moltiplicazioni e n3/3 addizioni per eseguire l’algoritmo.
• C[J(n)] = O(2m*n2).
15
Codice Matlab
Il programma principale è CostoComputazionale dove al suo interno sono presenti alcune chiamate
a certe funzioni che eseguono gli algoritmi e realizzano i grafici.
Le funzioni sono:
• gauss che esegue il metodo di Gauss;
• jacobi che esegue il metodo di Jacobi;
• divisione che esegue la divisione tra due numeri;
• moltiplicazione che esegue la moltiplicazione tra due numeri;
• somma che esegue la somma tra due numeri;
• sommaMatr che esegue la somma tra matrici;
• moltMatr che esegue la moltiplicazione tra due matrici.
I due metodi di risoluzione sono stati implementati nelle funzioni gauss e jacobi, le quali ritornano
il vettore soluzione del sistema.
Qui sotto riportiamo il codice matlab riguardante il costo computazionale e tutte le funzioni
ausiliare elencate sopra.
costoComputazionale.m
%|----------------------------------------------------------|
% COSTO COMPUTAZIONALE |
%|----------------------------------------------------------|
function f = costoComputazionale()
%inizializzazione delle strutture
matrmax=512;
toll=1e-6;
tempoG=[];
tempoJ=[];
costoCompG=[];
costoCompJ=[];
costoTeorG=[];
costoTeorJ=[];
inversione=0;
x_bis = [4 40 80 120 160 200 240 320 360 400 440 480 512]
n=4;
i=1;
while n<=matrmax
n
%creazione della matrice A
A1=eye(n);
for k=1:n
for j=1:n
if j==k
A1(k,k)=8;
elseif abs(k-j)==1
A1(k,j)=-1;
end
16
end
end
A=A1+1e-6;
b=rand(n,1);%b è unamatrice casuale 4x1
solSist=inv(A)*b;
profile resume;
profile on;
t_inizio=cputime;
xG=gauss(A,b);
t_fine=cputime;
profile off;
tempoG(i)=t_fine-t_inizio;
info=profile('info');
costoCompG(i)=0;
for j=1:size(info.FunctionTable)
if (strcmp(info.FunctionTable(j).FunctionName,'somma')==1)
costoCompG(i)=costoCompG(i)+info.FunctionTable(j).NumCalls;
elseif (strcmp(info.FunctionTable(j).FunctionName,'sottrazione')==1)
costoCompG(i)=costoCompG(i)+info.FunctionTable(j).NumCalls;
elseif (strcmp(info.FunctionTable(j).FunctionName,'moltiplicazione')==1)
costoCompG(i)=costoCompG(i)+info.FunctionTable(j).NumCalls;
elseif (strcmp(info.FunctionTable(j).FunctionName,'divisione')==1)
costoCompG(i)=costoCompG(i)+info.FunctionTable(j).NumCalls;
end;
end;
profile resume;
profile on;
t_inizio=cputime;
xJ=jacobi(A,b,solSist,toll);
t_fine=cputime;
profile off;
tempoJ(i)=t_fine-t_inizio;
info=profile('info');
costoCompJ(i)=0;
for j=1:size(info.FunctionTable)
if (strcmp(info.FunctionTable(j).FunctionName,'somma')==1)
costoCompJ(i)=costoCompJ(i)+info.FunctionTable(j).NumCalls;
elseif (strcmp(info.FunctionTable(j).FunctionName,'sottrazione')==1)
costoCompJ(i)=costoCompJ(i)+info.FunctionTable(j).NumCalls;
elseif (strcmp(info.FunctionTable(j).FunctionName,'moltiplicazione')==1)
costoCompJ(i)=costoCompJ(i)+info.FunctionTable(j).NumCalls;
elseif (strcmp(info.FunctionTable(j).FunctionName,'divisione')==1)
costoCompJ(i)=costoCompJ(i)+info.FunctionTable(j).NumCalls;
end;
end;
if (tempoJ(i)>tempoG(i))
inversione=n;
end
i=i+1;
if matrmax>n
n=x_bis(i);
else
n=matrmax+1
end
end;
num=i-1;
for i=1:num
costoTeorG(i)=((2*(x_bis(i)^3))/3);
m = fix((-6/log10(0.25))+1);
costoTeorJ(i)=(2*m*(x_bis(i)^2));
end;
unaG=tempoG(num)/costoTeorG(num);
for i=1:num
17
timesTeorG(i)=costoTeorG(i)*unaG;
end;
unaJ=tempoJ(num)/costoTeorJ(num);
for i=1:num
timesTeorJ(i)=costoTeorJ(i)*unaJ;
end;
%|----------------------------------|
% GRAFICI |
%|----------------------------------|
for i=1:num
x(i)=x_bis(i);
end;
inversione
unaG
unaJ
figure
plot(x,tempoG,'r+-',x,timesTeorG,'b.--','MarkerSize',4)
legend('Tempi reali','Tempi teorici',2)
title('Confronto tra tempi calcolati e teorici per Gauss')
xlabel('N')
ylabel('Tempo')
figure
plot(x,tempoJ,'r+-',x,timesTeorJ,'b.--','MarkerSize',4)
legend('Tempi reali','Tempi teorici',2)
title('Confronto tra tempi calcolati e teorici per Jacobi')
xlabel('N')
ylabel('Tempo')
figure
plot(x,tempoG,'c+--',x,tempoJ,'g.-','MarkerSize',4)
legend('Gauss','Jacobi',2)
title('Confronto tra tempi di esecuzione reali di Jacobi e di Gauss')
xlabel('N')
ylabel('Tempo')
figure
plot(x,timesTeorG,'c+--',x,timesTeorJ,'g.-','MarkerSize',4)
legend('Gauss','Jacobi',2)
title('Confronto tra tempi di esecuzione teorici di Jacobi e di Gauss')
xlabel('N')
ylabel('Tempo')
figure
plot(x,costoCompG,'r+-',x,costoTeorG,'g*--','MarkerSize',4)
legend('Costo reale','Costo teorico',2)
title('Confronto tra costi computazionali calcolati e teorici per Gauss')
xlabel('N')
ylabel('Costo')
figure
plot(x,costoCompJ,'r+-',x,costoTeorJ,'b.--','MarkerSize',4)
legend('Costo reale','Costo teorico',2)
title('Confronto tra costi computazionali calcolati e teorici per Jacobi')
xlabel('N')
ylabel('Costo')
figure
plot(x,costoCompG,'c+--',x,costoCompJ,'g.-','MarkerSize',4)
legend('Gauss','Jacobi',2)
title('Confronto tra costi computazionali reali di Jacobi e di Gauss')
xlabel('N')
ylabel('Costo')
figure
plot(x,costoTeorG,'c+--',x,costoTeorJ,'g*-','MarkerSize',4)
legend('Gauss','Jacobi',2)
title('Confronto tra costi computazionali teorici di Jacobi e di Gauss')
xlabel('N')
ylabel('Costo')
18
gauss.m
% calcola la soluzione approssimata del sistema Ax=b tramite il metodo di Gauss
senza pivoting
function b = gauss(a,b)
n=size(a);
%Crea una matrice triangolare alta, sistemando anche il vettore b.
for i=1:n
m=a(i,i);
for j=i:n
a(i,j)=divisione(a(i,j),m);
end;
b(i)=divisione(b(i),m);
for z=i+1:n
m=a(z,i);
for k=i:n
a(z,k)=sottrazione(a(z,k),moltiplicazione(a(i,k),m));
end;
b(z)=sottrazione(b(z),moltiplicazione(b(i),m));
end;
end;
% Risolve il sistema con la sostituzione all'indietro.
for i=n:-1:1
for j=i+1:n
b(i)=sottrazione(b(i),moltiplicazione(b(j),a(i,j)));
end;
end;
jacobi.m
% calcola la soluzione approssimata del sistema Ax=b tramite il metodo
% iterativo di Jacobi partendo da una soluzione inziale xk fino ad ottenere
% una soluzione il cui errore sia inferiore alla tolleranza toll richiesta
function [xk,iter] = jacobi(a,b,x,toll)
n=size(a);
% Calcola le matrici L,U,D
L=tril(a,-1); %tril calcola L
U=triu(a,1); %triu calcola U
D=diag(diag(a));
% Calcola inversa di D
for i=1:n
invD(i,i)=1/D(i,i);
end;
% calcola la matrice di iterazione di Jacobi
% Ej = moltMatr(-invD,sommaMatr(L,U));
Ej=-invD*(L+U);
% applica lo schema di iterazione fino ad ottenere un certo errore
x0=zeros(n(1),1);
sprintf('%d',1);
xk=x0; % l'iterazione comincia con un x0 dato
nrx=norm(x); % norma della soluzione esatta
nrk=nrx;
c=moltMatr(invD,b); % c=D^(-1)*b
while (nrk/nrx)>toll
19
xk_1=sommaMatr(moltMatr(Ej,xk),c);
xk=xk_1;
nrk=norm(x-xk);
end;
% restituisce la soluzione calcolata
f=xk;
moltiplicazione.m
%esegue la moltiplicazione tra due numeri
function m=moltiplicazione(a,b)
m=a*b;
moltMatr.m
%funzione che esegue la moltiplicazione tra due matrici
function f=moltMatr(a,b)
for k=1:size(b,2)
for i=1:size(a,1)
temp=moltiplicazione(a(i,1),b(1,k));
for j=2:size(a,2)
temp=somma(temp,moltiplicazione(a(i,j),b(j,k)));
end
f(i,k)=temp;
end
end
divisione.m
%funzione che effetua la divisione
function d=divisione(a,b)
d=a/b;
somma.m
%esegue la somma
function s=somma(a,b)
s=a+b;
sommaMatr.m
% Esegue somme tra matrici
20
function s=sommaMatr(a,b)
for i=1:size(a,1)
for j=1:size(b,2)
s(i,j)=somma(a(i,j),b(i,j));
end
end;
sottrazione.m
%effetua la sottrazione
function m=sottrazione(a,b)
m=a-b;
Grafici
Di seguito vengono riportati i grafici che rappresentano il confronto tra tempi reali e teorici calcolati
per entrambi i metodi. Il punto di inversione calcolato è 40
21
22
23
24
25
26
27
28
Esercitazione Appendice O : sistemi Hamiltoniani
Introduzione
Supponiamo di avere il pendolo della figura seguente:
dove la massa m = 1 Kg, l’asta rigida ha massa nulla e lunghezza l = 1 m e φ rappresenta l’angolo
fra la posizione dell’asta in movimento e la posizione di quiete. Sulla massa agisce una forza di
gravita che genera un’accelerazione g = 1 m/s2.
La formulazione del problema secondo le equazioni di Hamilton è la seguente:
H ( p, φ ) =
p2
− mgl ⋅ cos(φ ) ,
2ml 2
con p = − mgl ⋅ sin(φ ) (accelerazione angolare del pendolo)
eφ=
p
ml 2
Analisi dell’obiettivo
E’ richiesto di calcolare il moto del pendolo (ovvero i valori di p e φ ) nell’intervallo di tempo 0 < t
< 100 utilizzando il metodo di Eulero Esplicito ed Implicito, con le condizioni iniziali
(p0, q0) = (0.0, 0.5)
h = 0.2
29
E’ inoltre richiesto di usare il metodo di Eulero Simplettico, con le condizioni iniziali
(p0, q0) = (0.0, 0.7)
(p0, q0) = (0.0, 1.4)
(p0, q0) = (0.0, 2.1)
h = 0.3 ,
h = 0.3 ,
h = 0.3 .
Tali metodi consistono nei seguenti schemi:
•
Eulero Esplicito: y n +1 = y n + hf ( y n ) .
•
Eulero Implicito: y n +1 = y n + hf ( y n+1 ) . Essendo quest’ultima un’equazione non lineare è
necessario applicare un metodo come Newton-Raphson per calcolare il punto successivo.
•
Eulero Simplettico: y1,n +1 = y1, n + hf ( y1,n +1 , y 2, n ) e y 2,n +1 = y 2,n + hg ( y1,n +1 , y 2, n ) .
Risoluzione
Sostituendo i dati negli schemi sopra otteniamo:
•
Eulero esplicito :
p n +1 = p n − 0.2 ⋅ sin(φ n ) , φ n +1 = φ n + 0.2 p n
•
Eulero implicito:
p n +1 = p n − 0.2 ⋅ sin(φ n +1 ) , φ n +1 = φ n + 0.2 p n +1
•
Eulero simplettico:
p n +1 = p n − 0.3 ⋅ sin(φ n ) , φ n +1 = φ n + 0.3 p n
Codice Matlab
Qui sotto riportiamo il codice Matlab che eseguono gli schemi di Eulero Esplicito, Implicito e
Simlpettico e che generano i grafici.
g.m
function [g] = g(x, pn, qn)
g = pn + 0.2 * (-sin(qn + 0.2 * x)) - x;
return
30
gd.m
function [gd] = gd(x, qn)
gd = 0.04 * cos(qn + 0.2 * x) - 1;
return
n_raph.m
function [x_k] = n_raph(pn, qn)
%format long eng;
x_prec = pn;
toll = 10^-6;
scarto = toll + 1;
while (scarto > toll)
x_k = x_prec - g(x_prec, pn, qn)/gd(x_prec, qn);
scarto = abs((x_k - x_prec)/x_k);
x_prec = x_k;
end
return
euleroEsplicito.m
function [p, q] = euleroEsplicito(h, p0, q0)
%format long eng;
p(1) = p0;
q(1) = q0;
h=0.2
t(1)=0;
for i = 2:100
t(end)=i;
q(i) = q(i-1) + h * p(i-1);
p(i) = p(i-1) + h * (-sin(q(i-1)));
t=[t,t(end)];
end
plot(t, q);
%plot(p,q)
return
euleroImplicito.m
function [p, q] = euleroImplicito(h, p0, q0)
%format long eng;
p(1) = p0;
q(1) = q0;
t(1)=0
for i = 2:100
t(end)=i
p(i) = n_raph(p(i-1), q(i-1));
q(i) = q(i-1) + h * p(i);
p(i) = p(i-1) + h * (-sin(q(i)));
t=[t,t(end)];
end
%plot(p, q);
plot(t,q);
31
return
euleroSimplettico.m
function [p, q] = euleroSimplettico(h, p0, q0)
%format long eng;
p(1) = p0;
q(1) = q0;
t(1)=0;
for i = 2:100
t(end)=i;
p(i) = p(i-1) + h * (-sin(q(i-1)));
q(i) = q(i-1) + h * p(i);
t=[t,t(end)];
end
plot(p, q);
%plot(t,q);
return
Grafici
32
Da questo grafico si può notare che l’oscillazione aumenta nel tempo, fino a rimanere
costantemente positiva, ovvero l’asta rimane lontano dalla posizione di equilibrio, sempre dallo
stesso lato. Da qui si può intuire che questo metodo non risolve in maniera corretta il problema.
Dal grafico di Eulero Implicito sembra che le oscillazioni diminuiscano fino a tendere a zero, come
se il pendolo fosse sottoposto a forze di tipo conservativo, come per esempio una forza di
attrito.Anche con questo metodo il problema non è stato risolto in maniera corretta.
33
34
35
36
37
38
39
Da questi grafici che mostrano le curve dello schema di Eulero simplettico con al variazione
dell’angolo q = 0.7, 1.4, 2.1, si può notare che le oscillazioni rimangono approssimatamene costanti
nel tempo, e risulta quindi essere la soluzione corretta per il moto di un pendolo non sottoposto a
forze esterne o forze dissipative. Si rispetta quindi la legge di conservazione dell’energia, che
afferma che la somma di energia cinetica e potenziale rimane costante in un sistema.
40
41