def psi_roots(n):
"""Gauss-Hermite quadrature for functions including the exponential factor.
Computes the sample points and weights for transformed Gauss-Hermite
quadrature. The sample points are the roots of the `n`th degree Hermite
polynomial, :math:`H_n(x)`. The weights are transformed such that
they do not include the exponential factor :math:`\exp(-x^2)`.
Parameters
----------
n : int
quadrature order
Returns
-------
x : ndarray
Sample points
w : ndarray
Weights
Notes
-----
For small n up to 150 a modified version of the Golub-Welsch
algorithm is used. Nodes are computed from the eigenvalue
problem and improved by one step of a Newton iteration.
The weights are computed from the well-known analytical formula.
For n larger than 150 an optimal asymptotic algorithm is applied
which computes nodes and weights in a numerically stable manner.
The algorithm has linear runtime making computation for very
large n (several thousand or more) feasible.
See Also
--------
integrate.quadrature
integrate.fixed_quad
numpy.polynomial.hermite.hermgauss
"""
m = int(n)
if n < 1 or n != m:
raise ValueError("n must be a positive integer.")
if n <= 150:
nodes, weights = h_roots_original(n)
# Hermite function recursion
h = hermite_recursion(n - 1, nodes)
weights = 1.0 / (h**2 * n)
return nodes, weights
else:
return psi_roots_asy(n)
def psi_roots(n):
"""Gauss-Hermite quadrature for functions including the exponential factor.
Computes the sample points and weights for transformed Gauss-Hermite
quadrature. The sample points are the roots of the `n`th degree Hermite
polynomial, :math:`H_n(x)`. The weights are transformed such that
they do not include the exponential factor :math:`\exp(-x^2)`.
Parameters
----------
n : int
quadrature order
Returns
-------
x : ndarray
Sample points
w : ndarray
Weights
Notes
-----
For small n up to 150 a modified version of the Golub-Welsch
algorithm is used. Nodes are computed from the eigenvalue
problem and improved by one step of a Newton iteration.
The weights are computed from the well-known analytical formula.
For n larger than 150 an optimal asymptotic algorithm is applied
which computes nodes and weights in a numerically stable manner.
The algorithm has linear runtime making computation for very
large n (several thousand or more) feasible.
See Also
--------
integrate.quadrature
integrate.fixed_quad
numpy.polynomial.hermite.hermgauss
"""
m = int(n)
if n < 1 or n != m:
raise ValueError("n must be a positive integer.")
if n <= 150:
nodes, weights = h_roots_original(n)
# Hermite function recursion
h = hermite_recursion(n-1, nodes)
weights = 1.0/(h**2 * n)
return nodes, weights
else:
return psi_roots_asy(n)
def h_roots(n):
"""Gauss-Hermite (physicst's) quadrature
Computes the sample points and weights for Gauss-Hermite quadrature.
The sample points are the roots of the `n`th degree Hermite polynomial,
:math:`H_n(x)`. These sample points and weights correctly integrate
polynomials of degree :math:`2*n - 1` or less over the interval
:math:`[-inf, inf]` with weight function :math:`f(x) = e^{-x^2}`.
Parameters
----------
n : int
quadrature order
Returns
-------
x : ndarray
Sample points
w : ndarray
Weights
Notes
-----
For small n up to 150 a modified version of the Golub-Welsch
algorithm is used. Nodes are computed from the eigenvalue
problem and improved by one step of a Newton iteration.
The weights are computed from the well-known analytical formula.
For n larger than 150 an optimal asymptotic algorithm is applied
which computes nodes and weights in a numerically stable manner.
The algorithm has linear runtime making computation for very
large n (several thousand or more) feasible.
See Also
--------
integrate.quadrature
integrate.fixed_quad
numpy.polynomial.hermite.hermgauss
"""
m = int(n)
if n < 1 or n != m:
raise ValueError("n must be a positive integer.")
if n <= 150:
return h_roots_original(n)
else:
return h_roots_asy(n)
def h_roots(n):
"""Gauss-Hermite (physicst's) quadrature
Computes the sample points and weights for Gauss-Hermite quadrature.
The sample points are the roots of the `n`th degree Hermite polynomial,
:math:`H_n(x)`. These sample points and weights correctly integrate
polynomials of degree :math:`2*n - 1` or less over the interval
:math:`[-inf, inf]` with weight function :math:`f(x) = e^{-x^2}`.
Parameters
----------
n : int
quadrature order
Returns
-------
x : ndarray
Sample points
w : ndarray
Weights
Notes
-----
For small n up to 150 a modified version of the Golub-Welsch
algorithm is used. Nodes are computed from the eigenvalue
problem and improved by one step of a Newton iteration.
The weights are computed from the well-known analytical formula.
For n larger than 150 an optimal asymptotic algorithm is applied
which computes nodes and weights in a numerically stable manner.
The algorithm has linear runtime making computation for very
large n (several thousand or more) feasible.
See Also
--------
integrate.quadrature
integrate.fixed_quad
numpy.polynomial.hermite.hermgauss
"""
m = int(n)
if n < 1 or n != m:
raise ValueError("n must be a positive integer.")
if n <= 150:
return h_roots_original(n)
else:
return h_roots_asy(n)
