con condizione iniziale:

Equazioni Differenziali.

Consideriamo il sistema di equazioni differenziali:

y ⁰ = f (t, y) (1)

con condizione iniziale:

y(t ₀ ) = y ₀ ,

e supponiamo che la funzione f : [t ₀ , T ] × R ^s → R ^s sia continua nelle due variabili e Lipshitziana in y, cio` e che, presi y ₁ , y ₂ ∈ R ^s , risulti:

kf(t, y 1 ) − f(t, y 2 ) k < Lky 1 − y 2 k

con L > 0. ` E noto che sotto queste ipotesi, fissata la condizione iniziale, esiste un’unica soluzione dell’equazione (1). Tranne pochi casi per` o le so- luzioni non possono essere fornite analiticamente, cio` e non possono essere espresse mediante polinomi, funzioni elementari e funzioni trigonometriche.

Bisogna necessariamente approssimarle mediante un procedimento numerico oppure cercare le informazioni di interesse sul loro comportamento mediante opportune tecniche.

Il Matlab ha un certo numero di funzioni per risolvere equazioni differen- ziali,

ode45, ode23, ode113, ode15s, ode23s, ode23t,ode23tb Per problemi non stiff conviene usare le seguenti funzioni:

• ode45 `e basata su una formula di Runge-Kutta esplicita (4,5). ` E un metodo ad un passo.

• ode23 `e basata su una formula di Runge-Kutta esplicita (2,3), `e pi`u effi- ciente di ode45 se non si richiede una precisione elevata e se il problema

`

e moderatamente stiff

• ode113 formula di Adams-Bashforth-Moulton ad ordine variabile. Pu`o

essere pi` u efficiente di ode45 a basse tolleranze e quando la valutazione

della funzione ` e molto costosa. ` E unmetodo multistep, cio ‘e richiede

la soluzione in alcuni punti precendenti per calcolare quella nel punto

corrente.

Per problemi stiff:

• ode15s metodo ad ordine variabile basato sulla differenziazione numeri- ca. ` E un risolutore multistp da usare quando il problema ` e stiff oppure l’equazione differenziale ` e associata ad equazioni algebriche.

• ode23s `e un metodo ad un passo basato su una formula di Rosenbrock di ordine 2. ` E pi` u efficiente di ode15s ad alte tolleranze.

• ode23t implementazione della formula dei trapezi per problemi mode- ratamente stiff.

• ode23tb formula di Runge-Kutta implicita. ` E pi` u efficiente di ode15s ad alte tolleranze.

Costruiamo il seguente m-file:

function dydt = ode1(t,y)

% funzione per la il problema differenziale

% y’ = -10*y dydt = -10*y;

lo risolviamo nell’intervallo [02] e diamo come punto iniziale y ₀ = 1.

>> [t,y]=ode45(’ode1’,[0;2],1);

>> plot(t,y)

La precisione usata ` e quella di default, se vogliamo possiamo dare in input alcuni parametri opzionali, per vedere quali sono i parametri opzionali digitare

>> odeset

AbsTol: [ positive scalar or vector {1e-6} ] RelTol: [ positive scalar {1e-3} ]

NormControl: [ on | {off} ] OutputFcn: [ function ]

OutputSel: [ vector of integers ] Refine: [ positive integer ]

Stats: [ on | {off} ]

InitialStep: [ positive scalar ]

MaxStep: [ positive scalar ] BDF: [ on | {off} ]

MaxOrder: [ 1 | 2 | 3 | 4 | {5} ] Jacobian: [ matrix | function ] JPattern: [ sparse matrix ] Vectorized: [ on | {off} ]

Mass: [ matrix | function ] MStateDependence: [ none | weak | strong ]

MvPattern: [ sparse matrix ] MassSingular: [ yes | no | {maybe} ] InitialSlope: [ vector ]

Events: [ function ]

Introduciamo tolleranze assolute e relative uguali a 1e-5, avvisiamo che lo jacobiano ` e costante e uguale a -10 e diciamo di stampare il grafico della funzione durante l’elaborazione

