Skip to article frontmatterSkip to article content
Site not loading correctly?

This may be due to an incorrect BASE_URL configuration. See the MyST Documentation for reference.

Numerično reševanje diferencialnih enačb - robni problem

Fakulteta za strojništvo, Univerza v Ljubljani

Reševanje dvotočkovnih robnih problemov

Pod dvotočkovnim robnim problemom razumemo navadno diferencialno enačbo drugega reda oblike:

y¨=f(t,y,y˙),\ddot y=f(t, y, \dot y),

ob predpisanih robnih pogojih:

y(a)=αiny(b)=β.y(a)=\alpha\qquad\textrm{in}\qquad y(b)=\beta.

Metode, ki smo jih spoznali pri reševanju začetnih problemov, tukaj neposredno niso uporabne, ker nimamo podanega odvoda v začetni točki pri t=at=a.

V nadaljevanju si bomo pogledali dva različna pristopa k reševanju robnih problemov:

  1. t. i. strelska metoda,

  2. metoda končnih razlik.

Strelska metoda

Rešujemo robni problem:

y¨=f(t,y,y˙),y(a)=α,y(b)=β,\ddot y=f(t, y, \dot y),\qquad y(a)=\alpha,\quad y(b)=\beta,

ki ga prevedemo na začetni problem tako, da si izberemo:

y˙(a)=u.\dot y (a)=u.

Problem rešimo z numeričnimi metodami reševanja začetnega problema in rešitev označimo z θ(u,t)\theta(u, t).

Robni problem rešimo, ko izberemo uu tako, da velja:

r(u)=θ(u,b)−β=0.r(u)=\theta(u,b)-\beta=0.

Dobili smo nelinearno enačbo, ki jo moramo rešiti; za izračun vrednosti mejnih preostankov r(u)r(u) moramo numerično rešiti začetni problem.

Za rešitev enačbe r(u)=0r(u)=0 lahko uporabimo sekantno metodo. Izberemo u0u_0 in u1u_1 in na ii-tem koraku izračunamo:

ui+1=ui−r(ui) ui−ui−1r(ui)−r(ui−1),i=2,3,…u_{i+1}=u_i-r(u_i)\,\frac{u_{i}-u_{i-1}}{r(u_{i})-r(u_{i-1})},\qquad i=2,3,\dots

Zaključimo, ko je:

∣r(ui+1)∣<ϵ.\left|r(u_{i+1})\right|<\epsilon.

Rešitev strelske metode je obremenjena z napako metode reševanja nelinearne enačbe ϵ\epsilon in z napako numerične metode za reševanje začetnega problema.

Numerični zgled: poševni met

Na sliki je prikazan izstrelek mase mm, ki ga izstrelimo s hitrostjo v0\textbf{v}_0. Poševni met

Velikost sile upora zraka je ∣F∣=c ∣v∣2|\textbf{F}|=c\,|\textbf{v}|^2, potem sta gibalni enačbi:

x′′(t)=Fx/my′′(t)=Fy/m−g.x''(t)=F_x/m\qquad y''(t)=F_y/m-g.

Komponente sile so (glejte izpeljavo pri poglavju iz reševanja začetnega problema sistema diferencialnih enačb):

Fx=−c x′ x′2+y′2,Fy=−c y′ x′2+y′2.F_x=-c\,x'\,\sqrt{x'^2+y'^2},\qquad F_y=-c\,y'\,\sqrt{x'^2+y'^2}.

Vertikalni met

Najprej predpostavimo, da je φ=90\varphi=90° in torej v xx smeri nimamo gibanja. Zanima nas rešitev, ko izstrelek izstrelimo iz višine y=0y=0 m in mora pri času t=b=1t=b=1 s biti na višini y(b)=10y(b)=10 m. Definirali smo robni problem:

y′′(t)=Fy /m−g,y(0)=0,y(1)=10.y''(t)=F_y\,/m-g,\qquad y(0)=0,\quad y(1)=10.

Najprej moramo enačbo drugega reda:

y′′=f(t,y,y′)=Fy/m−gy''=f(t, y, y') = F_y/m-g

preoblikovati na sistem dveh enačb prvega reda. Uporabimo yi=y(i)y_i=y^{(i)} ter upoštevamo Fy=−c y′ y′2F_y=-c\,y'\,\sqrt{y'^2}.

