scipy.integrate.

quad#

scipy.integrate.quad(func, a, b, args=(), full_output=0, epsabs=1.49e-08, epsrel=1.49e-08, limit=50, points=None, weight=None, wvar=None, wopts=None, maxp1=50, limlst=50, complex_func=False)[Quelle]#

Berechnet ein bestimmtes Integral.

Integriert `func` von `a` bis `b` (möglicherweise auf einem unendlichen Intervall) unter Verwendung einer Technik aus der Fortran-Bibliothek QUADPACK.

Parameter:

func{Funktion, scipy.LowLevelCallable}

Eine Python-Funktion oder -Methode zur Integration. Wenn `func` viele Argumente hat, wird es entlang der Achse integriert, die dem ersten Argument entspricht.

Wenn der Benutzer eine verbesserte Integrationsleistung wünscht, kann `f` eine scipy.LowLevelCallable mit einer der Signaturen sein.

double func(double x)
double func(double x, void *user_data)
double func(int n, double *xx)
double func(int n, double *xx, void *user_data)

Der `user_data` sind die Daten, die in der `scipy.LowLevelCallable` enthalten sind. In den Aufrufformen mit `xx` ist `n` die Länge des `xx`-Arrays, das `xx[0] == x` und die restlichen Elemente enthält, die Zahlen sind, die im `args`-Argument von quad enthalten sind.

Zusätzlich werden bestimmte ctypes-Aufrufsignaturen zur Kompatibilität mit älteren Versionen unterstützt, diese sollten jedoch nicht in neuem Code verwendet werden.

afloat

Untere Integrationsgrenze (verwenden Sie -numpy.inf für -Unendlich).

bfloat

Obere Integrationsgrenze (verwenden Sie numpy.inf für +Unendlich).

argstuple, optional

Zusätzliche Argumente, die an func übergeben werden.

full_outputint, optional

Ungleich 0, um ein Wörterbuch mit Integrationsinformationen zurückzugeben. Wenn ungleich 0, werden Warnmeldungen ebenfalls unterdrückt und die Meldung wird dem Ausgabetupel angehängt.

complex_funcbool, optional

Gibt an, ob der Rückgabetyp der Funktion (`func`) reell (`complex_func=False`: Standard) oder komplex (`complex_func=True`) ist. In beiden Fällen ist das Argument der Funktion reell. Wenn `full_output` ebenfalls ungleich 0 ist, werden das `infodict`, die `message` und die `explain` für die reellen und komplexen Komponenten in einem Wörterbuch mit den Schlüsseln "real output" und "imag output" zurückgegeben.

Rückgabe:

yfloat: Das Integral von `func` von `a` bis `b`.
abserrfloat: Eine Schätzung des absoluten Fehlers im Ergebnis.
infodictdict: Ein Wörterbuch mit zusätzlichen Informationen.
message: Eine Konvergenzmeldung.
explain: Nur angehängt bei 'cos'- oder 'sin'-Gewichtung und unendlichen Integrationsgrenzen, enthält es eine Erklärung der Codes in `infodict['ierlst']`.

Andere Parameter:

