Numerische Lösung mathematischer Modelle von Objekten, die durch Differentialgleichungssysteme gegeben sind

Einführung:


Bei der mathematischen Modellierung einer Reihe technischer Geräte werden Systeme nichtlinearer Differentialgleichungen verwendet. Solche Modelle werden nicht nur in der Technologie verwendet, sondern auch in den Bereichen Wirtschaft, Chemie, Biologie, Medizin und Management.

Die Untersuchung der Funktionsweise solcher Geräte erfordert die Lösung dieser Gleichungssysteme. Da der Großteil solcher Gleichungen nichtlinear und nicht stationär ist, ist es oft unmöglich, ihre analytische Lösung zu erhalten.

Es müssen numerische Methoden verwendet werden, von denen die bekannteste die Runge-Kutta-Methode ist [1]. Was Python betrifft, so gibt es in Veröffentlichungen zu numerischen Methoden, zum Beispiel [2,3], nur sehr wenige Daten zur Verwendung von Runge-Kutta, und es gibt keine Daten zu seiner Modifikation der Runge-Kutta-Felberg-Methode.

Derzeit hat die Odeint-Funktion des Moduls scipy.integrate dank ihrer einfachen Oberfläche die größte Verbreitung in Python. Die zweite Funktions-Ode dieses Moduls implementiert mehrere Methoden, einschließlich der erwähnten fünfrangigen Runge-Kutta-Felberg-Methode, weist jedoch aufgrund ihrer Universalität eine begrenzte Leistung auf.

Der Zweck dieser Veröffentlichung ist eine vergleichende Analyse der aufgelisteten Mittel zum numerischen Lösen von Differentialgleichungssystemen mit einem modifizierten Autor unter Python unter Verwendung der Runge-Kutta-Felberg-Methode. Die Veröffentlichung bietet auch Lösungen für Randwertprobleme für Differentialgleichungssysteme (SDEs).

Kurze theoretische und tatsächliche Daten zu den betrachteten Methoden und Software für die numerische Lösung von CDS


Cauchys Problem

Für eine Differentialgleichung n-ter Ordnung besteht das Cauchy-Problem darin, eine Funktion zu finden, die die Gleichheit erfüllt:



und Anfangsbedingungen



Bevor Sie dieses Problem lösen, sollten Sie es in Form der folgenden CDS umschreiben

(1)

mit Anfangsbedingungen



Scipy.integrate-Modul

Das Modul hat zwei Funktionen ode () und odeint (), mit denen Systeme gewöhnlicher Differentialgleichungen (ODEs) erster Ordnung mit Anfangsbedingungen an einem Punkt gelöst werden können (Cauchy-Problem). Die Funktion ode () ist universeller und die Funktion odeint () (ODE-Integrator) hat eine einfachere Schnittstelle und löst die meisten Probleme gut.

Odeint () Funktion

Die Funktion odeint () verfügt über drei erforderliche Argumente und viele Optionen. Es hat das folgende Format odeint (func, y0, t [, args = (), ...]) Das Argument func ist der Python-Name der Funktion zweier Variablen, von denen die erste die Liste y = [y1, y2, ..., yn ist ] und der zweite ist der Name der unabhängigen Variablen.

Die Funktion func sollte eine Liste von n Funktionswerten zurückgeben für einen gegebenen Wert des unabhängigen Arguments t. Tatsächlich implementiert die Funktion func (y, t) die Berechnung der rechten Seiten des Systems (1).

Das zweite Argument y0 von odeint () ist ein Array (oder eine Liste) von Anfangswerten bei t = t0.

Das dritte Argument ist eine Reihe von Zeitpunkten, zu denen Sie eine Lösung für das Problem erhalten möchten. In diesem Fall wird das erste Element dieses Arrays als t0 betrachtet.

Die Funktion odeint () gibt ein Array der Größe len (t) x len (y0) zurück. Die Funktion odeint () verfügt über viele Optionen, die den Betrieb steuern. Die Optionen rtol (relativer Fehler) und atol (absoluter Fehler) bestimmen den Berechnungsfehler ei für jeden Wert von yi gemäß der Formel



Sie können Vektoren oder Skalare sein. Default



