scipy.integrate.

Radau

class scipy.integrate.Radau(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 Runge-Kutta-Methode der Radau IIA-Familie der Ordnung 5.

Die Implementierung folgt [1]. Der Fehler wird mit einer drittgradig genauen eingebetteten Formel gesteuert. Für die dichte Ausgabe wird ein kubisches Polynom verwendet, das die Kollokationsbedingungen erfüllt.

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 Solver hält die lokalen Fehlerschätzungen kleiner als atol + rtol * abs(y). Hier steuert rtol die relative Genauigkeit (Anzahl der korrekten Ziffern), während atol die absolute Genauigkeit (Anzahl der korrekten 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 Sie array_like mit der Form (n,) für atol übergeben. Standardwerte sind 1e-3 für rtol und 1e-6 für atol.

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

Jacobimatrix der rechten Seite des Systems bezüglich y, erforderlich für diese Methode. Die Jacobimatrix 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 sowohl von t als auch von 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 eine Sparsity-Struktur der Jacobi-Matrix für eine Approximation durch endliche Differenzen. 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, kann die Angabe der Sparsity-Struktur die Berechnungen erheblich beschleunigen [2]. 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 Approximation der Jacobi-Matrix durch endliche Differenzen mit dieser Methode, kann aber unter Umständen (z. B. bei kleinem len(y0)) zu einer langsameren Gesamtausfü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]

E. Hairer, G. Wanner, „Solving Ordinary Differential Equations II: Stiff and Differential-Algebraic Problems“, Kap. IV.8.

[2]

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.