scipy.integrate.

nsum#

scipy.integrate.nsum(f, a, b, *, step=1, args=(), log=False, maxterms=1048576, tolerances=None)[Quelle]#

Eine konvergente endliche oder unendliche Reihe auswerten.

Für endliches a und b wertet dies aus

f(a + np.arange(n)*step).sum()

wobei n = int((b - a) / step) + 1, wobei f glatt, positiv und unimodal ist. Die Anzahl der Terme in der Summe kann sehr groß oder unendlich sein. In diesem Fall wird eine partielle Summe direkt ausgewertet und der Rest wird durch Integration angenähert.

Parameter:
faufrufbar

Die Funktion, die die zu summierenden Terme auswertet. Die Signatur muss lauten:

f(x: ndarray, *args) -> ndarray

wobei jedes Element von x eine endliche reelle Zahl ist und args ein Tupel ist, das eine beliebige Anzahl von Arrays enthalten kann, die mit x broadcastfähig sind.

f muss eine elementweise Funktion sein: jedes Element f(x)[i] muss gleich f(x[i]) für alle Indizes i sein. Sie darf das Array x oder die Arrays in args nicht verändern und muss NaN zurückgeben, wenn das Argument NaN ist.

f muss eine glatte, positive, unimodale Funktion von x darstellen, die für *alle reellen Zahlen* zwischen a und b definiert ist.

a, bfloat array_like

Reelle untere und obere Grenzen der zu summierenden Terme. Müssen broadcastbar sein. Jedes Element von a muss kleiner sein als das entsprechende Element in b.

stepfloat array_like

Endlicher, positiver, reeller Schritt zwischen den zu summierenden Termen. Muss mit a und b broadcastbar sein. Beachten Sie, dass die Anzahl der im Summen enthaltenen Terme floor((b - a) / step) + 1 beträgt; passen Sie b entsprechend an, um sicherzustellen, dass f(b) eingeschlossen wird, falls beabsichtigt.

argstuple of array_like, optional

Zusätzliche Positionsargumente, die an f übergeben werden. Müssen Arrays sein, die mit a, b und step broadcastbar sind. Wenn die aufzurufende Funktion Argumente benötigt, die nicht mit a, b und step broadcastbar sind, umschließen Sie diese Funktion mit f, sodass f nur x und broadcastbare *args akzeptiert. Siehe Beispiele.

logbool, Standard: False

Wenn True gesetzt, gibt an, dass f den Logarithmus der Terme zurückgibt und dass atol und rtol als Logarithmen der absoluten und relativen Fehler ausgedrückt werden. In diesem Fall enthält das Ergebnisobjekt den Logarithmus der Summe und des Fehlers. Dies ist nützlich für Summanden, bei denen numerisches Unter- oder Überlaufen zu Ungenauigkeiten führen würde.

maxtermsint, Standard: 2**20

Die maximale Anzahl von Termen, die für die direkte Summierung ausgewertet werden. Zusätzliche Funktionsauswertungen können für die Eingabevalidierung und die Integralbewertung durchgeführt werden.

atol, rtolfloat, optional

Absolute Abbruchtoleranz (Standard: 0) und relative Abbruchtoleranz (Standard: eps**0.5, wobei eps die Präzision des Ergebnis-Datentyps ist). Müssen nicht-negativ und endlich sein, wenn log False ist, und müssen als Logarithmus einer nicht-negativen und endlichen Zahl ausgedrückt werden, wenn log True ist.

Rückgabe:
res_RichResult

Ein Objekt ähnlich einer Instanz von scipy.optimize.OptimizeResult mit den folgenden Attributen. (Die Beschreibungen sind so geschrieben, als ob die Werte Skalare wären; wenn f jedoch ein Array zurückgibt, sind die Ausgaben Arrays derselben Form.)

successbool

True, wenn der Algorithmus erfolgreich beendet wurde (Status 0); andernfalls False.

statusInteger-Array

Eine Ganzzahl, die den Exit-Status des Algorithmus darstellt.

  • 0 : Der Algorithmus konvergierte gegen die angegebenen Toleranzen.

  • -1 : Elemente von a, b oder step sind ungültig

  • -2 : Die numerische Integration hat ihr Iterationslimit erreicht; die Summe kann divergent sein.

  • -3 : Ein nicht-endlicher Wert wurde angetroffen.

  • -4 : Die Magnitude des letzten Terms der partiellen Summe überschreitet die Toleranzen, daher überschreitet die Fehlerschätzung die Toleranzen. Erwägen Sie, maxterms zu erhöhen oder tolerances zu lockern. Alternativ ist die aufzurufende Funktion möglicherweise nicht unimodal, oder die Grenzen der Summierung liegen zu weit vom Funktionsmaximum entfernt. Erwägen Sie, maxterms zu erhöhen oder die Summe in Stücke zu zerlegen.

sumfloat array

Eine Schätzung der Summe.

