scipy.integrate.

tplquad#

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

Berechnet ein dreifaches (bestimmtes) Integral.

Gibt das dreifache Integral von func(z, y, x) von x = a..b, y = gfun(x)..hfun(x) und z = qfun(x,y)..rfun(x,y) zurück.

Parameter:

funcFunktion: Eine Python-Funktion oder Methode mit mindestens drei Variablen in der Reihenfolge (z, y, x).
a, bfloat: Die Integrationsgrenzen für x: a < b
gfunFunktion oder float: Die untere Grenzlinie für y, die eine Funktion ist, die ein einzelnes Gleitkommaargument (x) nimmt und ein Gleitkommaergebnis zurückgibt, oder ein float, das eine konstante Grenzlinie angibt.
hfunFunktion oder float: Die obere Grenzlinie für y (gleiche Anforderungen wie gfun).
qfunFunktion oder float: Die untere Grenzfläche für z. Es muss eine Funktion sein, die zwei Floats in der Reihenfolge (x, y) nimmt und einen Float zurückgibt, oder ein Float, der eine konstante Grenzfläche angibt.
rfunFunktion oder float: Die obere Grenzfläche für z. (Gleiche Anforderungen wie qfun.)
argstuple, optional: Zusätzliche Argumente, die an func übergeben werden.
epsabsfloat, optional: Absolute Toleranz, die direkt an die innerste 1-D-Quadraturintegration übergeben wird. Standard ist 1,49e-8.
epsrelfloat, optional: Relative Toleranz der innersten 1-D-Integrale. Standard ist 1,49e-8.

Rückgabe:

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

Siehe auch

quad: Adaptive Quadratur mit QUADPACK
fixed_quad: Gauß-Quadratur fester Ordnung
dblquad: Doppelte Integrale
nquad: N-dimensionale Integrale
romb: Integratoren für abgetastete Daten
simpson: Integratoren 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 gibt 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. Das Folgende liefert 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.

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 dreifache Integral von x * y * z, wobei x von 1 bis 2, y von 2 bis 3 und z von 0 bis 1 reicht. Das heißt, \(\int^{x=2}_{x=1} \int^{y=3}_{y=2} \int^{z=1}_{z=0} x y z \,dz \,dy \,dx\).

>>> import numpy as np
>>> from scipy import integrate
>>> f = lambda z, y, x: x*y*z
>>> integrate.tplquad(f, 1, 2, 2, 3, 0, 1)
(1.8749999999999998, 3.3246447942574074e-14)

Berechnet \(\int^{x=1}_{x=0} \int^{y=1-2x}_{y=0} \int^{z=1-x-2y}_{z=0} x y z \,dz \,dy \,dx\). Hinweis: qfun/rfun nimmt Argumente in der Reihenfolge (x, y) entgegen, obwohl f Argumente in der Reihenfolge (z, y, x) nimmt.

>>> f = lambda z, y, x: x*y*z
>>> integrate.tplquad(f, 0, 1, 0, lambda x: 1-2*x, 0, lambda x, y: 1-x-2*y)
(0.05416666666666668, 2.1774196738157757e-14)

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

>>> f = lambda z, y, x, a: a*x*y*z
>>> integrate.tplquad(f, 0, 1, 0, 1, 0, 1, args=(1,))
    (0.125, 5.527033708952211e-15)
>>> integrate.tplquad(f, 0, 1, 0, 1, 0, 1, args=(3,))
    (0.375, 1.6581101126856635e-14)

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

>>> f = lambda x, y, z: np.exp(-(x ** 2 + y ** 2 + z ** 2))
>>> integrate.tplquad(f, -np.inf, np.inf, -np.inf, np.inf, -np.inf, np.inf)
    (5.568327996830833, 4.4619078828029765e-08)