1 EDO în MATLAB

Cuprins
Ecuaţii diferenţiale în MATLAB ....................................................................................................................................................................................................... 1
1. Probleme cu valori iniţiale ....................................................................................................................................................................................................... 1
1.1 Rezolvitori .............................................................................................................................................................................................................................. 1
1.2 Exemple .............................................................................................................................................................................................................................. 3
1.3 Opţiuni ................................................................................................................................................................................................................................ 8
1.2 Tratarea evenimentelor........................................................................................................................................................................................................ 9
2. Probleme cu valori pe frontieră ............................................................................................................................................................................................. 15

Ecuaţii diferenţiale în MATLAB

1. Probleme cu valori iniţiale
1.1 Rezolvitori

MATLAB are facilităţi foarte puternice de rezolvare a problemelor cu valori iniţiale pentru ecuaţii
diferenţiale ordinare:
𝑑𝑦(𝑡)
= 𝑓(𝑡, 𝑦(𝑡)), 𝑦(𝑡0 ) = 𝑦0 .
𝑑𝑡
Cel mai simplu mod de a rezolva o astfel de problemă este de a scrie o funcţie care evaluează f şi de
a apela unul dintre rezolvitorii MATLAB. Informaţia minimă pe care un rezolvitor trebuie să o
primească este numele funcţiei, mulţimea valorilor lui t pe care se cere soluţia şi valoarea iniţială 𝑦0 .
Rezolvitorii MATLAB acceptă argumente de intrare şi ieşire opţionale care permit să se specifice

Pagina 1
 EDO în MATLAB 2

mai mult despre problema matematică şi modul de rezolvare a ei. Fiecare rezolvitor MATLAB este
conceput să fie eficient în anumite situaţii, dar toţi sunt în esenţă interschimbabili. Toţi rezolvitorii
au aceeaşi sintaxă, ceea ce ne permite să încercăm diferite metode numerice atunci când nu ştim care
ar fi cea mai potrivită. Sintaxa este
[t,y]=rezolvitor(@fun,tspan,y0,optiuni,p1,p2,...)
unde rezolvitor este unul din rezolvitorii daţi în tabela 1.
Rezolvitor Tip Algoritm
problemă
ode45 Nonstiff Pereche Runge-Kutta explicită, cu ordinele 4 şi 5
ode23 Nonstiff Pereche Runge-Kutta explicită, cu ordinele 2 şi 3
ode113 Nonstiff Metodă cu mai mulţi paşi explicită, cu ordin variabil, ordinele de la 1 la 13
ode15s Stiff Metodă cu mai mulţi paşi implicită, cu ordin variabil, ordinele de la 1 la 15
ode23s Stiff Pereche Rosenbrock modificată (cu un pas), cu ordinele 2 şi 3
ode23t Stiff Regula implicită a trapezului, cu ordinele 2 şi 3
ode23tb Stiff Algoritm Runge-Kutta implicit, ordinele 2 şi 3

Argumentele de intrare sunt

• fun – specifică funcţia din membrul drept. În versiunile 6.x este un handler de funcţie, iar în
versiunile 5.x este un nume de funcţie (în acest caz se scrie ’fun’ nu @fun);
• tspan – vector ce specifică intervalul de integrare. Dacă este un vector cu două elemente
tspan=[t0 tfinal], rezolvitorul integrează de la t0 la tfinal. Dacă tspan are mai
mult de două elemente rezolvitorul returnează soluţiile în acele puncte. Abscisele trebuie
ordonate crescător sau descrescător. Rezolvitorul nu îşi alege paşii după valorile din tspan, ci

Pagina 2
 3 EDO în MATLAB

obţine valorile în aceste puncte prin prelungiri continue ale formulelor de bază care au acelaşi
ordin de precizie ca şi soluţiile calculate în puncte.
• optiuni – opţiunile permit setarea unor parametrii ai rezolvitorului şi se crează cu odeset.

Parametrii de ieşire sunt:

• t – vectorul coloană al absciselor;
• y – tabloul soluţiilor: o linie corespunde unei abscise, iar o coloană unei componente a
soluţiei.

După optiuni pot să apară parametrii variabili, p1, p2, ... care sunt transmişi funcţiei fun la
fiecare apel. De exemplu

