scipy.integrate.

nquad#

scipy.integrate.nquad(func, ranges, args=None, opts=None, full_output=False)[Quelle]#

Integration über mehrere Variablen.

Wickelt quad ein, um die Integration über mehrere Variablen zu ermöglichen. Verschiedene Optionen erlauben eine verbesserte Integration von diskontinuierlichen Funktionen, sowie die Verwendung gewichteter Integration und generell eine feinere Steuerung des Integrationsprozesses.

Parameter:

func{callable, scipy.LowLevelCallable}

Die zu integrierende Funktion. Hat Argumente von x0, ... xn, t0, ... tm, wobei die Integration über x0, ... xn durchgeführt wird, welche float sein müssen. Wobei t0, ... tm zusätzliche Argumente sind, die in args übergeben werden. Die Funktionssignatur sollte func(x0, x1, ..., xn, t0, t1, ..., tm) lauten. Die Integration wird in Reihenfolge durchgeführt. Das heißt, die Integration über x0 ist das innerste Integral und xn ist das äußerste.

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

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

wobei n die Anzahl der Variablen und Argumente ist. Das xx-Array enthält die Koordinaten und zusätzlichen Argumente. user_data sind die Daten, die in der scipy.LowLevelCallable enthalten sind.

rangesiterierbares Objekt

Jedes Element von ranges kann entweder eine Sequenz von 2 Zahlen oder eine aufrufbare Funktion sein, die eine solche Sequenz zurückgibt. ranges[0] entspricht der Integration über x0 und so weiter. Wenn ein Element von ranges aufrufbar ist, wird es mit allen verfügbaren Integrationsargumenten sowie allen parametrischen Argumenten aufgerufen. z.B. wenn func = f(x0, x1, x2, t0, t1), dann kann ranges[0] entweder als (a, b) oder als (a, b) = range0(x1, x2, t0, t1) definiert werden.

argsiterierbares Objekt, optional

Zusätzliche Argumente t0, ... tn, die von func, ranges und opts benötigt werden.

optsiterierbares Objekt oder dict, optional

Optionen, die an quad übergeben werden. Kann leer sein, ein dict oder eine Sequenz von dicts oder Funktionen, die ein dict zurückgeben. Wenn leer, werden die Standardoptionen von scipy.integrate.quad verwendet. Wenn ein dict, werden die gleichen Optionen für alle Integrationslevel verwendet. Wenn eine Sequenz, dann entspricht jedes Element der Sequenz einer bestimmten Integration. z.B. entspricht opts[0] der Integration über x0 und so weiter. Wenn aufrufbar, muss die Signatur die gleiche sein wie für ranges. Die verfügbaren Optionen zusammen mit ihren Standardwerten sind

epsabs = 1.49e-08

epsrel = 1.49e-08

limit = 50

points = None

weight = None

wvar = None

wopts = None

Weitere Informationen zu diesen Optionen finden Sie unter quad.

full_outputbool, optional

Partielle Implementierung von full_output aus scipy.integrate.quad. Die Anzahl der Integrandenfunktionsauswertungen neval kann durch Setzen von full_output=True beim Aufruf von nquad erhalten werden.

Rückgabe:

resultfloat: Das Ergebnis der Integration.
abserrfloat: Das Maximum der Schätzungen des absoluten Fehlers in den verschiedenen Integrationsergebnissen.
out_dictdict, optional: Ein Dict, das zusätzliche Informationen zur Integration enthält.

Siehe auch

quad: 1-D numerische Integration
dblquad, tplquad: Doppel- und Dreifachintegrale
fixed_quad: Gauß-Quadratur mit festem Ordnung

Hinweise

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

Details zu den QUADPACK-Level-Routinen

nquad ruft Routinen aus der FORTRAN-Bibliothek QUADPACK auf. Dieser Abschnitt gibt 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 gibt eine kurze Beschreibung aus [1] für jede Routine.

qagse

