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)