epsabsfloat oder int, optional: Absolute Fehlertoleranz. Standard ist 1.49e-8. `quad` versucht, eine Genauigkeit von `abs(i-result) <= max(epsabs, epsrel*abs(i))` zu erreichen, wobei `i` = Integral von `func` von `a` bis `b` und `result` die numerische Annäherung ist. Siehe `epsrel` unten.
epsrelfloat oder int, optional: Relative Fehlertoleranz. Standard ist 1.49e-8. Wenn `epsabs <= 0`, muss `epsrel größer als sowohl 5e-29 als auch 50 * (Maschinengenauigkeit) sein. Siehe `epsabs` oben.
limitfloat oder int, optional: Eine Obergrenze für die Anzahl der Unterintervalle, die im adaptiven Algorithmus verwendet werden.
points(Sequenz von floats, ints), optional: Eine Sequenz von Bruchpunkten im begrenzten Integrationsintervall, an denen lokale Schwierigkeiten des Integranden auftreten können (z. B. Singularitäten, Diskontinuitäten). Die Sequenz muss nicht sortiert sein. Beachten Sie, dass diese Option nicht in Verbindung mit `weight` verwendet werden kann.
weightfloat oder int, optional: String, der die Gewichtungsfunktion angibt. Vollständige Erklärungen zu dieser und den verbleibenden Argumenten finden Sie weiter unten.
wvaroptional: Variablen für die Verwendung mit Gewichtungsfunktionen.
woptsoptional: Optionale Eingabe zur Wiederverwendung von Chebyshev-Momenten.
maxp1float oder int, optional: Eine Obergrenze für die Anzahl der Chebyshev-Momente.
limlstint, optional: Obergrenze für die Anzahl der Zyklen (>=3) für die Verwendung mit einer sinusförmigen Gewichtung und einem unendlichen Endpunkt.

Siehe auch

dblquad: doppeltes Integral
tplquad: dreifaches Integral
nquad: n-dimensionale Integrale (verwendet `quad` rekursiv)
fixed_quad: Gauß-Quadratur mit festem Ordnung
simpson: Integrator für abgetastete Daten
romb: Integrator für abgetastete Daten
scipy.special: für Koeffizienten und Wurzeln orthogonaler Polynome

Hinweise

Für gültige Ergebnisse muss das Integral konvergieren; das Verhalten bei divergenten Integralen ist nicht garantiert.

Zusätzliche Informationen für quad()-Ein- und Ausgaben

Wenn `full_output` ungleich 0 ist, ist das dritte Ausgabeargument (infodict) ein Wörterbuch mit den unten tabellierten Einträgen. Bei unendlichen Grenzen wird der Bereich auf (0,1) transformiert und die optionalen Ausgaben werden bezüglich dieses transformierten Bereichs angegeben. Sei M das Eingabeargument `limit` und K sei `infodict['last']`. Die Einträge sind:

‘neval’: Die Anzahl der Funktionsauswertungen.
‘last’: Die Anzahl K der Unterintervalle, die im Unterteilungsverfahren erzeugt wurden.
‘alist’: Ein Array der Länge M vom Rang 1, dessen erste K Elemente die linken Endpunkte der Unterintervalle in der Partition des Integrationsbereichs sind.
‘blist’: Ein Array der Länge M vom Rang 1, dessen erste K Elemente die rechten Endpunkte der Unterintervalle sind.
‘rlist’: Ein Array der Länge M vom Rang 1, dessen erste K Elemente die Integralannherungen in den Unterintervallen sind.
‘elist’: Ein Array der Länge M vom Rang 1, dessen erste K Elemente die Beträge der absoluten Fehlerschätzungen in den Unterintervallen sind.
‘iord’: Ein ganzzahliger Array vom Rang 1 der Länge M, dessen erste L Elemente Zeiger auf die Fehlerschätzungen über die Unterintervalle sind, wobei L=K ist, wenn K<=M/2+2 oder L=M+1-K andernfalls. Sei I die Sequenz `infodict['iord']` und E sei die Sequenz `infodict['elist']`. Dann bildet `E[I[1]], ..., E[I[L]]` eine abnehmende Sequenz.

Wenn das Eingabeargument `points` bereitgestellt wird (d. h. es ist nicht `None`), werden die folgenden zusätzlichen Ausgaben in das Ausgabewörterbuch aufgenommen. Angenommen, die Sequenz `points` hat die Länge P.

‘pts’: Ein Array vom Rang 1 der Länge P+2, das die Integrationsgrenzen und die Bruchpunkte der Intervalle in aufsteigender Reihenfolge enthält. Dies ist ein Array, das die Unterintervalle angibt, über die integriert wird.
‘level’: Ein ganzzahliger Array vom Rang 1 der Länge M (=limit), der die Unterteilungsstufen der Unterintervalle enthält, d. h. ein Element dieses Arrays ist gleich l, wenn das entsprechende Unterintervall `|bb-aa| = |pts[2]-pts[1]| * 2**(-l)` ist.
‘ndin’: Ein ganzzahliger Array vom Rang 1 der Länge P+2. Nach der ersten Integration über die Intervalle (`pts[1]`, `pts[2]`) können die Fehlerschätzungen über einige der Intervalle künstlich erhöht worden sein, um ihre Unterteilung voranzutreiben. Dieses Array enthält Einsen in den Positionen, die den Unterintervallen entsprechen, für die dies geschieht.

Gewichtung des Integranden

Die Eingabevariablen `weight` und `wvar` werden verwendet, um den Integranden mit einer ausgewählten Liste von Funktionen zu gewichten. Unterschiedliche Integrationstechniken werden verwendet, um das Integral mit diesen Gewichtungsfunktionen zu berechnen, und diese unterstützen nicht die Angabe von Bruchpunkten. Die möglichen Werte von `weight` und die entsprechenden Gewichtungsfunktionen sind:

`weight`	Verwendete Gewichtungsfunktion	`wvar`
‘cos’	cos(w*x)	wvar = w
‘sin’	sin(w*x)	wvar = w
‘alg’	g(x) = ((x-a)*alpha)((b-x)**beta)	wvar = (alpha, beta)
‘alg-loga’	g(x)*log(x-a)	wvar = (alpha, beta)
‘alg-logb’	g(x)*log(b-x)	wvar = (alpha, beta)
‘alg-log’	g(x)log(x-a)log(b-x)	wvar = (alpha, beta)
‘cauchy’	1/(x-c)	wvar = c

`wvar` enthält den Parameter w, (alpha, beta) oder c, abhängig von der ausgewählten Gewichtung. In diesen Ausdrücken sind a und b die Integrationsgrenzen.

Für die 'cos'- und 'sin'-Gewichtung sind zusätzliche Ein- und Ausgaben verfügbar.

Für gewichtete Integrale mit endlichen Integrationsgrenzen erfolgt die Integration mit einer Clenshaw-Curtis-Methode, die Chebyshev-Momente verwendet. Für wiederholte Berechnungen werden diese Momente im Ausgabewörterbuch gespeichert.

‘momcom’: Die maximale Stufe der berechneten Chebyshev-Momente, d. h. wenn `M_c` `infodict['momcom']` ist, dann wurden die Momente für Intervalle der Länge `|b-a| * 2**(-l)` berechnet, l=0,1,...,M_c.
‘nnlog’: Ein ganzzahliger Array vom Rang 1 der Länge M (=limit), der die Unterteilungsstufen der Unterintervalle enthält, d. h. ein Element dieses Arrays ist gleich l, wenn das entsprechende Unterintervall `|b-a|* 2**(-l)` ist.
‘chebmo’: Ein Array vom Rang 2 mit der Form (25, maxp1), das die berechneten Chebyshev-Momente enthält. Diese können an eine Integration über dasselbe Intervall weitergegeben werden, indem dieses Array als zweites Element der Sequenz `wopts` übergeben und `infodict['momcom']` als erstes Element übergeben wird.

Wenn eine der Integrationsgrenzen unendlich ist, wird ein Fourier-Integral berechnet (vorausgesetzt w != 0). Wenn `full_output` gleich 1 ist und ein numerischer Fehler auftritt, wird zusätzlich zur Fehlermeldung, die dem Ausgabetupel angehängt ist, ein Wörterbuch angehängt, das die Fehlercodes im Array `info['ierlst']` in englische Meldungen übersetzt. Das Auskunftswörterbuch enthält anstelle von 'last', 'alist', 'blist', 'rlist' und 'elist' folgende Einträge:

‘lst’: Die Anzahl der für die Integration benötigten Unterintervalle (nennen wir sie `K_f`).
‘rslst’: Ein Array vom Rang 1 der Länge M_f=limlst, dessen erste `K_f` Elemente den Integralbeitrag über das Intervall `(a+(k-1)c, a+kc)` enthalten, wobei `c = (2*floor(|w|) + 1) * pi / |w|` und `k=1,2,...,K_f`.
‘erlst’: Ein Array vom Rang 1 der Länge `M_f`, das die Fehlerschätzung enthält, die dem Intervall in derselben Position in `infodict['rslist']` entspricht.
‘ierlst’: Ein ganzzahliger Array vom Rang 1 der Länge `M_f`, der ein Fehlerflag enthält, das dem Intervall in derselben Position in `infodict['rslist']` entspricht. Die Bedeutung der Codes finden Sie im Erklärungs-Wörterbuch (letzter Eintrag im Ausgabetupel).

Details zu den QUADPACK-Level-Routinen

quad ruft Routinen aus der FORTRAN-Bibliothek QUADPACK auf. Dieser Abschnitt liefert Details zu den Bedingungen für den Aufruf jeder Routine und eine kurze Beschreibung jeder Routine. Die aufgerufene Routine hängt von `weight`, `points` und den Integrationsgrenzen `a` und `b` ab.

QUADPACK-Routine	weight	points	unendliche Grenzen
qagse	None	Nein	Nein
qagie	None	Nein	Ja
qagpe	None	Ja	Nein
qawoe	‘sin’, ‘cos’	Nein	Nein
qawfe	‘sin’, ‘cos’	Nein	entweder `a` oder `b`
qawse	‘alg*’	Nein	Nein
qawce	‘cauchy’	Nein	Nein

Das Folgende liefert eine kurze Beschreibung von [1] für jede Routine.

qagse

ist ein Integrator, der auf global adaptiver Intervallunterteilung in Verbindung mit Extrapolation basiert und die Auswirkungen von Integranden-Singularitäten verschiedener Arten eliminiert. Die Integration wird mit einer 21-Punkte-Gauss-Kronrod-Quadratur innerhalb jedes Unterintervalls durchgeführt.

qagie

behandelt die Integration über unendliche Intervalle. Der unendliche Bereich wird auf ein endliches Intervall abgebildet und anschließend wird die gleiche Strategie wie in QAGS angewendet.

qagpe

dient denselben Zwecken wie QAGS, erlaubt dem Benutzer jedoch auch, explizite Informationen über den Ort und die Art von Problempunkten anzugeben, d. h. die Abszissen von internen Singularitäten, Diskontinuitäten und anderen Schwierigkeiten der Integrandenfunktion.

qawoe

ist ein Integrator zur Auswertung von \(\int^b_a \cos(\omega x)f(x)dx\) oder \(\int^b_a \sin(\omega x)f(x)dx\) über ein endliches Intervall [a,b], wobei \(\omega\) und \(f\) vom Benutzer spezifiziert werden. Die Regel-Auswertungskomponente basiert auf der modifizierten Clenshaw-Curtis-Technik.

Ein adaptives Unterteilungsverfahren wird in Verbindung mit einem Extrapolationsverfahren verwendet, das eine Modifikation des Verfahrens in `QAGS` ist und dem Algorithmus ermöglicht, mit Singularitäten in \(f(x)\) umzugehen.

qawfe

berechnet die Fourier-Transformation \(\int^\infty_a \cos(\omega x)f(x)dx\) oder \(\int^\infty_a \sin(\omega x)f(x)dx\) für benutzerdefinierte \(\omega\) und \(f\). Das Verfahren von `QAWO` wird auf aufeinanderfolgenden endlichen Intervallen angewendet, und eine Konvergenzbeschleunigung mittels des \(\varepsilon\)-Algorithmus wird auf die Reihe der Integralannherungen angewendet.

qawse

approximiert \(\int^b_a w(x)f(x)dx\), mit \(a < b\), wobei \(w(x) = (x-a)^{\alpha}(b-x)^{\beta}v(x)\) mit \(\alpha,\beta > -1\), wobei \(v(x)\) eine der folgenden Funktionen sein kann: \(1\), \(\log(x-a)\), \(\log(b-x)\), \(\log(x-a)\log(b-x)\).

Der Benutzer spezifiziert \(\alpha\), \(\beta\) und die Art der Funktion \(v\). Eine global adaptive Unterteilungsstrategie wird angewendet, mit modifizierter Clenshaw-Curtis-Integration auf denjenigen Unterintervallen, die `a` oder `b` enthalten.

qawce

berechnet \(\int^b_a f(x) / (x-c)dx\), wobei das Integral als Cauchy-Hauptwert-Integral für benutzerdefiniertes \(c\) und \(f\) interpretiert werden muss. Die Strategie ist global adaptiv. Die modifizierte Clenshaw-Curtis-Integration wird auf denjenigen Intervallen verwendet, die den Punkt \(x = c\) enthalten.

Integration einer komplexwertigen Funktion einer reellen Variablen

Eine komplexwertige Funktion \(f\) einer reellen Variablen kann als \(f = g + ih\) geschrieben werden. Ebenso kann das Integral von \(f\) als

\[\int_a^b f(x) dx = \int_a^b g(x) dx + i\int_a^b h(x) dx\]

geschrieben werden, vorausgesetzt, dass die Integrale von \(g\) und \(h\) über das Intervall \([a,b]\) existieren [2]. Daher integriert `quad` komplexwertige Funktionen, indem es die reellen und imaginären Komponenten getrennt integriert.

Referenzen

[1]

Piessens, Robert; de Doncker-Kapenga, Elise; Überhuber, Christoph W.; Kahaner, David (1983). QUADPACK: A subroutine package for automatic integration. Springer-Verlag. ISBN 978-3-540-12553-2.

[2]

McCullough, Thomas; Phillips, Keith (1973). Foundations of Analysis in the Complex Plane. Holt Rinehart Winston. ISBN 0-03-086370-8

Beispiele

Berechne \(\int^4_0 x^2 dx\) und vergleiche mit einem analytischen Ergebnis

>>> from scipy import integrate
>>> import numpy as np
>>> x2 = lambda x: x**2
>>> integrate.quad(x2, 0, 4)
(21.333333333333332, 2.3684757858670003e-13)
>>> print(4**3 / 3.)  # analytical result
21.3333333333

Berechne \(\int^\infty_0 e^{-x} dx\)

>>> invexp = lambda x: np.exp(-x)
>>> integrate.quad(invexp, 0, np.inf)
(1.0, 5.842605999138044e-11)

Berechne \(\int^1_0 a x \,dx\) für \(a = 1, 3\)

>>> f = lambda x, a: a*x
>>> y, err = integrate.quad(f, 0, 1, args=(1,))
>>> y
0.5
>>> y, err = integrate.quad(f, 0, 1, args=(3,))
>>> y
1.5

Berechne \(\int^1_0 x^2 + y^2 dx\) mit ctypes, wobei y als Parameter 1 gehalten wird

testlib.c =>
    double func(int n, double args[n]){
        return args[0]*args[0] + args[1]*args[1];}
compile to library testlib.*

from scipy import integrate
import ctypes
lib = ctypes.CDLL('/home/.../testlib.*') #use absolute path
lib.func.restype = ctypes.c_double
lib.func.argtypes = (ctypes.c_int,ctypes.c_double)
integrate.quad(lib.func,0,1,(1))
#(1.3333333333333333, 1.4802973661668752e-14)
print((1.0**3/3.0 + 1.0) - (0.0**3/3.0 + 0.0)) #Analytic result
# 1.3333333333333333

Beachten Sie, dass Pulsschemata und andere scharfe Merkmale im Vergleich zur Größe des Integrationsintervalls möglicherweise nicht korrekt integriert werden. Ein vereinfachtes Beispiel für diese Einschränkung ist die Integration einer spiegelbildlichen Sprungfunktion auf der y-Achse mit vielen Nullwerten innerhalb der Integrationsgrenzen.

>>> y = lambda x: 1 if x<=0 else 0
>>> integrate.quad(y, -1, 1)
(1.0, 1.1102230246251565e-14)
>>> integrate.quad(y, -1, 100)
(1.0000000002199108, 1.0189464580163188e-08)
>>> integrate.quad(y, -1, 10000)
(0.0, 0.0)