[t,y]=rezolvitor(@fun,tspan,y0,optiuni,p1,p2,...)

apelează

fun(T,Y,flag,p1,p2,...).

1.2 Exemple
Să considerăm ecuaţia scalară
𝑦 ′ (𝑡) = −𝑦(𝑡) + 5𝑒 −𝑡 cos 5𝑡, 𝑦(0) = 0.

Pagina 3
 EDO în MATLAB 4

pentru ∈ [0,3]. Membrul drept este conţinut în fişierul f1scal.m:

function yder=f1scal(t,y)
%F1SCAL Exemplu de EDO scalara

yder = -y+5*exp(-t).*cos(5*t);

Vom folosi rezolvitorul ode45. Secvenţa de comenzi MATLAB

tspan = [0,3]; yzero=0;
[t,y]=ode45(@f1scal,tspan,yzero);
plot(t,y,'k--*')
xlabel('t'), ylabel('y(t)')
produce graficul din Figura 1. Soluţia exactă este () = −sin 5. Verificăm aceasta calculând
maximul modulului diferenţelor dintre valorile furnizate de ode45 şi valorile soluţiei exacte
calculate în abscisele furnizate de ode45:
norm(y-exp(-t).*sin(5*t),inf)

ans =
3.8416e-004

Pagina 4
 5 EDO în MATLAB

0.8

0.6

0.4

y(t)
0.2

-0.2

-0.4
0 0.5 1 1.5 2 2.5 3
t

Figura 1 Graficul pentru ecuaţia scalară

Să considerăm acum ecuaţia pendulului simplu

𝑑2 𝑔
𝜃 (𝑡 ) = − sin 𝜃 (𝑡),
𝑑𝑡 2 𝐿
unde este acceleraţia gravitaţională şi este lungimea pendulului. Această ecuaţie de ordinul al
doilea se poate transforma într-un sistem de ecuaţii de ordinul I, introducând necunoscutele 𝑦1 =
𝜃 (𝑡), 𝑦2 = 𝑑𝜃/𝑑𝑡.

Pagina 5
 EDO în MATLAB 6