errorFloat-Array

Eine Schätzung des absoluten Fehlers unter der Annahme, dass alle Terme nicht-negativ sind, die Funktion exakt berechnet wird und die direkte Summierung bis zur Präzision des Ergebnis-Datentyps genau ist.

nfevInteger-Array

Die Anzahl der Punkte, an denen f ausgewertet wurde.

Siehe auch

mpmath.nsum

Hinweise

Die für die unendliche Summierung implementierte Methode ist mit dem Integraltest für die Konvergenz einer unendlichen Reihe verwandt: unter der Annahme eines Schrittmaßes step von 1 zur Vereinfachung der Darstellung wird die Summe einer monoton fallenden Funktion begrenzt durch

\[\int_u^\infty f(x) dx \leq \sum_{k=u}^\infty f(k) \leq \int_u^\infty f(x) dx + f(u)\]

Sei \(a\) a, \(n\) maxterms, \(\epsilon_a\) atol und \(\epsilon_r\) rtol. Die Implementierung wertet zunächst das Integral \(S_l=\int_a^\infty f(x) dx\) als untere Schranke für die unendliche Summe aus. Dann wird ein Wert \(c > a\) gesucht, so dass \(f(c) < \epsilon_a + S_l \epsilon_r\), falls dieser existiert; andernfalls sei \(c = a + n\). Dann wird die unendliche Summe approximiert als

\[\sum_{k=a}^{c-1} f(k) + \int_c^\infty f(x) dx + f(c)/2\]

und der gemeldete Fehler ist \(f(c)/2\) plus die Fehlerschätzung der numerischen Integration. Beachten Sie, dass die Integralapproximation die Auswertung der Funktion an Punkten erfordern kann, die sich von denen unterscheiden, die in der Summe erscheinen. Daher muss f eine stetige und monoton fallende Funktion sein, die für alle reellen Zahlen im Integrationsintervall definiert ist. Aufgrund der Natur der Integralapproximation hat die Form der Funktion zwischen den Punkten, die in der Summe erscheinen, jedoch wenig Einfluss. Wenn es keine natürliche Erweiterung der Funktion auf alle reellen Zahlen gibt, sollten Sie eine lineare Interpolation verwenden, die leicht auszuwerten ist und die Monotonie beibehält.

Der oben beschriebene Ansatz wird für nicht-Einheit step und endliches b verallgemeinert, das zu groß für die direkte Auswertung der Summe ist, d.h. b - a + 1 > maxterms. Er wird weiter zu unimodalen Funktionen verallgemeinert, indem Terme um das Maximum herum direkt summiert werden. Diese Strategie kann fehlschlagen

  • Wenn die linke Grenze endlich ist und das Maximum weit davon entfernt liegt.

  • Wenn die rechte Grenze endlich ist und das Maximum weit davon entfernt liegt.

  • Wenn beide Grenzen endlich sind und das Maximum weit vom Ursprung entfernt ist.

In diesen Fällen kann die Genauigkeit gering sein, und nsum kann den Statuscode 4 zurückgeben.

Obwohl die aufzurufende Funktion f nicht-negativ und unimodal sein muss, kann nsum zur Auswertung allgemeinerer Reihenformen verwendet werden. Um beispielsweise eine alternierende Reihe auszuwerten, übergeben Sie eine aufzurufende Funktion, die die Differenz zwischen benachbarten Termen zurückgibt, und passen Sie step entsprechend an. Siehe Beispiele.

Referenzen

[1]

Wikipedia. „Integral test for convergence.“ https://en.wikipedia.org/wiki/Integral_test_for_convergence

Beispiele

Berechnen Sie die unendliche Summe der Kehrwerte der quadrierten ganzen Zahlen.

>>> import numpy as np
>>> from scipy.integrate import nsum
>>> res = nsum(lambda k: 1/k**2, 1, np.inf)
>>> ref = np.pi**2/6  # true value
>>> res.error  # estimated error
np.float64(7.448762306416137e-09)
>>> (res.sum - ref)/ref  # true error
np.float64(-1.839871898894426e-13)
>>> res.nfev  # number of points at which callable was evaluated
np.int32(8561)

Berechnen Sie die unendlichen Summen der Kehrwerte ganzer Zahlen, die zu Potenzen p erhoben werden, wobei p ein Array ist.

>>> from scipy import special
>>> p = np.arange(3, 10)
>>> res = nsum(lambda k, p: 1/k**p, 1, np.inf, maxterms=1e3, args=(p,))
>>> ref = special.zeta(p, 1)
>>> np.allclose(res.sum, ref)
True

Werten Sie die alternierende harmonische Reihe aus.

>>> res = nsum(lambda x: 1/x - 1/(x+1), 1, np.inf, step=2)
>>> res.sum, res.sum - np.log(2)  # result, difference vs analytical sum
(np.float64(0.6931471805598691), np.float64(-7.616129948928574e-14))
Auf dieser Seite