Ode () Funktion

Die zweite Funktion des Moduls scipy.integrate, mit dem Differentialgleichungen und -systeme gelöst werden sollen, heißt ode (). Es wird ein ODE-Objekt erstellt (Typ scipy.integrate._ode.ode). Wenn man eine Verknüpfung zu einem solchen Objekt hat, sollte man seine Methoden verwenden, um Differentialgleichungen zu lösen. Ähnlich wie bei der Funktion odeint () reduziert die Funktion ode (func) das Problem auf ein System von Differentialgleichungen der Form (1) und verwendet dessen Funktion auf der rechten Seite.

Der einzige Unterschied besteht darin, dass die Funktion der rechten Funktion (t, y) eine unabhängige Variable als erstes Argument und die Liste der Werte der gewünschten Funktionen als zweites Argument akzeptiert. Mit der folgenden Befehlsfolge wird beispielsweise eine ODE erstellt, die eine Cauchy-Aufgabe darstellt.

Runge-Kutta-Methode

Bei der Konstruktion numerischer Algorithmen wird davon ausgegangen, dass es eine Lösung für dieses Differentialproblem gibt, die eindeutig ist und die erforderlichen Glätteigenschaften aufweist.

In der numerischen Lösung des Cauchy-Problems

(2)

(3)

gemäß der bekannten Lösung am Punkt t = 0 ist es notwendig, eine Lösung aus Gleichung (3) für andere t zu finden. In der numerischen Lösung von Problem (2), (3) verwenden wir der Einfachheit halber ein einheitliches Gitter in der Variablen t mit einem Schritt t> 0.

Eine ungefähre Lösung für Problem (2), (3) am Punkt bezeichnen . Methode konvergiert an einem Punkt wenn bei . Die Methode hat eine p-te Genauigkeitsordnung, wenn , p> 0 für . Das einfachste Differenzschema für eine ungefähre Lösung des Problems (2), (3) ist

(4)

Bei Wir haben eine explizite Methode und in diesem Fall nähert sich das Differenzschema Gleichung (2) mit der ersten Ordnung an. Symmetrisches Design in (4) hat eine zweite Näherungsordnung. Dieses Schema gehört zur Klasse der impliziten - um die ungefähre Lösung auf einer neuen Ebene zu bestimmen, muss das nichtlineare Problem gelöst werden.

Es ist zweckmäßig, explizite Approximationsschemata zweiter und höherer Ordnung basierend auf der Prädiktor-Korrektor-Methode zu konstruieren. In der Phase des Prädiktors (Vorhersage) wird ein explizites Schema verwendet.

(5)

und in der Korrekturphase (Verfeinerung) ein Diagramm



Bei den einstufigen Runge-Kutta-Methoden werden die Ideen des Prädiktor-Korrektors am vollständigsten umgesetzt. Diese Methode ist in allgemeiner Form geschrieben:

(6)

wo



Die Formel (6) basiert auf s Berechnungen der Funktion f und wird als s-Stufe bezeichnet. Wenn bei Wir haben die explizite Runge-Kutta-Methode. Wenn für j> 1 und dann implizit aus der Gleichung bestimmt:

(7)

Diese Runge-Kutta-Methode wird als diagonal implizit bezeichnet. Parameter Bestimmen Sie eine Variante der Runge-Kutta-Methode. Die folgende Darstellung der Methode wird verwendet (Butcher-Tabelle)



Eine der häufigsten ist die explizite Runge-Kutta-Methode vierter Ordnung.

(8)

Runge-Kutta-Felberg-Methode

Ich gebe den Wert der berechneten Koeffizienten an Methode

(9)

In Anbetracht von (9) hat die allgemeine Lösung die Form:

(10)

Diese Lösung bietet die fünfte Genauigkeitsordnung, die noch an Python angepasst werden muss.

Computerexperiment zur Bestimmung des absoluten Fehlers der numerischen Lösung einer nichtlinearen Differentialgleichung Verwenden Sie sowohl die Funktionen def odein () als auch def oden () des Moduls scipy.integrate und die an Python angepassten Methoden Runge-Kutta und Runge-Kutta-Felberg