𝑑
𝑦1 (𝑡) = 𝑦2 (𝑡)
{ 𝑑𝑡
𝑑 𝑔
𝑦1 (𝑡) = − sin 𝑦1 (𝑡)
𝑑𝑡 𝐿
Rezolvarea este data în fisierul pendul.m, dat în continuare:

%pendul
g=10; L=10;
pend = @(t,y) [y(2); -g/L*sin(y(1))];
tspan = [0,10];
yazero = [1; 1]; ybzero = [-5; 2];
yczero = [5; -2];
[ta,ya] = ode45(pend,tspan,yazero);
[tb,yb] = ode45(pend,tspan,ybzero);
[tc,yc] = ode45(pend,tspan,yczero);

[y1,y2] = meshgrid(-5:0.5:5,-3:0.5:3);
Dy1Dt = y2; Dy2Dt = -sin(y1);
quiver(y1,y2,Dy1Dt,Dy2Dt)
hold on
plot(ya(:,1),ya(:,2),yb(:,1),yb(:,2),yc(:,1),yc(:,2))
axis equal, axis([-5,5,-3,3])
xlabel y_1(t), ylabel y_2(t), hold off

Pagina 6
 7 EDO în MATLAB

Ec = 0.5*yc(:,2).^2-cos(yc(:,1));
max(abs(Ec(1)-Ec))
Pentru a obţine grafice de fază vom reprezenta pe 𝑦2 (𝑡) în funcţie de 𝑦1(𝑡) . Este sugestiv să
reprezentăm pe acelaşi grafic şi câmpul de vectori cu quiver. Săgeţile generate de quiver au
direcţia gradientului [𝑦2 , − sin 𝑦1 ] şi lungimea proporţională norma euclidiană a acestui vector.
Imaginea obţinută apare în figura 2.

Figura 2 Pendulul matematic

1
Orice soluţie a ecuaţiei pendulului conservă energia: cantitatea 𝑦22 (𝑡) − cos 𝑦1 (𝑡) este constantă.
2
Verificarea se face în ultimele doua linii.

Pagina 7
 EDO în MATLAB 8

1.3 Opţiuni
Funcţia odeset crează o structură de opţiuni care poate fi transmisă unui rezolvitor. Argumentele
lui odeset sunt perechi nume proprietate/valoare proprietate. Sintaxa este

optiuni=odeset(’nume1’, valoare1, ’nume2’, valoare2, ...)

Aceasta crează o structură de opţiuni în care proprietăţile cu numele dat primesc o valoare
specificată. Proprietăţile nespecificate primesc valori implicite. Pentru toate proprietăţile este
suficient să dăm doar caracterele de la început care identifică unic numele proprietăţii.
Apelul odeset fără argumente afişează toate numele de proprietăţi şi valorile lor posibile; valorile
implicite apar între acolade:

>> odeset
AbsTol: [ positive scalar or vector {1e-6} ]
RelTol: [ positive scalar {1e-3} ]
NormControl: [ on | {off} ]
NonNegative: [ vector of integers ]
OutputFcn: [ function_handle ]
OutputSel: [ vector of integers ]
Refine: [ positive integer ]
Stats: [ on | {off} ]
InitialStep: [ positive scalar ]
MaxStep: [ positive scalar ]

Pagina 8
 9 EDO în MATLAB

BDF: [ on | {off} ]
MaxOrder: [ 1 | 2 | 3 | 4 | {5} ]
Jacobian: [ matrix | function_handle ]
JPattern: [ sparse matrix ]
Vectorized: [ on | {off} ]
Mass: [ matrix | function_handle ]
MStateDependence: [ none | {weak} | strong ]
MvPattern: [ sparse matrix ]
MassSingular: [ yes | no | {maybe} ]
InitialSlope: [ vector ]
Events: [ function_handle ]
1.4 Tratarea evenimentelor
În multe situaţii, determinarea ultimei valori 𝑡𝑓𝑖𝑛𝑎𝑙 a lui tspan este un aspect important al
problemei. Un exemplu este căderea unui corp asupra căruia acţionează forţa gravitaţională şi
rezistenţa aerului. Când atinge el pământul?
Un alt exemplu este problema celor două corpuri, adică determinarea orbitei unui corp supus
atracţiei gravitaţionale a unui corp mult mai greu. Care este perioada orbitei? Facilitatea de
prelucrare a evenimentelor a rezolvitorilor din MATLAB furnizează răspunsuri la astfel de întrebări.
Detecţia evenimentelor în MATLAB presupune două funcţii 𝑓(𝑡, 𝑦) şi 𝑔(𝑡, 𝑦) şi o condiţie iniţială
(𝑡0 , 𝑦0 ). Problema este de a găsi o funcţie 𝑦(𝑡) şi o valoare finală 𝑡 ∗ astfel încât
𝑦 ′ = 𝑓(𝑡, 𝑦)
𝑦(𝑡0 ) = 𝑦0

Pagina 9
 EDO în MATLAB 10

𝑔(𝑡 ∗ , 𝑦(𝑡 ∗ )) = 0.
Un model simplu al unui corp în cădere este
𝑦 ′′ = −1 + 𝑦′2
cu o condiţie iniţială care dă valori pentru 𝑦(0) şi 𝑦′(0). Problema este pentru ce valori ale lui t
avem 𝑦(𝑡) = 0? Rezolvarea este în fişierul falling_body.m.
function falling_body(y0)
opts = odeset('events',@g);
[t,y,tfinal] = ode45(@f,[0,Inf],y0,opts);
tfinal
plot(t,y(:,1),'-',[0,tfinal],[1,0],'o')
axis([-0.1, tfinal+0.1, -0.1, max(y(:,1)+0.1)]);
xlabel t
ylabel y
title('Corp in cadere')
text(tfinal-0.8, 0, ['tfinal = ' num2str(tfinal)])
%-----
function ydot=f(t,y)
ydot = [y(2); -1+y(2)^2];
%-----
function [gstop,isterminal,direction] = g(t,y)
gstop = y(1);
isterminal = 1;
direction = 0; %[];

Pagina 10
 11 EDO în MATLAB

Funcţia f implementează membrul drept al ecuaţiei diferenţiale, iar g tratează evenimentele.

Primul argument de ieşire, gstop, este valoarea pe care dorim s-o anulăm. Dacă al doilea argument
de ieşire, isterminal, are valoarea 1, rezolvitorul va termina execuţia dacă gstop este zero.
Dacă isterminal = 0, evenimentul este înregistrat şi rezolvarea continu ă. direction poate
fi -1, 1 sau 0, după cum zeroul se atinge dacă funcţia este descresc ătoare, crescătoare sau
nemonotonă. Calculul şi reprezentarea traiectoriei se face în falling_body.
Pentru valoarea iniţială y0=[1; 0] se obţine
>> falling_body([1;0])
tfinal =
1.657456919958117
şi graficul din Figura 3.

Figura 3 Traiectoria unui corp în cădere

Pagina 11
 EDO în MATLAB 12

Detecţia evenimentelor este utilă în probleme ce presupun fenomene periodice. Problema celor
două corpuri este un exemplu bun. Ea descrie orbita unui corp asupra căruia acţionează forţa
gravitaţională a unui corp mult mai greu. Utilizând coordonate carteziene, 𝑢(𝑡) şi 𝑣(𝑡) cu originea în
corpul mai greu, ecuaţiile sunt:
𝑢(𝑡)
𝑢′′ (𝑡) = − ,
𝑟(𝑡)3
𝑣(𝑡)
𝑣 ′′ (𝑡) = − .
𝑟(𝑡)3
unde 𝑟(𝑡) = √𝑢(𝑡)2 + 𝑣(𝑡)2 . Întreaga rezolvare este conţinută într-un singur fişier de tip funcţie,
orbit.m (sursaMATLAB 10.6). Parametrul de intrare, reltol, este eroarea (precizia) relativă
dorită. Codificarea problemei twobody şi funcţia de tratare a evenimentelor gstop sunt date prin
subfuncţii (ele pot fi păstrate la fel de bine în fişiere separate). Calculul orbitei se realizează cu
ode45. Argumentul de intrare y0 este un vector cu 4 elemente, care dă poziţia iniţială şi viteza.
Corpul uşor porneşte din poziţia (1, 0) şi are viteza iniţială (0, 0.3), care este perpendiculară pe
vectorul poziţiei iniţiale. Argumentul opts este o structură creată cu odeset, care specifică
eroarea relativă (egală cu reltol) şi funcţia de tratare a evenimentelor gstop. Ultimul argument
al lui ode45 este o copie y0, transmisă atât lui twobody cât şi lui gstop. Vectorul bidimensional d
din gstop este diferenţa dintre poziţia curentă şi punctul de pornire. Viteza în poziţia curentă este
dată de vectorul bidimensional v, iar cantitatea val este produsul scalar al lui d şi v. Expresia
funcţiei de oprire este
𝑔(𝑡) = 𝑑′ (𝑡)𝑇 𝑑(𝑡),
unde

Pagina 12
 13 EDO în MATLAB

𝑑 = [𝑦1 (𝑡) − 𝑦1 (0), 𝑦2 (𝑡) − 𝑦2 (0)]𝑇 .

function orbit(reltol)
y0 = [1; 0; 0; 0.3];
opts = odeset('events', @gstop,'RelTol',reltol);
[t,y,te,ye] = ode45(@twobody,[0,2*pi], y0, opts, y0);
tfinal = te(end)
yfinal = ye(end,1:2)
plot(y(:,1),y(:,2),'-',0,0,'ro')
axis([-0.1 1.05 -0.35 0.35])

%----------

function ydot = twobody(t,y,y0)

r = sqrt(y(1)^2 + y(2)^2);
ydot = [y(3); y(4); -y(1)/r^3; -y(2)/r^3];

%--------

function [val,isterm,dir] = gstop(t,y,y0)

d = y(1:2)-y0(1:2);
v = y(3:4);
val = d'*v;
isterm = 1;

Pagina 13
 EDO în MATLAB 14

dir = 1;
Punctele în care 𝑔(𝑡, 𝑦(𝑡)) = 0 sunt extreme locale ale lui 𝑑(𝑡). Punând dir = 1, vom indica
că zerourile lui 𝑔(𝑡, 𝑦)sunt atinse de sus, ceea ce corespunde minimelor. Setând isterm= 1, vom
indica faptul că procesul de calcul trebuie oprit la întâlnirea primului minim. Dacă orbita este
periodică, atunci orice minim al lui 𝑑 apare când corpul se întoarce în punctul iniţial.
Apelând orbit cu o precizie mică
>> orbit(2e-3)
se obţine
tfinal =
2.350871977621059
yfinal =
0.981076599012211 -0.000125191385552
şi graficul din figura 10.14(a). Se poate observa din valoarea lui yfinal şi din grafic o abatere de la
periodicitate. Avem nevoie de o precizie mai bună. Cu comanda
>> orbit(1e-6)
se obţine
tfinal =
2.380258461718048
yfinal =
0.999985939055227 0.000000000322400
Valoarea yfinal este acum suficient de apropiată de y0, iar graficul arată mult mai bine (figura
10.14(b)).

Pagina 14
 15 EDO în MATLAB

1. Probleme cu valori pe frontieră

Funcţia bvp4c utilizează metoda colocaţiei pentru a rezolva sisteme de ecuaţii diferenţiale cu
condiţii pe frontieră. Acestea pot fi scrise sub forma
𝑑
𝑦(𝑥 ) = 𝑓(𝑥, 𝑦(𝑥 ), 𝑝), 𝑔(𝑦(𝑎), 𝑦(𝑏), 𝑝) = 0.
𝑑𝑥
y este un vector funcţie cu m componente, f este o funcţie de x şi y care are ca rezultat un m-vector,
iar p, opţional, este un vector de parametrii care trebuie determinaţi. Soluţia se caută pe intervalul
𝑎 ≤ 𝑥 ≤ 𝑏, iar funcţia 𝑔, dată, specifică condiţiile pe frontieră. În general, problemele cu valori pe

Pagina 15
 EDO în MATLAB 16

frontieră sunt mult mai dificil de rezolvat numeric decât problemele cu valori iniţiale. bvp4c
necesită o soluţie iniţială de pornire. Soluţia iniţială şi cea finală se păstrează în structuri.
Vom începe cu o problemă scalară care descrie secţiunea transversală a unei picături de apă pe o
suprafaţă plană:
3
2 2
𝑑2 𝑑
ℎ (𝑥 ) + (1 − ℎ (𝑥 ) ) (1 + ( ℎ(𝑥 )) ) = 0, ℎ(−1) = ℎ(1) = 0.
𝑑𝑥 2 𝑑𝑥
ℎ(𝑥) semnifică înalţimea picăturii în punctul 𝑥. Punem 𝑦1 (𝑥 ) = ℎ(𝑥), 𝑦2 (𝑥 ) = 𝑑ℎ(𝑥)/𝑑𝑥 şi
rescriem ecuaţia sub forma unui sistem de două ecuaţii de ordinul I
𝑑
𝑦 (𝑥 ) = 𝑦2 (𝑥 )
𝑑𝑥 1
3
𝑑 2
𝑦2 (𝑥 ) = (𝑦1 (𝑥 ) − 1)(1 + 𝑦22 (𝑥 ))
𝑑𝑥
Acest sistem se reprezintă prin funcţia
function yprime=drop(x,y)
%DROP ODE/BVP picatura de apa
%apel yprime=drop(x,y)

yprime = [y(2); (y(1)-1)*((1+y(2)^2)^(3/2)];

Condiţiile iniţiale se dau sub formă reziduală

function res=dropbc(ya,yb)

Pagina 16
 17 EDO în MATLAB

%DROPBC ODE/BVP conditii pe frontiera picatura de apa

%apel res=dropbc(ya,yb)

res = [ya(1); yb(1)];

−𝑥
Vom alege ca valori de pornire (soluţii iniţiale) funcţiile 𝑦1 (𝑥 ) = √1 − 𝑥 2 şi 𝑦2 (𝑥 ) = .
0.1+√1−𝑥 2
(fisierul dropinit.m)
function yinit = dropinit(x)
%DROPINIT ODE/BVP solutii initiale picatura de apa
%apel yinit = dropinit(x)

yinit = [sqrt(1-x^2); -x/(0.1+sqrt(1-x^2))];

Urmeaza scriptul care rezolvă problema şi desenează soluţia (waterdrop.m)
%WATERDROP - water droplet BVP

solinit = bvpinit(linspace(-1,1,20),@dropinit);
sol = bvp4c(@drop, @dropbc, solinit);
fill(sol.x, sol.y(1,:),[0.7, 0.7, 0.7])
axis([-1, 1, 0, 1])
xlabel('x', 'Fontsize',16)
ylabel('y','Rotation',0,'FontSize',16)

Exemplu de utilizare, vezi figura 1.

waterdrop

Pagina 17
 EDO în MATLAB 18

În general, bvp4c se apelează sub forma

sol = bvp4c(@odefun, @bcfun, solinit, options)
1

0.9

0.8

0.7

0.6
y 0.5
0.4

0.3

0.2

0.1

0
-1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4 0.6 0.8 1
x Figura 41

Funcţia odefun descrie ecuaţia diferenţială, iar bcfun dă reziduurile pentru condiţiile iniţiale. Ele
returnează vectori coloană. Forma generală a lui odefun este
yprime = odefun(x,y)
iar a lui bcfun
res=bcfun(ya,yb).

Pagina 18
 19 EDO în MATLAB

Structura pentru soluţia iniţială, solinit, are două câmpuri solinit.x şi solinit.y.
Valorile solinit.x dau abscisele soluţiei iniţiale, solinit.x(1) şi solinit.x(end)
conţinând a şi respectiv b. Corespunzător, solinit.y(:,i) dă soluţia iniţială în
solinit.x(i). Funcţia auxiliară bvpinit crează o structură pentru soluţia iniţială. Celelalte
argumente ale lui bvp4c sunt opţionale. Structura options pemite specificarea diverşilor
parametrii ai algoritmului de colocaţie, cum ar fi toleranţele, valori iniţiale, numărul maxim de
puncte. Ea poate fi creată cu bvpset, similară cu odeset. (vezi doc bvpset).
Parametrul de ieşire sol este o structură.
sol.x(i)abscisa,
sol.y(:,i) ordonata,
sol.yp(:,i) aproximarea derivatei

Alt exemplu este

𝑑2
𝜃 (𝑥 ) + 𝜆 sin 𝜃(𝑥) cos 𝜃 (𝑥 ) = 0, 𝜃 (−1) = 𝜃 (1) = 0;
𝑑𝑥 2
el apare în teoria cristalelor lichide.

function lcrun
%LCRUN Liquid crystal BVP.
% Solves the liquid crystal BVP for four different lambda values.

lambda_vals = [2.4, 2.5, 3, 10];

Pagina 19
 EDO în MATLAB 20

lambda_vals = lambda_vals(end:-1:1); %Necessary order for

%continuation.

solinit = bvpinit(linspace(-1,1,20),@lcinit);
lambda = lambda_vals(1); sola = bvp4c(@lc,@lcbc,solinit);
lambda = lambda_vals(2); solb = bvp4c(@lc,@lcbc,sola);
lambda = lambda_vals(3); solc = bvp4c(@lc,@lcbc,solb);
lambda = lambda_vals(4); sold = bvp4c(@lc,@lcbc,solc);
plot(sola.x,sola.y(1,:),'-', 'LineWidth',4), hold on
plot(solb.x,solb.y(1,:),'--','LineWidth',2)
plot(solc.x,solc.y(1,:),'--','LineWidth',4)
plot(sold.x,sold.y(1,:),'--','LineWidth',6), hold off
legend([repmat('\lambda = ',4,1) num2str(lambda_vals')])
xlabel('x','FontSize',16)
ylabel('\theta','Rotation',0,'FontSize',16)
ylim([-0.1 1.5])

function yprime = lc(x,y)

%LC ODE/BVP liquid crystal system.
yprime = [y(2); -lambda*sin(y(1))*cos(y(1))];
end

end

Pagina 20
21 EDO în MATLAB

function res = lcbc(ya,yb)

%LCBC ODE/BVP liquid crystal boundary conditions.
res = [ya(1); yb(1)];
end

function yinit = lcinit(x)

%LCINIT ODE/BVP liquid crystal initial guess.
yinit = [sin(0.5*(x+1)*pi); 0.5*pi*cos(0.5*(x+1)*pi)];
end
lcrun

Pagina 21
 EDO în MATLAB 22

1.5
 = 10
= 3
 = 2.5
 = 2.4
1

0.5

-1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4 0.6 0.8 1

x Figura 5. Problema cu cristale lichide pentru diverse valori ale lui λ
Am ales să scriem codul pentru soluţie sub forma unui singur fişier .m şi să scriem odefun, bcfun şi
solinit sub forma unor funcţii imbricate. În acest mod λ este accesibil în toate funcţiile. Valorile
(𝑥+1)𝜋
pentru λ sunt ordonate descrescător. Soluţia de pornire pentru 𝜆 = 10 este 𝑦1 (𝑥 ) = sin şi
2
𝜋 (𝑥+1)𝜋
𝑦2 (𝑥 ) = cos . Pentru celelate valori ale lui λ folosim ca soluţie de pornire soluţia finală
2 2
pentru valoarea precedentă. Tehnica se numeşte continuare în parametrul λ şi este o metodă utilă în
cazul problemelor grele. Dacă λ sunt ordonate crescător se obţine de fiecare dată soluţia trivială.

Pagina 22
 23 EDO în MATLAB

Ultimul exemplu este o problemă de valori proprii referitoare la o problemă cu valori pe frontieră.
Ecuaţia diferenţială este
𝑑2 𝑦(𝑥)
+ 𝜇𝑦(𝑥 ) = 0,
𝑑𝑥 2
cu condiţiile
𝑦(0) = 0, 𝑦 ′ (0) = 0, 𝑦(1) + 𝑦 ′ (1) = 0.
Această ecuaţie modelează deplasarea unei frânghii fixate în 𝑥 = 0, cu suport elastic în 𝑥 = 1 şi se
roteşte cu viteză unghiulară uniformă în jurul poziţiei de echilibru de pe axa Ox. Problema este o
problemă de valori proprii deoarece trebuie să găsim o valoare a parametrului 𝜇 pentru care există o
soluţie. Putem privi cele două condiţii în 𝑥 = 0 ca definid o problemă cu valori iniţiale şi să
încercăm să determinăm valorile lui 𝜇 pentru care soluţia verifică condiţia în 𝑥 = 1. Problema se
rescrie sub forma unui sistem de două EDO de ordinul I, iar soluţiile de pornire sunt 𝑦1 (𝑥 ) =
sin 𝑥, 𝑦2 (𝑥 ) = cos 𝑥 . Valorea de pornire 𝜇 = 5 se specifică ca parametru suplimentar în bvpinit.

function sol = skiprun

%SKIPRUN Skipping rope BVP/eigenvalue example.

solinit = bvpinit(linspace(0,1,10),@skipinit,5);
sol = bvp4c(@skip,@skipbc,solinit);
plot(sol.x,sol.y(1,:),'-', sol.x,sol.yp(1,:),'--', 'LineWidth',4)
xlabel('x','FontSize',12)
legend('y_1','y_2')

Pagina 23
 EDO în MATLAB 24

% ------------------------ Subfunctions ------------------------

function yprime = skip(x,y,mu)
%SKIP ODE/BVP skipping rope example.
% YPRIME = SKIP(X,Y,MU) evaluates derivative.
yprime = [y(2); -mu*y(1)];

function res = skipbc(ya,yb,mu)

%SKIPBC ODE/BVP skipping rope boundary conditions.
% RES = SKIPBC(YA,YB,MU) evaluates residual.
res = [ya(1); ya(2)-1; yb(1)+yb(2)];

function yinit = skipinit(x)

%SKIPINIT ODE/BVP skipping rope initial guess.
% YINIT = SKIPINIT(X) evaluates initial guess at X.
yinit = [sin(x); cos(x)];

skiprun
ans =
struct with fields:

solver: 'bvp4c'

Pagina 24
25 EDO în MATLAB

x: [0 0.1111 0.2222 0.3333 0.4444 0.5556 0.6667 0.7778

0.8889 1]
y: [2×10 double]
yp: [2×10 double]
parameters: 4.1159
stats: [1×1 struct]

Pagina 25