scipy.special.

roots_legendre#

scipy.special.roots_legendre(n, mu=False)[Quelle]#

Gauß-Legendre-Quadratur.

Berechnet die Abtastpunkte und Gewichte für die Gauß-Legendre-Quadratur [GL]. Die Abtastpunkte sind die Wurzeln des Legendre-Polynoms vom Grad n \(P_n(x)\). Diese Abtastpunkte und Gewichte integrieren Polynome vom Grad \(2n - 1\) oder weniger über das Intervall \([-1, 1]\) mit der Gewichtungsfunktion \(w(x) = 1\) korrekt. Weitere Details finden Sie unter 2.2.10 in [AS].

Parameter:

nint: Ordnung der Quadratur
mubool, optional: Wenn True, wird die Summe der Gewichte zurückgegeben, optional.

Rückgabe:

xndarray: Abtastpunkte
wndarray: Gewichte
mufloat: Summe der Gewichte

Siehe auch

scipy.integrate.fixed_quad
numpy.polynomial.legendre.leggauss

Referenzen

[AS]

Milton Abramowitz und Irene A. Stegun, Hrsg. Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. New York: Dover, 1972.

[GL] (1,2)

Gauß-Legendre-Quadratur, Wikipedia, https://en.wikipedia.org/wiki/Gauss%E2%80%93Legendre_quadrature

Beispiele

>>> import numpy as np
>>> from scipy.special import roots_legendre, eval_legendre
>>> roots, weights = roots_legendre(9)

roots enthält die Wurzeln und weights enthält die Gewichte für die Gauß-Legendre-Quadratur.

>>> roots
array([-0.96816024, -0.83603111, -0.61337143, -0.32425342,  0.        ,
        0.32425342,  0.61337143,  0.83603111,  0.96816024])
>>> weights
array([0.08127439, 0.18064816, 0.2606107 , 0.31234708, 0.33023936,
       0.31234708, 0.2606107 , 0.18064816, 0.08127439])

Überprüfen Sie, ob wir die Wurzeln haben, indem Sie das Legendre-Polynom vom Grad 9 an den Punkten roots auswerten. Alle Werte sind ungefähr Null.

>>> eval_legendre(9, roots)
array([-8.88178420e-16, -2.22044605e-16,  1.11022302e-16,  1.11022302e-16,
        0.00000000e+00, -5.55111512e-17, -1.94289029e-16,  1.38777878e-16,
       -8.32667268e-17])

Hier zeigen wir, wie die obigen Werte verwendet werden können, um das Integral von 1 bis 2 von f(t) = t + 1/t mit der Gauß-Legendre-Quadratur [GL] abzuschätzen. Definieren Sie zuerst die Funktion und die Integrationsgrenzen.

>>> def f(t):
...    return t + 1/t
...
>>> a = 1
>>> b = 2

Wir verwenden integral(f(t), t=a, t=b), um das bestimmte Integral von f von t=a bis t=b zu bezeichnen. Die Abtastpunkte in roots stammen aus dem Intervall [-1, 1], daher werden wir das Integral mit der einfachen Variablenänderung umschreiben

x = 2/(b - a) * t - (a + b)/(b - a)

mit der Umkehrung

t = (b - a)/2 * x + (a + b)/2

Dann

integral(f(t), a, b) =
    (b - a)/2 * integral(f((b-a)/2*x + (a+b)/2), x=-1, x=1)

Wir können das letztere Integral mit den von roots_legendre zurückgegebenen Werten approximieren.

Ordnen Sie die oben berechneten Wurzeln von [-1, 1] auf [a, b] ab.

>>> t = (b - a)/2 * roots + (a + b)/2

Approximieren Sie das Integral als gewichtete Summe der Funktionswerte.

>>> (b - a)/2 * f(t).dot(weights)
2.1931471805599276

Vergleichen Sie das mit dem exakten Ergebnis, das 3/2 + log(2) ist.

>>> 1.5 + np.log(2)
2.1931471805599454