Programmliste
from numpy import* import matplotlib.pyplot as plt from scipy.integrate import * def odein(): #dy1/dt=y2 #dy2/dt=y1**2+1: def f(y,t): return y**2+1 t =arange(0,1,0.01) y0 =0.0 y=odeint(f, y0,t) y = array(y).flatten() return y,t def oden(): f = lambda t, y: y**2+1 ODE=ode(f) ODE.set_integrator('dopri5') ODE.set_initial_value(0, 0) t=arange(0,1,0.01) z=[] t=arange(0,1,0.01) for i in arange(0,1,0.01): ODE.integrate(i) q=ODE.y z.append(q[0]) return z,t def rungeKutta(f, to, yo, tEnd, tau): def increment(f, t, y, tau): if z==1: k0 =tau* f(t,y) k1 =tau* f(t+tau/2.,y+k0/2.) k2 =tau* f(t+tau/2.,y+k1/2.) k3 =tau* f(t+tau, y + k2) return (k0 + 2.*k1 + 2.*k2 + k3) / 6. elif z==0: k1=tau*f(t,y) k2=tau*f(t+(1/4)*tau,y+(1/4)*k1) k3 =tau *f(t+(3/8)*tau,y+(3/32)*k1+(9/32)*k2) k4=tau*f(t+(12/13)*tau,y+(1932/2197)*k1-(7200/2197)*k2+(7296/2197)*k3) k5=tau*f(t+tau,y+(439/216)*k1-8*k2+(3680/513)*k3 -(845/4104)*k4) k6=tau*f(t+(1/2)*tau,y-(8/27)*k1+2*k2-(3544/2565)*k3 +(1859/4104)*k4-(11/40)*k5) return (16/135)*k1+(6656/12825)*k3+(28561/56430)*k4-(9/50)*k5+(2/55)*k6 t = [] y= [] t.append(to) y.append(yo) while to < tEnd: tau = min(tau, tEnd - to) yo = yo + increment(f, to, yo, tau) to = to + tau t.append(to) y.append(yo) return array(t), array(y) def f(t, y): f = zeros([1]) f[0] = y[0]**2+1 return f to = 0. tEnd = 1 yo = array([0.]) tau = 0.01 z=1 t, yn = rungeKutta(f, to, yo, tEnd, tau) y1n=[i[0] for i in yn] plt.figure() plt.title("   (..- u(t)=tan(t)) \n\ du/dt=u**2+1 cu(0)=0  t>0") plt.plot(t,abs(array(y1n)-array(tan(t))),label=' — \n\   -   ') plt.xlabel('') plt.ylabel(' .') plt.legend(loc='best') plt.grid(True) z=0 t, ym = rungeKutta(f, to, yo, tEnd, tau) y1m=[i[0] for i in ym] plt.figure() plt.title("   (..- u(t)=tan(t)) \n\ du/dt=u**2+1 cu(0)=0  t>0") plt.plot(t,abs(array(y1m)-array(tan(t))),label=' ——  \n\   -   ') plt.xlabel('') plt.ylabel(' .') plt.legend(loc='best') plt.grid(True) plt.figure() plt.title("    (..- u(t)=tan(t)) \n\ du/dt=u**2+1 cu(0)=0  t>0") y,t=odein() plt.plot(t,abs(array(tan(t))-array(y)),label=' odein') plt.xlabel('') plt.ylabel(' .') plt.legend(loc='best') plt.grid(True) plt.figure() plt.title("    (..- u(t)=tan(t)) \n\ du/dt=u**2+1 cu(0)=0  t>0") z,t=oden() plt.plot(t,abs(tan(t)-z),label=' ode  ——  \n\  ') plt.xlabel('') plt.ylabel(' .') plt.legend(loc='best') plt.grid(True) plt.show() 


Wir bekommen:









Fazit:

Python-angepasste Runge-Kutta- und Runge-Kutta-Felberg-Methoden haben ein niedrigeres Absolut als eine Lösung mit der Odeint-Funktion, aber mehr als eine Lösung mit der Edu-Funktion. Es ist notwendig, eine Leistungsstudie durchzuführen.

