scipy.integrate.

BDF

class scipy.integrate.BDF(fun, t0, y0, t_bound, max_step=inf, rtol=0.001, atol=1e-06, jac=None, jac_sparsity=None, vectorized=False, first_step=None, **extraneous)

Implizite Methode basierend auf Backward-Differentiation-Formeln.

Dies ist eine Methode mit variabler Ordnung, wobei die Ordnung automatisch von 1 bis 5 variiert. Der allgemeine Rahmen des BDF-Algorithmus ist in [1] beschrieben. Diese Klasse implementiert eine quasi-konstante Schrittweite, wie in [2] erklärt. Die Strategie zur Fehlerabschätzung für die BDF mit konstanter Schrittweite ist in [3] abgeleitet. Eine Genauigkeitsverbesserung durch modifizierte Formeln (NDF) [2] ist ebenfalls implementiert.

Kann im komplexen Bereich angewendet werden.

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

Grenzzeit - die Integration wird nicht darüber hinaus fortgesetzt. Sie bestimmt auch die Richtung der Integration.

first_stepfloat or None, optional

Anfängliche Schrittgröße. Standard ist None, was bedeutet, dass der Algorithmus wählen soll.

max_stepfloat, optional

Maximale zulässige Schrittgröße. Standard ist np.inf, d.h. die Schrittgröße ist nicht begrenzt und wird ausschließlich vom Solver bestimmt.

rtol, atolfloat and array_like, optional

Relative und absolute Toleranzen. Der Löser hält die lokalen Fehlerschätzungen kleiner als atol + rtol * abs(y). Hier steuert rtol die relative Genauigkeit (Anzahl korrekter Ziffern), während atol die absolute Genauigkeit (Anzahl korrekter Dezimalstellen) steuert. Um die gewünschte rtol zu erreichen, setzen Sie atol kleiner als den kleinsten Wert, der von rtol * abs(y) erwartet werden kann, sodass rtol den zulässigen Fehler dominiert. Wenn atol größer als rtol * abs(y) ist, ist die Anzahl der korrekten Ziffern nicht garantiert. Umgekehrt, um die gewünschte atol zu erreichen, setzen Sie rtol so, dass rtol * abs(y) immer kleiner als atol ist. Wenn Komponenten von y unterschiedliche Skalen haben, kann es vorteilhaft sein, unterschiedliche atol-Werte für verschiedene Komponenten festzulegen, indem man array_like mit der Form (n,) für atol übergibt. Standardwerte sind 1e-3 für rtol und 1e-6 für atol.

jac{None, array_like, sparse_matrix, callable}, optional

Jacobi-Matrix der rechten Seite des Systems bezüglich y, erforderlich für diese Methode. Die Jacobi-Matrix hat die Form (n, n) und ihr Element (i, j) ist gleich d f_i / d y_j. Es gibt drei Möglichkeiten, die Jacobi-Matrix zu definieren

• Wenn array_like oder sparse_matrix, wird angenommen, dass die Jacobi-Matrix konstant ist.

• Wenn callable, wird angenommen, dass die Jacobi-Matrix von sowohl t als auch y abhängt; sie wird bei Bedarf als jac(t, y) aufgerufen. Für die Methoden 'Radau' und 'BDF' kann der Rückgabewert eine spärliche Matrix sein.

• Wenn None (Standard), wird die Jacobi-Matrix durch endliche Differenzen angenähert.

Es wird generell empfohlen, die Jacobi-Matrix bereitzustellen, anstatt sich auf eine Approximation durch endliche Differenzen zu verlassen.

jac_sparsity{None, array_like, sparse matrix}, optional

Definiert die Sparsity-Struktur der Jacobi-Matrix für eine Finite-Differenzen-Approximation. Ihre Form muss (n, n) sein. Dieses Argument wird ignoriert, wenn jac nicht None ist. Wenn die Jacobi-Matrix nur wenige Nicht-Null-Elemente in *jeder* Zeile hat, beschleunigt die Angabe der Sparsity-Struktur die Berechnungen erheblich [4]. Ein Nulleintrag bedeutet, dass ein entsprechendes Element in der Jacobi-Matrix immer Null ist. Wenn None (Standard), wird angenommen, dass die Jacobi-Matrix dicht ist.

vectorizedbool, optional

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).

Das Setzen von vectorized=True ermöglicht eine schnellere Finite-Differenzen-Approximation der Jacobi-Matrix durch diese Methode, kann jedoch unter Umständen (z.B. kleine len(y0)) zu einer insgesamt langsameren Ausführung führen.

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 Auswertungen der rechten Seite.

njevint

Anzahl der Auswertungen der Jacobi-Matrix.

nluint

Anzahl der LU-Zerlegungen.

Methoden

dense_output()	Berechnet ein lokales Interpolationspolynom über den letzten erfolgreichen Schritt.
step()	Führt einen Integrationsschritt durch.

Referenzen

[1]

G. D. Byrne, A. C. Hindmarsh, „A Polyalgorithm for the Numerical Solution of Ordinary Differential Equations“, ACM Transactions on Mathematical Software, Vol. 1, No. 1, S. 71-96, März 1975.

[2] (1,2)

L. F. Shampine, M. W. Reichelt, „THE MATLAB ODE SUITE“, SIAM J. SCI. COMPUTE., Vol. 18, No. 1, S. 1-22, Januar 1997.

[3]

E. Hairer, G. Wanner, „Solving Ordinary Differential Equations I: Nonstiff Problems“, Abschn. III.2.

[4]

A. Curtis, M. J. D. Powell und J. Reid, „On the estimation of sparse Jacobian matrices“, Journal of the Institute of Mathematics and its Applications, 13, S. 117-120, 1974.