Odvajamo yi′=yi+1y_i'=y_{i+1} in pripravimo sistem enačb prvega reda:

y0′=y1y1′=−c y1 y12/m−g\begin{array}{rcl} y'_0&=&y_1\\ y'_1&=&-c\,y_1\,\sqrt{y_1^2}/m-g \end{array}

Uvozimo modula numpy in scipy.integrate.solve_ivp:

Pripravimo seznam funkcij desnih strani:

ter pripravimo funkcijo za izračun mejnega preostanka pri času bb v odvisnosti od začetne hitrosti v0v_0 (privzeti zračni upor je c=0.1c=0.1):

Preverimo mejni preostanek pri začetnem pogoju v0=y′=50v_0=y'=50 m/s:

np.float64(5.63455093999735)

Opazimo, da je masa pri 1 sekundi 5,635 m nad ciljno višino.

Naš cilj je, da pri 1 sekundi masa doseže lego 10 m z natančnostjo 1e-6:

Izvedimo sedaj sekantno metodo:

Novi približek je v0=5.644178759347113, napaka je -9.672536331804414.
Novi približek je v0=33.67258709458857, napaka je 2.2187017725280302.
Novi približek je v0=28.442965190719487, napaka je 0.8225839451367332.
Novi približek je v0=25.361704474139284, napaka je -0.10153714557803362.
Novi približek je v0=25.70025579721459, napaka je 0.004276366407131249.
Novi približek je v0=25.686573522825174, napaka je 2.16308919487318e-05.
Novi približek je v0=25.686503962731987, napaka je -4.623860405672531e-09.
Rešitev v0=25.686503962731987

Poglejmo si sedaj izračunano rešitev:

Zgoraj smo uporabili lambda izraz (dokumentacija). Izraz lambda t, y: f_vert(t, y, c=0.1) je ekvivalenten:

def ime_funkcije(t, y):
    return f_vert(t, y, c=0.1)

Uvozimo matplotlib:

Prikažemo rezultat:

<Figure size 640x480 with 1 Axes>

Poševni met

Poglejmo si sedaj splošen poševni met (diferencialne enačbe so definirana že zgoraj). Najprej moramo sistem diferencialnih enačb drugega reda preoblikovati v sistem enačb prvega reda.

Uporabimo:

y0=x, y1=x′, y2=y, y3=y′y_0=x,~ y_1=x',~ y_2=y,~ y_3=y'

in dobimo sistem diferencialnih enačb prvega reda:

y0′=y1y1′=Fx/my2′=y3y3′=Fy/m−g.\begin{array}{rcl} y_0'&=&y_1\\ y_1'&=&F_x/m\\ y_2'&=&y_3\\ y_3'&=&F_y/m-g.\\ \end{array}

Pripravimo seznam funkcij desnih strani:

Pripravimo še funkcijo za izračun mejnega preostanka pri času b=1b=1 v odvisnosti od vektorja začetne hitrosti v0\mathbf{v}_0:

Preverimo mejni preostanek pri začetnem pogoju v0=[100.,100.]\mathbf{v}_0=[100., 100.] m/s:

array([ 9.66195325, 11.84726075])

Za iskanje korena sistema nelinearnih funkcij smo že spoznali funkcijo scipy.optimize.root (dokumentacija):

root(fun, x0, args=(), method='hybr', jac=None,
     tol=None, callback=None, options=None)

Najprej jo uvozimo:

Potem uporabimo z začetnim ugibanjem v0\mathbf{v}_0:

Rešitev je:

message: The solution converged. success: True status: 1 fun: [ 1.155e-13 -3.260e-13] x: [ 1.938e+01 1.655e+01] method: hybr nfev: 19 fjac: [[-9.339e-01 3.575e-01] [-3.575e-01 -9.339e-01]] r: [-4.078e-01 2.409e-01 -3.754e-01] qtf: [ 1.067e-09 -1.311e-09]

Atribut rešitev.x vsebuje vektor izračunanih rešitev ([19.37894314, 16.55482478]). Preverimo mejni preostanek pri izračunani rešitvi:

array([ 1.15463195e-13, -3.25961480e-13])

Poglejmo si sedaj izračunano rešitev:

Prikažemo rezultat:

<Figure size 640x480 with 1 Axes>

Uporaba scipy.integrate.solve_bvp

