scipy.integrate.

dblquad#

scipy.integrate.dblquad(func, a, b, gfun, hfun, args=(), epsabs=1.49e-08, epsrel=1.49e-08)[Quelle]#

Berechnet ein Doppelintegral.

Gibt das doppelte (bestimmte) Integral von func(y, x) von x = a..b und y = gfun(x)..hfun(x) zurück.

Parameter:

funccallable: Eine Python-Funktion oder -Methode mit mindestens zwei Variablen: y muss das erste Argument und x das zweite Argument sein.
a, bfloat: Die Integrationsgrenzen in x: a < b
gfuncallable oder float: Die untere Grenzfunktion in y, die eine Funktion ist, die ein einzelnes Fließkommaargument (x) entgegennimmt und ein Fließkommaergebnis oder eine Fließkommazahl zurückgibt, die eine konstante Grenzfunktion angibt.
hfuncallable oder float: Die obere Grenzfunktion in y (gleiche Anforderungen wie gfun).
argssequence, optional: Zusätzliche Argumente, die an func übergeben werden.
epsabsfloat, optional: Absolute Toleranz, die direkt an die innere 1-D-Quadraturintegration übergeben wird. Standardwert ist 1.49e-8. dblquad versucht, eine Genauigkeit von abs(i-result) <= max(epsabs, epsrel*abs(i)) zu erreichen, wobei i das innere Integral von func(y, x) von gfun(x) bis hfun(x) ist und result die numerische Approximation darstellt. Siehe epsrel unten.
epsrelfloat, optional: Relative Toleranz der inneren 1-D-Integrale. Standardwert ist 1.49e-8. Wenn epsabs <= 0 ist, muss epsrel größer als sowohl 5e-29 als auch 50 * (maschinelles Epsilon) sein. Siehe epsabs oben.

Rückgabe:

yfloat: Das resultierende Integral.
abserrfloat: Eine Schätzung des Fehlers.

Siehe auch

quad: Einzelnes Integral
tplquad: Dreifachintegral
nquad: N-dimensionale Integrale
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.

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. Für jede Integrationsebene wird qagse für endliche Grenzen oder qagie verwendet, wenn eine (oder beide!) Grenzen unendlich sind. Die folgende kurze Beschreibung stammt 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.

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

Berechnet das Doppelintegral von x * y**2 über die Box, wobei x von 0 bis 2 und y von 0 bis 1 reicht. Das heißt, \(\int^{x=2}_{x=0} \int^{y=1}_{y=0} x y^2 \,dy \,dx\).

>>> import numpy as np
>>> from scipy import integrate
>>> f = lambda y, x: x*y**2
>>> integrate.dblquad(f, 0, 2, 0, 1)
    (0.6666666666666667, 7.401486830834377e-15)

Berechnet \(\int^{x=\pi/4}_{x=0} \int^{y=\cos(x)}_{y=\sin(x)} 1 \,dy \,dx\).

>>> f = lambda y, x: 1
>>> integrate.dblquad(f, 0, np.pi/4, np.sin, np.cos)
    (0.41421356237309503, 1.1083280054755938e-14)

Berechnet \(\int^{x=1}_{x=0} \int^{y=2-x}_{y=x} a x y \,dy \,dx\) für \(a=1, 3\).

>>> f = lambda y, x, a: a*x*y
>>> integrate.dblquad(f, 0, 1, lambda x: x, lambda x: 2-x, args=(1,))
    (0.33333333333333337, 5.551115123125783e-15)
>>> integrate.dblquad(f, 0, 1, lambda x: x, lambda x: 2-x, args=(3,))
    (0.9999999999999999, 1.6653345369377348e-14)

Berechnet das zweidimensionale Gaußsche Integral, das das Integral der Gaußschen Funktion \(f(x,y) = e^{-(x^{2} + y^{2})}\) über \((-\infty,+\infty)\) ist. Das heißt, berechnet das Integral \(\iint^{+\infty}_{-\infty} e^{-(x^{2} + y^{2})} \,dy\,dx\).

>>> f = lambda x, y: np.exp(-(x ** 2 + y ** 2))
>>> integrate.dblquad(f, -np.inf, np.inf, -np.inf, np.inf)
    (3.141592653589777, 2.5173086737433208e-08)