ESERCITAZIONE APPENDICE B: MODELLI DI CRESCITA

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

2

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

kpdt

dp= (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

)( ppKpdt

dpm −= (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) è:

)exp()1/(1)(

0 tKppp

ptp

mm

m

−−+= (B.3)

3

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

)exp()1/(1)(

0 tKppp

ptp

mm

m

−−+=

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.

4

Sostituendo i dati forniti per t = 60 otteniamo

)60102exp()110/(11500

6mm

m

pp

p−×−−+

=

ed effettuando alcune esemplificazioni :

01500)60102.1exp()110/(1 4

=−×−−+ −

m

m

px

p

E’ richiesto di calcolare pm, quindi la funzione sulla quale applicare i tre metodi di approssimazione

è:

1500)60102.1exp()110/(1

)(4

−×−−+

=−

mpx

xxf

il cui grafico è:

5

Soluzioni con lo schema di Newton-Raphson

Ricordiamo brevemente la formula utilizzata per applicare l’algoritmo di Newton-Raphson:

)(

)()(

)()()1(

k

kkk

xf

xfxx

′−=+

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 Scarto relativo

1 +63655.35771378 - 2 +63207.53101795 +7.085020E-3 Come possiamo notare il metodo si ferma al passo 2 poiché lo scarto relativo risulta pari a +7.085020E-03 che è minore a τ = 10-2

Ripetiamo lo stesso procedimento considerando ora lo scarto τ = 10-4 : Passo Risultato Scarto relativo

1 +63655.35771378 - 2 +63207.53101795 +7.085020E-3 3 +63200.06151730 +1.11819E-4 4 +63200.05945184 +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 Risultato Scarto relativo

1 +63655.35771378 - 2 +63207.53101795 +7.085020E-3 3 +63200.06151730 +1.11819E-4 4 +63200.05945184 +3.0E-8

Il valore p(90) richiesto risulta pari a +872044.55286934

6

Soluzioni con lo schema della secante fissa

Ricordiamo brevemente lo schema della variante fissa:

01

01 )()(

xx

xfxfkn

−

−=

n

n

nnk

xfxx

)(1 −=+

Ponendo x0 = 60000, x1 = 65000 , kn = 1.358858477689318. Con τ = 10-2 otteniamo i seguenti risultati: Passo Risultato Scarto relativo

1 +62979.43709842 - 2 +63209.57029504 +3.64080E-3 Ripetendo il procedimento con τ = 10-4 otteniamo i seguenti risultati: Passo Risultato Scarto relativo

1 +62979.43709842 - 2 +63209.57029504 +3.64080E-3 3 +63199.56438684 +1.5832E-4 4 +63200.08502846 +8.24E-6 Ponendo invece τ = 10-6 otteniamo Passo Risultato Scarto relativo

1 +62979.43709842 - 2 +63209.57029504 +3.64080E-3 3 +63199.56438684 +1.5832E-4 4 +63200.08502846 +8.24E-6 5 +63200.05812996 +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:

1

1)()(

−

−

−

−=

nn

nn

nxx

xfxfk

n

n

nnk

xfxx

)(1 −=+

7

Poniamo x0n = 60000 e x0n-1 =59900. Con τ = 10 -2 otteniamo i seguenti risultati: Passo Risultato Scarto relativo

1 +63670.91239097 - 2 +63139.92379703 +8.40971E-3 Calcolando i risultati ponendo invece 10 -4 si ottiene: Passo Risultato Scarto relativo

1 +63670.91239097 - 2 +63139.92379703 +8.40971E-3 3 +63199.02392071 +9.351E-4 4 +63200.06176099 +1.642E-5 Ponendo invece τ = 10-6 otteniamo: Passo Risultato Scarto relativo

1 +63670.91239097 - 2 +63139.92379703 +8.40971E-3 3 +63199.02392071 +9.351E-4 4 +63200.06176099 +1.642E-5 5 +63200.05945176 +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 Newton-Raphoson 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).

8

Infine riportiamo un grafico in scala logaritmica degli scarti relativi per poter apprezzare come si comportano i tre metodi.

9

10

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

11

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


write(*,*)'\n**************************'


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


write(*,*)'\n**************************'


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

12

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.

13

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 |

% |--------------------------------------|

14

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

15

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


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:

Ãij =

=−−

=

1||,1

,8

ji

ji i , j=1,…n .

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

16

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

17

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)


elseif (strcmp(info.FunctionTable(j).FunctionName,'moltiplicazione')==1)


elseif (strcmp(info.FunctionTable(j).FunctionName,'divisione')==1)


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)


elseif (strcmp(info.FunctionTable(j).FunctionName,'moltiplicazione')==1)


elseif (strcmp(info.FunctionTable(j).FunctionName,'divisione')==1)


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

18

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)


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)


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)


title('Confronto tra costi computazionali teorici di Jacobi e di Gauss')

xlabel('N')

ylabel('Costo')

19

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

20

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

21

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

22

23

24

25

26

27

28

29

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:

)cos(2

),(2

2

φφ ⋅−= mglml

ppH ,

con )sin(φ⋅−= mglp (accelerazione angolare del pendolo)

e 2

ml

p=φ


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

30

E’ inoltre richiesto di usare il metodo di Eulero Simplettico, con le condizioni iniziali (p0, q0) = (0.0, 0.7) h = 0.3 , (p0, q0) = (0.0, 1.4) h = 0.3 , (p0, q0) = (0.0, 2.1) h = 0.3 . Tali metodi consistono nei seguenti schemi:

• Eulero Esplicito: )(1 nnn yhfyy +=+ .

• Eulero Implicito: )( 11 ++ += nnn yhfyy . Essendo quest’ultima un’equazione non lineare è

necessario applicare un metodo come Newton-Raphson per calcolare il punto successivo.

• Eulero Simplettico: ),( ,21,1,11,1 nnnn yyhfyy ++ += e ),( ,21,1,21,2 nnnn yyhgyy ++ += .

Risoluzione

Sostituendo i dati negli schemi sopra otteniamo:

• Eulero esplicito : )sin(2.01 nnn pp φ⋅−=+ , nnn p2.01 +=+ φφ

• Eulero implicito: )sin(2.0 11 ++ ⋅−= nnn pp φ , 11 2.0 ++ += nnn pφφ

• Eulero simplettico: )sin(3.01 nnn pp φ⋅−=+ , nnn p3.01 +=+ φφ

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

31

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

32

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

33

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.

34

35

36

37

38

39

40

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.

41

Documents

ESERCITAZIONE APPENDICE B: MODELLI DI CRESCITA