Namesto scipy.integrate.solve_ivp in scipy.optimize lahko uporabimo vgrajeno funkcijo za reševanje robnih problemov scipy.integrate.solve_bvp (BVP - angl. Boundary Value Problem):

scipy.integrate.solve_bvp(fun, bc, x, y, 
                          p=None, S=None, fun_jac=None, bc_jac=None, 
                          tol=0.001, max_nodes=1000, verbose=0)

Pojasnilo vseh argumentov je v dokumentaciji, tukaj bomo izpostavili nekatere:

  • fun je desna stran (func(t, y...)),

  • bc je mejni preostanek: bc(y(a), y(b)) = 0

  • x numerično polje (dimenzija (m)) neodvisne spremenljivke x[0]=a in x[-1]=b,

  • y numerično polje (dimenzija (n, m)) začetnih vrednosti.

Rezultat klicanja solve_bvp je objekt z atributi (izbrani):

  • x vrednosti neodvisne spremenljivke pri katerih je izračunan rezultat,

  • y rezultat,

  • sol rezultat v obliki kubičnega zlepka,

  • success je True, če je rešitev konvergirala.

Poglejmo primer:

Definirajmo neodvisno spremenljivko

In mejni preostanek (želimo, da je pri času b lega x=10x=10 m in y=5y=5 m):

Definirajmo še začetne vrednosti hitrosti (kot začetno ugibanje):

array([[ 0., 0., 0.], [ 5., 5., 5.], [ 0., 0., 0.], [100., 100., 100.]])

In rešimo robni problem in opis rezultata

message: The algorithm converged to the desired accuracy. success: True status: 0 x: [ 0.000e+00 2.381e-02 ... 9.762e-01 1.000e+00] sol: <scipy.interpolate._interpolate.PPoly object at 0x7e3e20de7a10> p: None y: [[-1.588e-22 4.482e-01 ... 9.853e+00 1.000e+01] [ 1.939e+01 1.828e+01 ... 6.210e+00 6.117e+00] [-3.176e-22 3.801e-01 ... 5.031e+00 5.000e+00] [ 1.656e+01 1.539e+01 ... -1.189e+00 -1.403e+00]] yp: [[ 1.939e+01 1.828e+01 ... 6.210e+00 6.117e+00] [-4.944e+01 -4.369e+01 ... -3.926e+00 -3.839e+00] [ 1.656e+01 1.539e+01 ... -1.189e+00 -1.403e+00] [-5.205e+01 -4.659e+01 ... -9.058e+00 -8.929e+00]] rms_residuals: [ 4.302e-05 3.582e-05 ... 1.297e-06 4.151e-06] niter: 2

Prikažimo rezultat:

<Figure size 640x480 with 1 Axes>

Numerični zgled: nosilec z obremenitvijo

Poglejmo si nosilec: Nosilec

Poves w(x)w(x) nosilca popiše diferencialna enačba četrtega reda:

−E Id4dx4w(x)+q(x)=0.-E\,I\frac{\textrm{d}^4}{\textrm{d}x^4}w(x)+q(x)=0.

Znane konstante so E,I,lE,I,l in je q(x)q(x) porazdeljena obremenitev.

Robni pogoji (členkasto vpet nosilec):

w(0)=w(l)=0inw′′(0)=w′′(l)=0w(0)=w(l)=0\quad\textrm{in}\quad w''(0)=w''(l)=0

Parametri so:

  • I=2.1⋅10−5I=2.1\cdot10^{-5} m 4^4,

  • E=2.1⋅1011E=2.1\cdot10^{11} N/m 2^2,

  • l=10l=10 m.

Porazdeljena obremenitev q(x)q(x) bo definirana pozneje.

Najprej moramo diferencialno enačbo četrtega reda preoblikovati v sistem diferencialnih enačb prvega reda. Uporabimo:

y0=w, y1=w′, y2=w′′, y3=w′′′y_0=w,~ y_1=w',~ y_2=w'',~ y_3=w'''

in dobimo sistem diferencialnih enačb prvega reda:

y0′=y1y1′=y2y2′=y3y3′=q(x)/(EI).\begin{array}{rcl} y_0'&=&y_1\\ y_1'&=&y_2\\ y_2'&=&y_3\\ y_3'&=&q(x)/(EI).\\ \end{array}

Pripravimo različne porazdeljene obremenitve:

Definirajmo dolžino (ostale parametre, I,EI, E, bomo uporabili privzete):