Ein numerisches Experiment zum Vergleich der Geschwindigkeit der numerischen Lösung von SDEs unter Verwendung der Ode-Funktion mit dem Attribut dopri5 (Runge-Kutta-Methode 5. Ordnung) und unter Verwendung der an Python angepassten Runge-Kutta-Felberg-Methode



Eine vergleichende Analyse wird am Beispiel des in [2] angegebenen Modellproblems durchgeführt. Um die Quelle nicht zu wiederholen, werde ich die Formulierung und Lösung des Modellproblems aus [2] vorstellen.

Lösen wir das Cauchy-Problem, das die Bewegung eines Körpers beschreibt, der mit einer Anfangsgeschwindigkeit v0 in einem Winkel α zum Horizont geworfen wird, unter der Annahme, dass der Luftwiderstand proportional zum Quadrat der Geschwindigkeit ist. In Vektorform hat die Bewegungsgleichung die Form



wo Ist der Radius des Vektors des sich bewegenden Körpers, Ist der Geschwindigkeitsvektor des Körpers, - Widerstandsbeiwert, Vektor Kräfte des Körpergewichts der Masse m, g - Erdbeschleunigung.



Die Besonderheit dieser Aufgabe ist, dass die Bewegung zu einem zuvor unbekannten Zeitpunkt endet, wenn der Körper zu Boden fällt. Wenn angegeben , dann haben wir in Koordinatenform ein Gleichungssystem:



Die Anfangsbedingungen sollten dem System hinzugefügt werden: (h Anfangshöhe) . Put . Dann nimmt das entsprechende ODE-System erster Ordnung die Form an:



Für das Modellproblem setzen wir . Wenn ich eine ziemlich ausführliche Beschreibung des Programms weglasse, werde ich nur eine Auflistung der Kommentare geben, zu denen meines Erachtens das Prinzip seiner Funktionsweise klar sein wird. Das Programm hat einen Countdown für die vergleichende Analyse hinzugefügt.

Programmliste
 import numpy as np import matplotlib.pyplot as plt import time start = time.time() from scipy.integrate import ode ts = [ ] ys = [ ] FlightTime, Distance, Height =0,0,0 y4old=0 def fout(t, y):#   global FlightTime, Distance, Height,y4old ts.append(t) ys.append(list(y.copy())) y1, y2, y3, y4 = y if y4*y4old<=0: #    Height=y3 if y4<0 and y3<=0.0: #    FlightTime=t Distance=y1 return -1 y4old=y4 #      def f(t, y, k): #    k g=9.81 y1, y2, y3, y4 = y return [y2,-k*y2*np.sqrt(y2**2+y4**2), y4,-k*y4*np.sqrt(y2**2+y4**2)-g] tmax=1.41 #     alph=np.pi/4 #    v0=10.0 #   K=[0.1,0.2,0.3,0.5] #    y0,t0=[0, v0*np.cos(alph), 0, v0*np.sin(alph)], 0 #   ODE=ode(f) ODE.set_integrator('dopri5', max_step=0.01) ODE.set_solout(fout) fig, ax = plt.subplots() fig.set_facecolor('white') for k in K: #     ts, ys = [ ],[ ] ODE.set_initial_value(y0, t0) #    ODE.set_f_params(k) #    k #   f(t,y,k)     ODE.integrate(tmax) #   print('Flight time = %.4f Distance = %.4f Height =%.4f '% (FlightTime,Distance,Height)) Y=np.array(ys) plt.plot(Y[:,0],Y[:,2],linewidth=3,label='k=%.1f'% k) stop = time.time() plt.title("      \n    ode   dopri5 ") print ("   : %f"%(stop-start)) plt.grid(True) plt.xlim(0,8) plt.ylim(-0.1,2) plt.legend(loc='best') plt.show() 



Wir bekommen:

Flugzeit = 1,2316 Entfernung = 5,9829 Höhe = 1,8542
Flugzeit = 1.1016 Entfernung = 4.3830 Höhe = 1.5088
Flugzeit = 1.0197 Entfernung = 3.5265 Höhe = 1.2912
Flugzeit = 0,9068 Entfernung = 2,5842 Höhe = 1,0240
Zeit für Modellproblem: 0,454787