>> options = odeset(’RelTol’,1e-5,’AbsTol’,1e-5,’Jacobian’,-10, ...

’OutputFcn’,’odeplot’)

>> [t,y]=ode45(’ode1’,[0;2],1,options);

I dati di output possono essere memorizzati in una struttura, in questo caso la funzione deve essere passata utilizzando l’handle corrispondente, cio` e anteponendo @al nome della funzione

>> sol =ode45(@ode1,[0;2],1,options);

>> plot(sol.x,sol.y)

>> sol.solver ans =

ode45

>> options = odeset(’RelTol’,1e-5,’AbsTol’,1e-5,’Jacobian’,-10)

>> options = odeset(options,’OutputFcn’,’odeplot’,’stats’,’on’)

>> sol=ode45(@ode1,[0;2],1,options);

22 successful steps

0 failed attempts

133 function evaluations 0 partial derivatives 0 LU decompositions

0 solutions of linear systems

>> sol=ode23(@ode1,[0;2],1,options);

54 successful steps 1 failed attempts

166 function evaluations 0 partial derivatives 0 LU decompositions

0 solutions of linear systems

>> sol=ode113(@ode1,[0;2],1,options);

48 successful steps 0 failed attempts

97 function evaluations 0 partial derivatives 0 LU decompositions

0 solutions of linear systems

Essendo tutti metodi espliciti non richiedono decomposizioni LU o so- luzioni di sistemi lineari, invece le altre funzioni che usano metodi implici- ti richiedono per la soluzione di sistemi di equazioni differenziali anche la soluzione di un sistema di equazioni non lineare.

>> sol=ode15s(@ode1,[0;2],1,options);

61 successful steps 0 failed attempts

124 function evaluations 0 partial derivatives 13 LU decompositions

122 solutions of linear systems

>> sol=ode23s(@ode1,[0;2],1,options);

66 successful steps 0 failed attempts

200 function evaluations

0 partial derivatives

66 LU decompositions

198 solutions of linear systems

>> sol=ode23t(@ode1,[0;2],1,options);

108 successful steps 0 failed attempts

131 function evaluations 0 partial derivatives 21 LU decompositions

129 solutions of linear systems

>> sol=ode23tb(@ode1,[0;2],1,options);

80 successful steps 0 failed attempts

181 function evaluations 0 partial derivatives 19 LU decompositions

259 solutions of linear systems

Possiamo introdurre anche un parametro nella equazione differenziale per esempio

function dydt = ode1p(t,y, lambda)

% funzione per la il problema differenziale

% y’ = -lambda*y dydt = -10*y;

Per risolverlo diamo il valore del parametro come ultimo dato di input il parametro

>> sol=ode23s(@ode1p,[0 1],[2;0],options,20);

95 successful steps 0 failed attempts

287 function evaluations 0 partial derivatives 95 LU decompositions

285 solutions of linear systems

Risolviamo adesso un sistema di equazioni

>> type vdp1

function dydt = vdp1(t,y)

%VDP1 Evaluate the van der Pol ODEs for mu = 1

%

% See also ODE113, ODE23, ODE45.

% Jacek Kierzenka and Lawrence F. Shampine

% Copyright 1984-2001 The MathWorks, Inc.

% $Revision: 1.4 $ $Date: 2001/04/15 12:03:19 $ dydt = [y(2); (1-y(1)^2)*y(2)-y(1)];

>> options = odeset(’RelTol’,1e-2,’AbsTol’,1e-2,...

’OutputFcn’,’odeplot’,’stats’,’on’)

>> sol=ode45(@vdp1,[0 20],[2;0],options);

41 successful steps 14 failed attempts

331 function evaluations 0 partial derivatives 0 LU decompositions

0 solutions of linear systems

>> sol=ode23tb(@vdp1,[0 20],[2;0],options);

85 successful steps 11 failed attempts

389 function evaluations 1 partial derivatives 43 LU decompositions

481 solutions of linear systems Costruiamo la funzione jacobiana function jac = jacvdp1(t,y)

% jacobiano per il problema di van der pol vdp1

%

jac = [0 1; -2*y(1)*y(2)-1 (1-y(1)^2)];

e diamola come parametro di input

>> options = odeset(’RelTol’,1e-2,’AbsTol’,1e-2,’Jacobian’,@jacvdp1...

’OutputFcn’,’odeplot’,’stats’,’on’)

>> sol=ode23tb(@vdp1,[0 20],[2;0],options);

85 successful steps 11 failed attempts

387 function evaluations 1 partial derivatives 43 LU decompositions

481 solutions of linear systems

>>

Metodi di Eulero implicito ed esplicito.

Consideriamo l’equazione differenziale con condizione iniziale

( y ⁰ = f (t, y)

y(t ₀ ) = y ₀ (2)

e supponiamo che f : [t 0 , T ] × R → R sia una funzione tale che la soluzione esista e sia unica nell’intervallo [t ₀ , T ]. Vogliamo ottenere una approssima- zione della soluzione. Dividiamo l’intervallo in N sottointervalli di ampiezza h. Sar` a quindi N h = T − t ⁰ .