ist ein Integrator, der auf global adaptiver Intervallunterteilung in Verbindung mit Extrapolation basiert und die Effekte von Integranden-Singularitäten verschiedener Typen eliminiert. Die Integration wird mit einer 21-Punkt-Gauss-Kronrod-Quadratur innerhalb jedes Teilintervalls 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 aber auch die Angabe expliziter Informationen über den Ort und die Art von Problempunkten, d.h. die Abszissen von inneren 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 Komponente zur Regelbewertung 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 es 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 vom Benutzer bereitgestellte \(\omega\) und \(f\). Das Verfahren von QAWO wird auf aufeinanderfolgenden endlichen Intervallen angewendet und die Konvergenzbeschleunigung mittels des \(\varepsilon\)-Algorithmus wird auf die Reihen der Integralapproximationen 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 gibt \(\alpha\), \(\beta\) und die Art der Funktion \(v\) an. Eine global adaptive Unterteilungsstrategie wird angewendet, mit modifizierter Clenshaw-Curtis-Integration auf denjenigen Teilintervallen, die a oder b enthalten.

qawce

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

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.

Beispiele

Berechnen

\[\int^{1}_{-0.15} \int^{0.8}_{0.13} \int^{1}_{-1} \int^{1}_{0} f(x_0, x_1, x_2, x_3) \,dx_0 \,dx_1 \,dx_2 \,dx_3 ,\]

wo

\[\begin{split}f(x_0, x_1, x_2, x_3) = \begin{cases} x_0^2+x_1 x_2-x_3^3+ \sin{x_0}+1 & (x_0-0.2 x_3-0.5-0.25 x_1 > 0) \\ x_0^2+x_1 x_2-x_3^3+ \sin{x_0}+0 & (x_0-0.2 x_3-0.5-0.25 x_1 \leq 0) \end{cases} .\end{split}\]

>>> import numpy as np
>>> from scipy import integrate
>>> func = lambda x0,x1,x2,x3 : x0**2 + x1*x2 - x3**3 + np.sin(x0) + (
...                                 1 if (x0-.2*x3-.5-.25*x1>0) else 0)
>>> def opts0(*args, **kwargs):
...     return {'points':[0.2*args[2] + 0.5 + 0.25*args[0]]}
>>> integrate.nquad(func, [[0,1], [-1,1], [.13,.8], [-.15,1]],
...                 opts=[opts0,{},{},{}], full_output=True)
(1.5267454070738633, 2.9437360001402324e-14, {'neval': 388962})

Berechnen

\[\int^{t_0+t_1+1}_{t_0+t_1-1} \int^{x_2+t_0^2 t_1^3+1}_{x_2+t_0^2 t_1^3-1} \int^{t_0 x_1+t_1 x_2+1}_{t_0 x_1+t_1 x_2-1} f(x_0,x_1, x_2,t_0,t_1) \,dx_0 \,dx_1 \,dx_2,\]

wo

\[\begin{split}f(x_0, x_1, x_2, t_0, t_1) = \begin{cases} x_0 x_2^2 + \sin{x_1}+2 & (x_0+t_1 x_1-t_0 > 0) \\ x_0 x_2^2 +\sin{x_1}+1 & (x_0+t_1 x_1-t_0 \leq 0) \end{cases}\end{split}\]

und \((t_0, t_1) = (0, 1)\).

>>> def func2(x0, x1, x2, t0, t1):
...     return x0*x2**2 + np.sin(x1) + 1 + (1 if x0+t1*x1-t0>0 else 0)
>>> def lim0(x1, x2, t0, t1):
...     return [t0*x1 + t1*x2 - 1, t0*x1 + t1*x2 + 1]
>>> def lim1(x2, t0, t1):
...     return [x2 + t0**2*t1**3 - 1, x2 + t0**2*t1**3 + 1]
>>> def lim2(t0, t1):
...     return [t0 + t1 - 1, t0 + t1 + 1]
>>> def opts0(x1, x2, t0, t1):
...     return {'points' : [t0 - t1*x1]}
>>> def opts1(x2, t0, t1):
...     return {}
>>> def opts2(t0, t1):
...     return {}
>>> integrate.nquad(func2, [lim0, lim1, lim2], args=(0,1),
...                 opts=[opts0, opts1, opts2])
(36.099919226771625, 1.8546948553373528e-07)