<Figure size 640x480 with 1 Axes>

Pripravimo seznam funkcij desne strani:

Definirajmo sedaj robne pogoje oz. mejni preostanek (poves in moment sta na robovih enaka nič):

Definirajmo še začetne vrednosti naklona (w′w') in strižne sile (w′′′w''') (kot začetno ugibanje):

In rešimo robni problem (za vse tri tipe obremenitve):

Rezultat prikažimo za konstantno obremenitev:

<Figure size 640x480 with 1 Axes>

In primerjavo povesa za različne tipe obremenitve:

<Figure size 640x480 with 1 Axes>

Metoda končnih razlik

Loading...

Rešujemo robni problem:

y′′=f(t,y,y′),y(a)=α,y(b)=β.y''=f(t, y, y'),\qquad y(a)=\alpha,\quad y(b)=\beta.

Velja torej:

a=t0,b=tn−1.a=t_0,\quad b=t_{n-1}.

Pri metodi končnih razlik za reševanje robnega problema uporabimo diferenčno shemo. Predpostavimo, da imamo interval [a,b][a,b], na katerem rešujemo diferencialno enačbo (neodvisna spremenljivka) razdeljeno na enake podintervale (točk je nn):

t=[t0,t1,…,tn−1].t=[t_0, t_1,\dots, t_{n-1}].

Odvode nadomestimo s centralno diferenčno shemo:

Odvod ↓\downarrow \\backslash Vrednosti →\rightarrowyi−2y_{i-2}yi−1y_{i-1}yiy_{i}yi+1y_{i+1}yi+2y_{i+2}
yi′=1h⋅y_i'=\frac{1}{h}\cdot0-0.500.50
yi′′=1h2⋅y_i''=\frac{1}{h^2}\cdot01-210
yi′′′=1h3⋅y_i'''=\frac{1}{h^3}\cdot-0.510-10.5
yi(4)=1h4⋅y_i^{(4)}=\frac{1}{h^4}\cdot1-46-41

Prikazana centralna diferenčna shema ima napako drugega reda O(h2)\mathcal{O}(h^{2}).

V ii-ti točki navadno diferencialno enačbo drugega reda s centralnimi diferencami zapišemo:

1h2(yi−1−2 yi+yi+1)+O(h2)=f(ti,yi,12h(−yi−1+yi+1)+O(h2)).\frac{1}{h^2}\left(y_{i-1}-2\,y_{i}+y_{i+1}\right)+\mathcal{O}(h^{2})=f\left(t_i, y_i, \frac{1}{2h}\left(-y_{i-1}+y_{i+1}\right)+\mathcal{O}(h^{2})\right).

Če zanemarimo napako metode:

1h2(yi−1−2 yi+yi+1)=f(ti,yi,12h(−yi−1+yi+1)),i=1,2,…,n−2.\frac{1}{h^2}\left(y_{i-1}-2\,y_{i}+y_{i+1}\right)=f\left(t_i, y_i, \frac{1}{2h}\left(-y_{i-1}+y_{i+1}\right)\right),\qquad i=1,2,\dots,n-2.

Zgornjo enačbo lahko zapišemo za n−2n-2 notranjih točk, kar pomeni, da nam do rešljivega sistema enačb za nn neznank manjkata še dve enačbi. Ti dve enačbi sta robna pogoja:

y0=α,yn−1=β.y_0=\alpha,\quad y_{n-1}=\beta.

V primeru linearnega robnega problema moramo za izračun nn neznank yiy_i rešiti sistem nn linearnih enačb (če je pa nelinearen, pa sistem nelinearnih enačb).

Ocena napake

Točen rezultat y(ti)y(t_{i}) pri velikosti koraka hh je:

y(ti)=yi,h+Ei,h,y(t_{i})=y_{i,h}+E_{i,h},

kjer je yi,hy_{i,h} numerični približek in EhE_h napaka metode. Ker je globalna napaka drugega reda, lahko napako zapišemo:

Ei,h=k h2,E_{i,h}=k\,h^2,

Podobno lahko za velikost koraka 2h2h zapišemo:

y(tj)=yj,2h+Ej,2h,y(t_{j})=y_{j,2h}+E_{j,2h},

kjer je yj,2hy_{j,2h} numerični približek in E2hE_{2h} napaka metode in je:

Ej,2h=k (2 h)2=4 k h2E_{j,2h}=k\,(2\,h)^2=4\,k\,h^2

Ob predpostavki, da je konstanta kk pri koraku hh in koraku 2h2h enaka, lahko določimo oceno napake pri boljšem približku EhE_h. Najprej izenačimo točna rezultat y(ti)y(t_{i}) pri koraku hh in rezultat y(tj)y(t_{j}) pri koraku 2h2h (velja i=2 ji=2\,j, j=1,2,…j=1,2,\dots):

yi,h+k h2=yj,2h+4 k h2y_{i,h}+k\,h^2=y_{j,2h}+4\,k\,h^2

sledi:

3 k h2=y2j,h−yj,2h3\,k\,h^2=y_{2j,h}-y_{j,2h}

in nato izračunamo oceno napake:

Ej,h=y2j,h−yj,2h3.E_{j,h}=\frac{y_{2j,h}-y_{j,2h}}{3}.

Numerični zgled: vertikalni met

Zgoraj smo vertikalni met rešili s strelsko metodo; uporabimo sedaj metodo končnih razlik. Najprej robni problem:

y′′(t)=Fy/m−g,y(0)=0,y(1)=10.y''(t)=F_y/m-g,\qquad y(0)=0,\quad y(1)=10.

zapisati s pomočjo centralne diferenčne sheme (Fy=−c y′F_y=-c\,y'):

1h2(yi−1−2 yi+yi+1)=−c(12h(−yi−1+yi+1))/m−g.\frac{1}{h^2}\left(y_{i-1}-2\,y_{i}+y_{i+1}\right)= -c\left(\frac{1}{2h}\left(-y_{i-1}+y_{i+1}\right)\right)/m-g.

(Tukaj smo predpostavili, da je zračni upor linearno odvisen od hitrosti. V nasprotnem primeru bi imeli nelinearni robni problem, in posledično razvili sistem nelinearnih enačb.)

Zgornji izraz preoblikujemo:

(2−c h/m) yi−1−4 yi+(2+c h/m) yi+1=−2 g h2,i=1,2,…,n−2.(2-c\,h/m)\,y_{i-1}-4\,y_{i}+(2+c\,h/m)\,y_{i+1}=-2\,g\,h^2,\qquad i=1,2,\dots,n-2.

Robna pogoja sta:

y0=0,yn−1=10y_0=0,\qquad y_{n-1}=10

Robni problem smo torej preoblikovali na sistem nn linearnih enačb. Poglejmo si sedaj konkreten izračun za n=11n=11; najprej definirajmo konstante, časovni vektor t in korak h:

Nato nadaljujemo z izračunom tridiagonalne matrike koeficientov A.

Pomagamo si s funkcijo numpy.diag() (dokumentacija):

numpy.diag(v, k=0)

s parametroma:

  • v vektor, ki bo prirejen diagonali,

  • k diagonala, kateri se priredi v. k=0 uporabimo za glavno diagonalo, k<0 oz. k>0 uporabimo za diagonale pod oz. nad glavno diagonalo.

array([[-4. , 2.05, 0. , 0. ], [ 1.95, -4. , 2.05, 0. ], [ 0. , 1.95, -4. , 2.05], [ 0. , 0. , 1.95, -4. ]])

Definirajmo še vektor konstant:

Sedaj popravimo matriko koeficientov A in vektor konstant b, da zadostimo robnim pogojem:

y0=0,yn−1=10.y_0=0,\quad y_{n-1}=10.

Rešimo sistem linearnih enačb:

Prikažemo rezultat:

<Figure size 640x480 with 1 Axes>

S pomočjo funkcije numpy.gradient() izračunamo še hitrost in pospešek:

array([17.99109496, 16.20009044, 14.45276895, 12.79068266])

Izračunajmo sedaj še rezultat z dvojnim korakom:

Primerjajmo prvih šest rezultatov pri koraku 2h2h:

array([ 0. , 3.24082594, 5.7992875 , 7.74037178, 9.12287659, 10. ])

z vsakim drugim rezultatom pri koraku hh:

array([ 0. , 3.24001809, 5.79815462, 7.73931207, 9.12221538, 10. ])

Sedaj lahko ocenimo napako:

array([ 0. , -0.00026928, -0.00037763, -0.00035324, -0.0002204 , 0. ])

Numerični zgled: nosilec z obremenitvijo

Vrnimo se k robnemu problemu nosilca s polsinusno obremenitvijo (q(x)=−F0 sin⁡(π x/l))q(x)=-F_0\,\sin(\pi\,x/l))), ki smo ga že obravnavali s strelsko metodo.

Diferencialno enačbo četrtega reda zapišemo s pomočjo centralne diferenčne sheme (za ii-to točko):

−E Ih4(1 wi−2−4 wi−1+6 wi−4 wi+1+1 wi+2)−F0 sin⁡(π xi/l)=0.-\frac{E\,I}{h^4}\left(1\,w_{i-2} - 4\,w_{i-1} + 6\,w_{i} - 4\,w_{i+1} + 1\, w_{i+2}\right) - F_0\,\sin(\pi\,x_i/l)= 0.

Robni pogoji so štirje, najprej poves na robovih:

w0=wn−1=0w_0=w_{n-1}=0

Ker na robovih ni momenta, je drugi odvod nič. S centralno diferenčno shemo torej zapišemo dodatne enačbe:

w−1−2 w0+w1=0wn−2−2 wn−1+wn=0.w_{-1}-2\,w_{0}+w_{1}=0\qquad w_{n-2}-2\,w_{n-1}+w_{n}=0.

Če za neodvisno spremenljivko xx uporabimo nn ekvidistantnih točk, potem diferencialno enačbo četrtega reda zapišemo za n−2n-2 notranje točke. S tem pridobimo dodatni nefizikalni točki w−1w_{-1} in wnw_n. Če dodamo še štiri robne pogoje, imamo rešljiv sistem linearnih enačb z n+2n+2 neznakami in n+2n+2 enačbami.

Najprej pripravimo podatke, neodvisno spremenljivko x in korak h:

Nato pripravimo matriko koeficientov (matrika je dimenzije (n, n), v prvi in v zadnji dve vrstici bi lahko zapisali tudi vrednosti 0, to bomo pozneje popravili):

array([[ 6., -4., 1., 0.], [-4., 6., -4., 1.], [ 1., -4., 6., -4.], [ 0., 1., -4., 6.]])

Definirajmo še vektor konstant (dodamo en element na koncu in en na začetku):

array([ 0.00000000e+00, 0.00000000e+00, -7.48966545e-10, -1.49717894e-09])

Sedaj popravimo matriko koeficientov A in vektor konstant b, da zadostimo robnim pogojem.

Najprej w0=wn−1=0w_0=w_{n-1}=0:

Nato w−1−2 w0+w1=0w_{-1}-2\,w_{0}+w_{1}=0 in wn−2−2 wn−1+wn=0w_{n-2}-2\,w_{n-1}+w_{n}=0:

array([[ 0., 1., 0., 0., 0.], [ 1., -2., 1., 0., 0.], [ 1., -4., 6., -4., 1.], [ 0., 1., -4., 6., -4.], [ 0., 0., 1., -4., 6.]])
array([[ 6., -4., 1., 0., 0.], [-4., 6., -4., 1., 0.], [ 1., -4., 6., -4., 1.], [ 0., 0., 1., -2., 1.], [ 0., 0., 0., 1., 0.]])
array([ 0.00000000e+00, 0.00000000e+00, -7.48966545e-10, -1.49717894e-09, -2.24388381e-09])
array([-2.24388381e-09, -1.49717894e-09, -7.48966545e-10, 0.00000000e+00, 0.00000000e+00])

Rešimo sistem linearnih enačb:

Prikažemo rezultat:

<Figure size 640x480 with 1 Axes>

Dodatno: simbolna rešitev nosilca

Tukaj si bomo pogledali simbolno reševanje robnega problema. Poudariti je treba, da gre tukaj zgolj za zgled, ki ga lahko naredimo za obravnavani nosilec z relativno enostavno polsinusno obremenitvijo. V praksi so seveda obremenitve in tudi oblike nosilca lahko bistveno bolj zahtevne in takrat druge poti kot numeričnega reševanja skoraj nimamo na voljo.

Najprej uvozimo sympy:

Definirajmo spremenljivke:

Definirajmo differencialno enačbo (robne pogoje dodamo pozneje):

Loading...

Rešimo:

Loading...
<Figure size 640x480 with 1 Axes>

Primerjajmo sedaj analitično rešitev, z rešitvijo z metodo končnih razlik in strelsko metodo:

Loading...