Il metodo pi` u semplice per approssimare la soluzione ` e quello di con- siderare lo sviluppo in serie di Taylor nell’intorno del generico punto t _n , n = 0, 1, . . . , N :

y(t _n+1 ) = y(t _n ) + y ⁰ (t _n )h + τ _n

ove τ _n = ^h ₂

y ⁰⁰ (ξ _n ), essendo ξ _n un punto tra t _n e t _n+1 . Questa quantit` a

`

e detta errore locale. Il metodo di Eulero esplicito consiste nel trascurare questo termine e scrivere:

( y _n+1 = y _n + hf (t _n , y _n )

y ₀ = y(t ₀ ) . (3)

Questa formula di ricorrenza non fornir` a la soluzione esatta y(t _n ), per

n = 1, . . . , N , ma una sua approssimazione, che abbiamo indicato con y _n .

Ora costruiamo la function Matlab che implementa il metodo di eulero espli-

cito:

% METODO DI EULERO ESPLICITO

% PER IL CALCOLO DELLA SOLUZIONE DI UN’EQUAZIONE DIFFERENZIALE

%

% function [t,y] = eulero(funz,t0,tf,y0,N)

%

% DATI DI INPUT:

% funz = stringa contenente il nome della funzione che definisce l’equazione

% differenziale (definita in un omonimo file .m)

% t0 = istante di tempo iniziale

% tf = istante di tempo finale

% y0 = condizione iniziale

% n = numero di punti

%

% DATI DI OUTPUT:

% t = vettore contenente un insieme di punti interni all’intervallo di

% tempo considerato

% y = vettore contenente la soluzione nei punti del vettore t

%

function [t,y] = eulero(funz,t0,tf,y0,N) h = (tf - t0)/(N-1);

t = linspace(t0,tf,N);

N = length(t);

y(:,1) = y0;

for n = 1:N-1

y(:,n+1) = y(:,n) + h * feval(funz,t(n),y(:,n));

end

Un esempio di metodo con regione di Assoluta stabilit` a pi` u ampia, ` e il metodo di Eulero implicito definito da

( y _n+1 = y _n + hf (t _n+1 , y _n+1 )

y ₀ = y(t ₀ ) . (4)

Si vede facilmente che questo metodo ` e ancora di ordine 1, cio` e che si ha y(t _n+1 ) = y(t _n ) + hf (t _n+1 , y(t _n+1 )) + τ _n

con τ _n = O(h ² ).

Ora costruiamo la function Matlab che implementa il metodo di eulero im- plicito:

function [t,y] = eul_imp(funz, jacf, t0, tf, y0, N)

%

% Funzione che calcola la soluzione di un’equazione

% differenziale con il metodo di Eulero implicito.

% Dati di input:

% funz = stringa contenente il nome del file in cui

% inserire l’equazione differenziale

% jacf = stringa contenente il nome del file in cui

% inserire lo Jacobiano della funzione

% t0 = istante di tempo iniziale

% tf = istante di tempo finale

% y0 = condizione iniziale

% n = numero di punti

% Dati di output:

% t = vettore contenente un insieme di punti

% interni all’intervallo di tempo considerato

% y = vettore contenente la soluzione nei punti

% del vettore t

%

h = (tf - t0)/(N-1);

t = linspace(t0,tf,N);

N = length(t);

I = eye(length(y0));

epsilon = 1e-5;

y(:,1) = y0;

for n = 1:N-1

y(:,n+1) = y(:,n);

A = I - h * feval(jacf, t(n+1), y(:,n+1));

b = y(:,n+1) - y(:,n) - h ...

* feval(funz, t(n+1), y(:,n+1));

u = A \ b;

%% risolviamo il sistema non lineare con il metodo di Newton y(:,n+1) = y(:,n+1) - u;

cont = 1;

while (norm(u, ’inf’) > epsilon) & (cont < 100) A = I - h * feval(jacf, t(n+1), y(:,n+1));

b = y(:,n+1) - y(:,n) - h ...

* feval(funz, t(n+1), y(:,n+1));

u = A \ b;

y(:,n+1) = y(:,n+1) - u;

cont = cont + 1;

end

if cont == 100

disp([’In ’ num2str(t(n)) ’ non si raggiunge’]) disp(’la approssimazione desiderata’)

disp(’per la soluzione’) end

end

La funzione MATLAB tt num2str permette di trasformare un numero reale in una stringa di caratteri. ` E utile quindi per inserire il valore di una variabile in una stringa. Analogamente ` e possibile trasformare un numero intero in una stringa mediante int2str.

Questo algoritmo, cos`ı come gli altri metodi impliciti presentati in seguito, utilizza il metodo di Newton per calcolare la soluzione ad ogni passo. Richiede quindi come dato di input, lo jacobiano della funzione f .

ESEMPIO: Risolvere l’equazione differenziale

( y ⁰ = −10 ³ y, 0 ≤ t ≤ 20 y 0 = 2

con i due metodi e con le funzioni del matlab.

Il metodo dei trapezi ` e definito da:

y _n+1 − y n = h

2 (f _n+1 + f _n ). (5)

Ora costruiamo la function Matlab che implementa il metodo dei trapezi:

function [t,y] = trapezi(funz, jacf, t0, tf, y0, N)

%

% Funzione che calcola la soluzione di un’equazione

% differenziale con il metodo dei trapezi.

% Dati di input:

% funz = stringa contenente il nome del file in cui

% inserire l’equazione differenziale

% jacf = stringa contenente il nome del file in cui

% lo Jacobiano della funzione

% t0 = istante di tempo iniziale

% tf = istante di tempo finale

% y0 = condizione iniziale

% n = numero di punti

% Dati di output:

% t = vettore contenente un insieme di punti

% interni all’intervallo di tempo considerato

% y = vettore contenente la soluzione nei punti

% del vettore t

%

h = (tf - t0)/(N-1);

t = linspace(t0,tf,N);

N = length(t);

I = eye(length(y0));

epsilon = 1e-5;

y(:,1) = y0;

for n = 1:N-1

y(:,n+1) = y(:,n);

A = I - h/2 * feval(jacf, t(n+1), y(:,n+1));

b = y(:,n+1) - y(:,n) - h/2 * ( feval(funz,t(n+1), y(:,n+1))...

+ feval(funz, t(n), y(:,n)) );

u = A \ b;

y(:,n+1) = y(:,n+1) - u;

cont = 1;

while (norm(u, ’inf’) > epsilon) & (cont < 100) A = I - h/2 * feval(jacf, t(n+1), y(:,n+1));

b = y(:,n+1) - y(:,n) - h/2 * ( feval(funz,t(n+1), y(:,n+1))...

+ feval(funz, t(n), y(:,n)) );

u = A \ b;

y(:,n+1) = y(:,n+1) - u;

cont = cont + 1;

end

if cont == 100

disp([’In ’ num2str(t(n)) ’ non si raggiunge’]) disp(’la approssimazione desiderata’)

disp(’per la soluzione’) end

end end

Applicazione: modello sulla dinamica delle popolazio- ni.

Sia y(t) la popolazione al tempo t. Supponiamo che la variazione di y sia dovuta alle nascite e alle morti. Supponiamo inoltre che il numero di nascite sia proporzionale alla popolazione al tempo t, e che altrettanto avvenga per le morti. Si ha quindi

dy

dt = αy(t) − βy(t), α > 0, β > 0

ove α ` e la costante di proporzionalit` a per le nascite e β quello per le morti.

Si ha quindi, ponendo a = α − β e indicando con y 0 la popolazione al tempo

t = t ₀ :

( y ⁰ = ay y(t ₀ ) = y ₀ .

La soluzione ` e y(t) = y ₀ e ^a(t−t

⁾ da cui risulta che la popolazione aumenta esponenzialmente se a > 0.

Questo modello non ` e in pratica soddisfacente perch` e non tiene conto della limitatezza delle risorse, ad esempio del cibo. Infatti, poich` e la crescita

`

e molto rapida, ad un certo punto la popolazione non avr` a cibo sufficiente per tutti gli individui. Bisogna quindi modificare il modello per tenere conto di ci` o. ` E necessario cio` e aggiungere un termine che tenga conto del conflitto che si crea tra gli individui quando le risorse diventano limitate. Tale termi- ne deve essere negativo perch` e tende a limitare la crescita, ma deve essere trascurabile quando y(t) ` e piccolo. In tal caso infatti ` e da ritenersi che le risorse siano sufficienti.

Il termine da aggiungere ` e quindi del tipo −by ² . Il modello diventa (modello di Verhulst):



 

 

dy

dt = ay − by ² ≡ ay 1 − b a y

!

y(t 0 ) = y 0

.

Il termine in parentesi viene anche chiamato resistenza ambientale. In questo caso si pu` o dare la soluzione analitica del problema che ` e:

y(t) = y ₀

 1 − _a ^b y ₀ ^ e ^−a(t−t

⁾ + _a ^b y ₀ .

Si vede subito che questa curva ha un asintoto orizzontale dato da y( ∞) = a

b .

Non si ha pi` u quindi una crescita illimitata della popolazione, ma esiste una popolazione limite.

ESEMPIO: Poniamo a = 10, b = 5, y ₀ = 0.1 e calcoliamo la soluzione approssimata del problema associato al modello di Verhulst con il metodo di Eulero esplicito e con la funzione MATLAB ode23.

>> type mdp.m

function f = mdp(t,y) f = 10*y-5*y.^2;

>> [t,y] = eulero(’mdp’,0,20,0.1,201);

>> [u,z] = ode23(’mdp’,0,20,0.1);

Ora rappresentiamo graficamente la soluzione ottenuta con Eulero esplicito con passo h = 0.1 (contrassegnata con ‘+’) e quella ottenuta con ode23 ponendo (contrassegnata con ‘o’).

>> plot(t,y,’+’,u,z(:,1),’or’)

ESERCIZIO: Risolvere lo stesso problema con il metodo di Eulero Impli- cito e con il metodo dei trapezi e con le funzioni del Matlab.

ESERCIZIO: Risolvere il seguente sistema









y ⁰ = −3 2

−1 0

!

y

y(t ₀ ) = ^ −1 1 ^{ T}