scipy.integrate.

OdeSolver#

class scipy.integrate.OdeSolver(fun, t0, y0, t_bound, vectorized, support_complex=False)[Quelle]#

Basisklasse für ODE-Löser.

Um einen neuen Löser zu implementieren, müssen Sie die folgenden Richtlinien befolgen

  1. Ein Konstruktor muss die Parameter der Basisklasse (unten aufgeführt) zusammen mit allen anderen spezifischen Parametern für einen Löser akzeptieren.

  2. Ein Konstruktor muss beliebige zusätzliche Argumente **extraneous akzeptieren, aber mit der Funktion common.warn_extraneous darauf hinweisen, dass diese Argumente irrelevant sind. Übergeben Sie diese Argumente nicht an die Basisklasse.

  3. Ein Löser muss eine private Methode _step_impl(self) implementieren, die den Löser einen Schritt weiter vorantreibt. Sie muss ein Tupel (success, message) zurückgeben, wobei success ein boolescher Wert ist, der angibt, ob ein Schritt erfolgreich war, und message ein String ist, der die Beschreibung eines Fehlers enthält, falls ein Schritt fehlgeschlagen ist, oder None andernfalls.

  4. Ein Löser muss eine private Methode _dense_output_impl(self) implementieren, die ein DenseOutput-Objekt zurückgibt, das den letzten erfolgreichen Schritt abdeckt.

  5. Ein Löser muss die Attribute im Abschnitt Attribute aufweisen. Beachten Sie, dass t_old und step_size automatisch aktualisiert werden.

  6. Verwenden Sie die Methode fun(self, t, y) zur Auswertung der rechten Seite des Systems. Auf diese Weise werden die Funktionsaufrufe (nfev) automatisch verfolgt.

  7. Zur Vereinfachung bietet die Basisklasse fun_single(self, t, y) und fun_vectorized(self, t, y) zur Auswertung der rechten Seite in nicht-vektorisierter und vektorisierter Form (unabhängig davon, wie fun aus dem Konstruktor implementiert ist). Diese Aufrufe erhöhen nfev nicht.

  8. Wenn ein Löser eine Jacobi-Matrix und LU-Zerlegungen verwendet, sollte er die Anzahl der Jacobi-Auswertungen (njev) und die Anzahl der LU-Zerlegungen (nlu) verfolgen.

  9. Per Konvention werden die Funktionsauswertungen zur Berechnung einer finiten Differenzen-Approximation der Jacobi-Matrix nicht in nfev gezählt. Verwenden Sie daher fun_single(self, t, y) oder fun_vectorized(self, t, y) bei der Berechnung einer finiten Differenzen-Approximation der Jacobi-Matrix.

Parameter:
funcallable

Rechte Seite des Systems: die Zeitableitung des Zustands y zur Zeit t. Die Aufrufsignatur ist fun(t, y), wobei t ein Skalar ist und y ein ndarray mit len(y) = len(y0) ist. fun muss ein Array derselben Form wie y zurückgeben. Siehe vectorized für weitere Informationen.

t0float

Anfangszeit.

y0array_like, shape (n,)

Anfangszustand.

t_boundfloat

Randzeit — die Integration wird nicht darüber hinaus fortgesetzt. Sie bestimmt auch die Richtung der Integration.

vectorizedbool

Ob fun vektorisiert aufgerufen werden kann. Standard ist False.

Wenn vectorized False ist, wird fun immer mit y der Form (n,) aufgerufen, wobei n = len(y0) ist.

Wenn vectorized True ist, kann fun mit y der Form (n, k) aufgerufen werden, wobei k eine Ganzzahl ist. In diesem Fall muss fun so funktionieren, dass fun(t, y)[:, i] == fun(t, y[:, i]) (d. h. jede Spalte des zurückgegebenen Arrays ist die Zeitableitung des Zustands, der einer Spalte von y entspricht).

Wenn vectorized=True gesetzt ist, können die Methoden ‘Radau’ und ‘BDF’ die Jacobi-Matrix durch finite Differenzen schneller approximieren, was jedoch zu einer langsameren Ausführung für andere Methoden führt. Unter bestimmten Umständen (z. B. kleine len(y0)) kann dies auch zu einer insgesamt langsameren Ausführung für ‘Radau’ und ‘BDF’ führen.

support_complexbool, optional

Ob die Integration im komplexen Bereich unterstützt werden soll. Im Allgemeinen wird dies durch die Fähigkeiten der abgeleiteten Löserklasse bestimmt. Standard ist False.

Attribute:
nint

Anzahl der Gleichungen.

statusstring

Aktueller Status des Solvers: 'running', 'finished' oder 'failed'.

t_boundfloat

Grenzzeit.

directionfloat

Integrationsrichtung: +1 oder -1.

tfloat

Aktuelle Zeit.

yndarray

Aktueller Zustand.

t_oldfloat

Vorherige Zeit. None, wenn noch keine Schritte gemacht wurden.

step_sizefloat

Größe des letzten erfolgreichen Schritts. None, wenn noch keine Schritte gemacht wurden.

nfevint

Anzahl der RHS-Auswertungen des Systems.

njevint

Anzahl der Jacobi-Auswertungen.

nluint

Anzahl der LU-Zerlegungen.

Methoden

dense_output()

Berechnet ein lokales Interpolationspolynom über den letzten erfolgreichen Schritt.

step()

Führt einen Integrationsschritt durch.
Auf dieser Seite