Um eine numerische Lösung des CDS mit Python-Tools ohne Verwendung spezieller Module zu implementieren, habe ich die folgende Funktion vorgeschlagen und untersucht:

def increment(f, t, y, tau
k1=tau*f(t,y)
k2=tau*f(t+(1/4)*tau,y+(1/4)*k1)
k3 =tau *f(t+(3/8)*tau,y+(3/32)*k1+(9/32)*k2)
k4=tau*f(t+(12/13)*tau,y+(1932/2197)*k1-(7200/2197)*k2+(7296/2197)*k3)
k5=tau*f(t+tau,y+(439/216)*k1-8*k2+(3680/513)*k3 -(845/4104)*k4)
k6=tau*f(t+(1/2)*tau,y-(8/27)*k1+2*k2-(3544/2565)*k3 +(1859/4104)*k4-(11/40)*k5)
return (16/135)*k1+(6656/12825)*k3+(28561/56430)*k4-(9/50)*k5+(2/55)*k6


Die Inkrementfunktion (f, t, y, tau) liefert die fünfte Ordnung der numerischen Lösungsmethode. Weitere Funktionen des Programms finden Sie in der folgenden Liste:

Programmliste
 from numpy import* import matplotlib.pyplot as plt import time start = time.time() def rungeKutta(f, to, yo, tEnd, tau): def increment(f, t, y, tau):#     ——. k1=tau*f(t,y) k2=tau*f(t+(1/4)*tau,y+(1/4)*k1) k3 =tau *f(t+(3/8)*tau,y+(3/32)*k1+(9/32)*k2) k4=tau*f(t+(12/13)*tau,y+(1932/2197)*k1-(7200/2197)*k2+(7296/2197)*k3) k5=tau*f(t+tau,y+(439/216)*k1-8*k2+(3680/513)*k3 -(845/4104)*k4) k6=tau*f(t+(1/2)*tau,y-(8/27)*k1+2*k2-(3544/2565)*k3 +(1859/4104)*k4-(11/40)*k5) return (16/135)*k1+(6656/12825)*k3+(28561/56430)*k4-(9/50)*k5+(2/55)*k6 t = []#   t y= []#   y t.append(to)#   t   to y.append(yo)#   y   yo while to < tEnd:#     t,y tau = min(tau, tEnd - to)#   tau yo = yo + increment(f, to, yo, tau) #     t0,y0    to = to + tau #   t.append(to) #   t y.append(yo) #   y return array(t), array(y) def f(t, y): #      f = zeros([4]) f[0]=y[1] f[1]=-k*y[1]*sqrt(y[1]**2+y[3]**2) f[2]=y[3] f[3]=-k*y[3]*sqrt(y[1]**2+y[3]**2) -g if y[3]<0 and y[2]<=0.0: #    return -1 return f to = 0#     tEnd = 1.41#     alph=pi/4#    v0=10.0 #   K=[0.1,0.2,0.3,0.5]#     g=9.81 yo = array([0.,v0*cos(alph),0.,v0*sin(alph)]) #   tau =0.01#  for i in K: #      k=i t, y = rungeKutta(f, to, yo, tEnd, tau) y1=array([i[0] for i in y]) #     y y3=array([i[2] for i in y]) #    ""     s,h,t plt.plot(y1,y3,linewidth=2,label='k=%.1f h=%.3f s=%.2f t=%s' % (k,max(y3),max(y1),round(t[list(y1).index(max(y1))],3))) stop = time.time() plt.title("      \n     Python\n  —— ") print ("   : %f"%(stop-start)) plt.xlabel(' h') plt.ylabel(' s') plt.legend(loc='best') plt.xlim(0,8) plt.ylim(-0.1,2) plt.grid(True) plt.show() 


Wir bekommen:

Zeit für Modellproblem: 0,259927



Fazit

Die vorgeschlagene Software-Implementierung des Modellproblems ohne Verwendung spezieller Module hat eine fast doppelt so schnelle Leistung wie mit der Ode-Funktion, aber wir dürfen nicht vergessen, dass die Ode eine höhere Genauigkeit der numerischen Lösung und die Möglichkeit der Auswahl einer Lösungsmethode aufweist.

Lösen eines Randwertproblems mit fadengetrennten Randbedingungen


Wir geben ein Beispiel für ein spezifisches Randwertproblem mit fadengetrennten Randbedingungen:

(11)

Um das Problem (11) zu lösen, verwenden wir den folgenden Algorithmus:

1. Wir lösen die ersten drei inhomogenen Gleichungen von System (11) mit den Anfangsbedingungen

Wir führen die Notation zur Lösung des Cauchy-Problems ein:


2. Wir lösen die ersten drei homogenen Gleichungen von System (11) mit den Anfangsbedingungen

Wir führen die Notation zur Lösung des Cauchy-Problems ein:


3. Wir lösen die ersten drei homogenen Gleichungen von System (11) mit den Anfangsbedingungen



Wir führen die Notation zur Lösung des Cauchy-Problems ein:



4. Die allgemeine Lösung des Randwertproblems (11) unter Verwendung der Lösungen der Cauchy-Probleme wird als lineare Kombination von Lösungen geschrieben:

Dabei sind p2, p3 einige unbekannte Parameter.

5. Um die Parameter p2, p3 zu bestimmen, verwenden wir die Randbedingungen der letzten beiden Gleichungen (11), dh die Bedingungen für x = b. Durch Einsetzen erhalten wir ein lineares Gleichungssystem in Bezug auf unbekanntes p2, p3:
(12)
Wenn wir (12) lösen, erhalten wir die Beziehungen für p2, p3.

Unter Verwendung des obigen Algorithmus unter Verwendung der Runge-Kutta-Felberg-Methode erhalten wir das folgende Programm:

Programmliste
  #   from numpy import* import matplotlib.pyplot as plt import matplotlib.font_manager as fm,os import matplotlib.patches as mpatches import matplotlib.lines as mlines from scipy.integrate import odeint from scipy import linalg import time start = time.time() c1 = 1.0 c2 = 0.8 c3 = 0.5 a =0.0 b = 1.0 nn =100 initial_state_0 =array( [a, c1, 0.0, 0.0]) initial_state_I =array( [a, 0.0, 1.0, 0.0]) initial_state_II =array( [a, 0.0, 0.0, 1.0]) to = a tEnd =b N = int(nn) tau=(ba)/N def rungeKutta(f, to, yo, tEnd, tau): def increment(f, t, y, tau): k1=tau*f(t,y) k2=tau*f(t+(1/4)*tau,y+(1/4)*k1) k3 =tau *f(t+(3/8)*tau,y+(3/32)*k1+(9/32)*k2) k4=tau*f(t+(12/13)*tau,y+(1932/2197)*k1-(7200/2197)*k2+(7296/2197)*k3) k5=tau*f(t+tau,y+(439/216)*k1-8*k2+(3680/513)*k3 -(845/4104)*k4) k6=tau*f(t+(1/2)*tau,y-(8/27)*k1+2*k2-(3544/2565)*k3 +(1859/4104)*k4-(11/40)*k5) return (16/135)*k1+(6656/12825)*k3+(28561/56430)*k4-(9/50)*k5+(2/55)*k6 t = [] y= [] t.append(to) y.append(yo) while to < tEnd: tau = min(tau, tEnd - to) yo = yo + increment(f, to, yo, tau) to = to + tau t.append(to) y.append(yo) return array(t), array(y) def f(t, y): global theta f = zeros([4]) f[0] = 1 f[1] = -y [1]-y[2] +theta* sin(y[0]) f[2] = -y[2]+y[3] f[3] = -y[2] return f #    -- theta = 1 theta = 1.0 yo =initial_state_0 t, y = rungeKutta(f, to, yo, tEnd, tau) y2=[i[2] for i in y] y3=[i[3] for i in y] #       # Y20 = Y2(b), Y30 = Y3(b) Y20 = y2[N-1] Y30 = y3[N-1] #    -- theta = 0,  I theta = 0.0 yo= initial_state_I t, y = rungeKutta(f, to, yo, tEnd, tau) y2=[i[2] for i in y] y3=[i[3] for i in y] #       # Y21= Y2(b), Y31 = Y3(b) Y21= y2[N-1] Y31 = y3[N-1] #    -- theta = 0,  II theta = 0.0 yo =initial_state_II t, y = rungeKutta(f, to, yo, tEnd, tau) y2=[i[2] for i in y] y3=[i[3] for i in y] #       # Y211= Y2(b), Y311 = Y3(b) Y211= y2[N-1] Y311 = y3[N-1] #    #     p2, p3 b1 = c2 - Y20 b2 = c3 - Y30 A = array([[Y21, Y211], [Y31, Y311]]) bb = array([[b1], [b2]]) #   p2, p3 = linalg.solve(A, bb) #    #  , theta = 1 theta = 1.0 yo = array([a, c1, p2, p3]) t, y = rungeKutta(f, to, yo, tEnd, tau) y0=[i[0] for i in y] y1=[i[1] for i in y] y2=[i[2] for i in y] y3=[i[3] for i in y] #  print('y0[0]=', y0[0]) print('y1[0]=', y1[0]) print('y2[0]=', y2[0]) print('y3[0]=', y3[0]) print('y0[N-1]=', y0[N-1]) print('y1[N-1]=', y1[N-1]) print('y2[N-1]=', y2[N-1]) print('y3[N-1]=', y3[N-1]) j = N xx = y0[:j] yy1 = y1[:j] yy2 = y2[:j] yy3 = y3[:j] stop = time.time() print ("   : %f"%(stop-start)) plt.subplot(2, 1, 1) plt.plot([a], [c1], 'ro') plt.plot([b], [c2], 'go') plt.plot([b], [c3], 'bo') plt.plot(xx, yy1, color='r') #  plt.plot(xx, yy2, color='g') #  plt.plot(xx, yy3, color='b') #  plt.xlabel(r'$x$') #   x   TeX plt.ylabel(r'$y_k(x)$') #   y   TeX plt.title(r'  ', color='blue') plt.grid(True) # patch_y1 = mpatches.Patch(color='red', label='$y_1$') patch_y2 = mpatches.Patch(color='green', label='$y_2$') patch_y3 = mpatches.Patch(color='blue', label='$y_3$') plt.legend(handles=[patch_y1, patch_y2, patch_y3]) ymin, ymax = plt.ylim() xmin, xmax = plt.xlim() plt.subplot(2, 1, 2) font = {'family': 'serif', 'color': 'blue', 'weight': 'normal', 'size': 12, } plt.text(0.2, 0.8, r'$\frac{dy_1}{dx}= - y_1 - y_2 + \sin(x),$', fontdict=font) plt.text(0.2, 0.6,r'$\frac{dy_2}{dx}= - y_1 + y_3,$', fontdict=font) plt.text(0.2, 0.4, r'$\frac{dy_3}{dx}= - y_2 - y_2,$', fontdict=font) plt.text(0.2, 0.2, r'$y_1(a)=c_1, ' r'\quad y_2(b)=c_2, \quad y_3(b)=c_3.$', fontdict=font) plt.subplots_adjust(left=0.15) plt.show() 


Wir bekommen:

y0 [0] = 0,0
y1 [0] = 1,0
y2 [0] = 0,7156448588231397
y3 [0] = 1,324566562303714
y0 [N-1] = 0,9900000000000007
y1 [N-1] = 0,1747719838716767
y2 [N-1] = 0,8
y3 [N-1] = 0,5000000000000001
Zeit für Modellproblem: 0.070878



Fazit



Das von mir entwickelte Programm unterscheidet sich von dem in [3] angegebenen Fehler, der die zu Beginn des Artikels angegebene vergleichende Analyse der Odeint-Funktion mit der in Python implementierten Runge-Kutta-Felberg-Methode bestätigt.

Referenzen:

1. Numerische Lösung mathematischer Modelle von Objekten, die durch zusammengesetzte Differentialgleichungssysteme definiert sind.

2. Einführung in das wissenschaftliche Python.

3. N.M. Polyakova, E.V. Shiryaeva Python 3. Erstellen einer grafischen Benutzeroberfläche (am Beispiel der Lösung des Randwertproblems für lineare gewöhnliche Differentialgleichungen mit der Aufnahmemethode). Rostow am Don 2017.

Source: https://habr.com/ru/post/de418139/


All Articles