def test_la_roots(): root_func = lambda a: lambda n, mu: orth.la_roots(n, a, mu) eval_func = lambda a: lambda n, x: orth.eval_genlaguerre(n, a, x) verify_gauss_quad(root_func(-0.5), eval_func(-0.5), 5) verify_gauss_quad(root_func(-0.5), eval_func(-0.5), 25, atol=1e-13) verify_gauss_quad(root_func(-0.5), eval_func(-0.5), 100, atol=1e-12) verify_gauss_quad(root_func(0.1), eval_func(0.1), 5) verify_gauss_quad(root_func(0.1), eval_func(0.1), 25, atol=1e-13) verify_gauss_quad(root_func(0.1), eval_func(0.1), 100, atol=1e-13) verify_gauss_quad(root_func(1), eval_func(1), 5) verify_gauss_quad(root_func(1), eval_func(1), 25, atol=1e-13) verify_gauss_quad(root_func(1), eval_func(1), 100, atol=1e-13) verify_gauss_quad(root_func(10), eval_func(10), 5) verify_gauss_quad(root_func(10), eval_func(10), 25, atol=1e-13) verify_gauss_quad(root_func(10), eval_func(10), 100, atol=1e-12) verify_gauss_quad(root_func(50), eval_func(50), 5) verify_gauss_quad(root_func(50), eval_func(50), 25, atol=1e-13) verify_gauss_quad(root_func(50), eval_func(50), 100, atol=1e-13) x, w = orth.la_roots(5, 2, False) y, v, m = orth.la_roots(5, 2, True) assert_allclose(x, y, 1e-14, 1e-14) assert_allclose(w, v, 1e-14, 1e-14) assert_raises(ValueError, orth.la_roots, 0, 2) assert_raises(ValueError, orth.la_roots, 3.3, 2) assert_raises(ValueError, orth.la_roots, 3, -1.1)
def quadrature(self,add=10): """base points and weights number of points = size of basis + add """ b,w =so.la_roots(self.n+add,0.) for i in range(len(b)): w[i]=w[i]*cmath.exp(b[i]) return b/(2.*self.s)+self.o, w
def test_la_roots(): rootf = lambda a: lambda n, mu: orth.la_roots(n, a, mu) evalf = lambda a: lambda n, x: orth.eval_genlaguerre(n, a, x) weightf = lambda a: lambda x: x**a * np.exp(-x) vgq = verify_gauss_quad vgq(rootf(-0.5), evalf(-0.5), weightf(-0.5), 0., np.inf, 5) vgq(rootf(-0.5), evalf(-0.5), weightf(-0.5), 0., np.inf, 25, atol=1e-13) vgq(rootf(-0.5), evalf(-0.5), weightf(-0.5), 0., np.inf, 100, atol=1e-12) vgq(rootf(0.1), evalf(0.1), weightf(0.1), 0., np.inf, 5) vgq(rootf(0.1), evalf(0.1), weightf(0.1), 0., np.inf, 25, atol=1e-13) vgq(rootf(0.1), evalf(0.1), weightf(0.1), 0., np.inf, 100, atol=1e-13) vgq(rootf(1), evalf(1), weightf(1), 0., np.inf, 5) vgq(rootf(1), evalf(1), weightf(1), 0., np.inf, 25, atol=1e-13) vgq(rootf(1), evalf(1), weightf(1), 0., np.inf, 100, atol=1e-13) vgq(rootf(10), evalf(10), weightf(10), 0., np.inf, 5) vgq(rootf(10), evalf(10), weightf(10), 0., np.inf, 25, atol=1e-13) vgq(rootf(10), evalf(10), weightf(10), 0., np.inf, 100, atol=1e-12) vgq(rootf(50), evalf(50), weightf(50), 0., np.inf, 5) vgq(rootf(50), evalf(50), weightf(50), 0., np.inf, 25, atol=1e-13) vgq(rootf(50), evalf(50), weightf(50), 0., np.inf, 100, rtol=1e-14, atol=2e-13) x, w = orth.la_roots(5, 2, False) y, v, m = orth.la_roots(5, 2, True) assert_allclose(x, y, 1e-14, 1e-14) assert_allclose(w, v, 1e-14, 1e-14) muI, muI_err = integrate.quad(weightf(2.), 0., np.inf) assert_allclose(m, muI, rtol=muI_err) assert_raises(ValueError, orth.la_roots, 0, 2) assert_raises(ValueError, orth.la_roots, 3.3, 2) assert_raises(ValueError, orth.la_roots, 3, -1.1)
def la_roots(n, alpha=0, method='newton'): ''' Returns the roots (x) of the nth order generalized (associated) Laguerre polynomial, L^(alpha)_n(x), and weights (w) to use in Gaussian quadrature over [0,inf] with weighting function exp(-x) x**alpha with alpha > -1. Parameters ---------- n : integer number of roots method : 'newton' or 'eigenvalue' uses Newton Raphson to find zeros of the Laguerre polynomial (Fast) or eigenvalue of the jacobi matrix (Slow) to obtain the nodes and weights, respectively. Returns ------- x : ndarray roots w : ndarray weights Example ------- >>> import numpy as np >>> [x,w] = h_roots(10) >>> np.sum(x*w) 1.3352627380516791e-17 See also -------- qrule, gaussq References ---------- [1] Golub, G. H. and Welsch, J. H. (1969) 'Calculation of Gaussian Quadrature Rules' Mathematics of Computation, vol 23,page 221-230, [2]. Stroud and Secrest (1966), 'gaussian quadrature formulas', prentice-hall, Englewood cliffs, n.j. ''' if alpha <= -1: raise ValueError('alpha must be greater than -1') if not method.startswith('n'): return ort.la_roots(n, alpha) return _la_roots_newton(n, alpha)
def RadialKinetic(N,L,h=1.0): T = zeros((N,N),'d') a = 2*L+2 h2 = h*h #q = Points(N) q,w = la_roots(N,a) q = q.real for i in range(N): for j in range(N): if i == j: T[i,i] = p2jj(N,a,q[i])-L*(L+1)*qm2jj(N,a,q[i]) else: T[i,j] = pow(-1,i+j)*(p2jk(N,a,q[i],q[j])\ -L*(L+1)*qm2jk(N,a,q[i],q[j])) return -0.5*T/h2
def RadialKinetic_BH0(N,L): # Baye + Heenen eq 3.17 a = 2*L+2 x,w = la_roots(N,a) x = x.real T = zeros((N,N),'d') for i in range(N): xi = x[i] Sii = Laguerre_S(i,i,x) T[i,i] = 0.25*pow((a+1.)/xi,2)+Sii for j in range(i): xj = x[j] Sij = Laguerre_S(i,j,x) T[i,j] = T[j,i] = pow(-1,i-j)*(0.5*(a+1.)*(xi+xj)/pow(xi*xj,1.5) +Sij) return x,0.5*T
def __init__(self, order, a=-0.5, options={}): r"""Initialize a new quadrature rule. :param order: The order :math:`k` of the Gauss-Laguerre quadrature. From theory we know that a Gauss quadrature rule of order :math:`k` is exact for polynomials up to degree :math:`2 k - 1`. :param a: The parameter :math:`a > -1` of the generalized Gauss-Laguerre quadrature. This value defaults to `0` resulting in classical Gauss-Laguerre quadrature. :raise: :py:class:`ValueError` if order ``order`` is not 1 or above. .. warning:: This quadrature is made specifically for our needs. Therefore the default values of :math:`\alpha` is not 0 but set to :math:`-\frac{1}{2}`. There is hope that this will give less confusion and hidden errors. """ # The space dimension of the quadrature rule. self._dimension = 1 # The order of the Gauss-Laguerre quadrature. self._order = order self._a = a # Quadrature has to have at least a single (node,weight) pair. if not self._order > 0: raise ValueError("Quadrature rule has to be of order 1 at least.") # Set the options self._options = options nodes, weights = la_roots(self._order, self._a) # The number of nodes in this quadrature rule self._number_nodes = nodes.size # The quadrature nodes \gamma. self._nodes = real(nodes).reshape((1,self._number_nodes)) # The quadrature weights \omega. self._weights = real(weights).reshape((1,self._number_nodes))
def __init__(self, order, a=-0.5, options={}): r"""Initialize a new quadrature rule. :param order: The order :math:`k` of the Gauss-Laguerre quadrature. From theory we know that a Gauss quadrature rule of order :math:`k` is exact for polynomials up to degree :math:`2 k - 1`. :param a: The parameter :math:`a > -1` of the generalized Gauss-Laguerre quadrature. This value defaults to `0` resulting in classical Gauss-Laguerre quadrature. :raise: :py:class:`ValueError` if order ``order`` is not 1 or above. .. warning:: This quadrature is made specifically for our needs. Therefore the default values of :math:`\alpha` is not 0 but set to :math:`-\frac{1}{2}`. There is hope that this will give less confusion and hidden errors. """ # Quadrature has to have at least a single (node,weight) pair. if not order > 0: raise ValueError("Quadrature rule has to be of order 1 at least.") # The space dimension of the quadrature rule. self._dimension = 1 # The order of the Gauss-Laguerre quadrature. self._order = order self._a = a # Set the options self._options = options nodes, weights = la_roots(self._order, self._a) # The number of nodes in this quadrature rule self._number_nodes = nodes.size # The quadrature nodes \gamma. self._nodes = real(nodes).reshape((1, self._number_nodes)) # The quadrature weights \omega. self._weights = real(weights).reshape((1, self._number_nodes))
def la_roots(n, alpha=0, method='newton'): ''' Returns the roots (x) of the nth order generalized (associated) Laguerre polynomial, L^(alpha)_n(x), and weights (w) to use in Gaussian quadrature over [0,inf] with weighting function exp(-x) x**alpha with alpha > -1. Parameters ---------- n : integer number of roots method : 'newton' or 'eigenvalue' uses Newton Raphson to find zeros of the Laguerre polynomial (Fast) or eigenvalue of the jacobi matrix (Slow) to obtain the nodes and weights, respectively. Returns ------- x : ndarray roots w : ndarray weights Example ------- >>> import numpy as np >>> [x,w] = h_roots(10) >>> np.sum(x*w) -5.2516042729766621e-19 See also -------- qrule, gaussq References ---------- [1] Golub, G. H. and Welsch, J. H. (1969) 'Calculation of Gaussian Quadrature Rules' Mathematics of Computation, vol 23,page 221-230, [2]. Stroud and Secrest (1966), 'gaussian quadrature formulas', prentice-hall, Englewood cliffs, n.j. ''' if alpha <= -1: raise ValueError('alpha must be greater than -1') if not method.startswith('n'): return ort.la_roots(n, alpha) else: max_iter = 10 releps = 3e-14 C = [9.084064e-01, 5.214976e-02, 2.579930e-03, 3.986126e-03] # Initial approximations to the roots go into z. anu = 4.0 * n + 2.0 * alpha + 2.0 rhs = np.arange(4 * n - 1, 2, -4) * np.pi / anu r3 = rhs ** (1. / 3) r2 = r3 ** 2 theta = r3 * (C[0] + r2 * (C[1] + r2 * (C[2] + r2 * C[3]))) z = anu * np.cos(theta) ** 2 dz = zeros(len(z)) L = zeros((3, len(z))) Lp = zeros((1, len(z))) pp = zeros((1, len(z))) k0 = 0 kp1 = 1 k = slice(len(z)) for _its in xrange(max_iter): #%Newton's method carried out simultaneously on the roots. L[k0, k] = 0. L[kp1, k] = 1. for jj in xrange(1, n + 1): # Loop up the recurrence relation to get the Laguerre # polynomials evaluated at z. km1 = k0 k0 = kp1 kp1 = np.mod(kp1 + 1, 3) L[kp1, k] = ((2 * jj - 1 + alpha - z[k]) * L[k0, k] - (jj - 1 + alpha) * L[km1, k]) / jj #end #%L now contains the desired Laguerre polynomials. #%We next compute pp, the derivatives with a standard #% relation involving the polynomials of one lower order. Lp[k] = L[k0, k] pp[k] = (n * L[kp1, k] - (n + alpha) * Lp[k]) / z[k] dz[k] = L[kp1, k] / pp[k] z[k] = z[k] - dz[k]# % Newton?s formula. #%k = find((abs(dz) > releps.*z)) if not np.any(abs(dz) > releps): break else: warnings.warn('too many iterations!') x = z w = -np.exp(sp.gammaln(alpha + n) - sp.gammaln(n)) / (pp * n * Lp) return x, w
def la_roots(n, alpha=0, method='newton'): ''' Returns the roots (x) of the nth order generalized (associated) Laguerre polynomial, L^(alpha)_n(x), and weights (w) to use in Gaussian quadrature over [0,inf] with weighting function exp(-x) x**alpha with alpha > -1. Parameters ---------- n : integer number of roots method : 'newton' or 'eigenvalue' uses Newton Raphson to find zeros of the Laguerre polynomial (Fast) or eigenvalue of the jacobi matrix (Slow) to obtain the nodes and weights, respectively. Returns ------- x : ndarray roots w : ndarray weights Example ------- >>> import numpy as np >>> [x,w] = h_roots(10) >>> np.sum(x*w) -5.2516042729766621e-19 See also -------- qrule, gaussq References ---------- [1] Golub, G. H. and Welsch, J. H. (1969) 'Calculation of Gaussian Quadrature Rules' Mathematics of Computation, vol 23,page 221-230, [2]. Stroud and Secrest (1966), 'gaussian quadrature formulas', prentice-hall, Englewood cliffs, n.j. ''' if alpha <= -1: raise ValueError('alpha must be greater than -1') if not method.startswith('n'): return ort.la_roots(n, alpha) else: max_iter = 10 releps = 3e-14 C = [9.084064e-01, 5.214976e-02, 2.579930e-03, 3.986126e-03] # Initial approximations to the roots go into z. anu = 4.0 * n + 2.0 * alpha + 2.0 rhs = np.arange(4 * n - 1, 2, -4) * np.pi / anu r3 = rhs ** (1. / 3) r2 = r3 ** 2 theta = r3 * (C[0] + r2 * (C[1] + r2 * (C[2] + r2 * C[3]))) z = anu * np.cos(theta) ** 2 dz = zeros(len(z)) L = zeros((3, len(z))) Lp = zeros((1, len(z))) pp = zeros((1, len(z))) k0 = 0 kp1 = 1 k = slice(len(z)) for _its in xrange(max_iter): # Newton's method carried out simultaneously on the roots. L[k0, k] = 0. L[kp1, k] = 1. for jj in xrange(1, n + 1): # Loop up the recurrence relation to get the Laguerre # polynomials evaluated at z. km1 = k0 k0 = kp1 kp1 = np.mod(kp1 + 1, 3) L[kp1, k] = ((2 * jj - 1 + alpha - z[k]) * L[ k0, k] - (jj - 1 + alpha) * L[km1, k]) / jj # end # L now contains the desired Laguerre polynomials. # We next compute pp, the derivatives with a standard # relation involving the polynomials of one lower order. Lp[k] = L[k0, k] pp[k] = (n * L[kp1, k] - (n + alpha) * Lp[k]) / z[k] dz[k] = L[kp1, k] / pp[k] z[k] = z[k] - dz[k] # % Newton?s formula. # k = find((abs(dz) > releps.*z)) if not np.any(abs(dz) > releps): break else: warnings.warn('too many iterations!') x = z w = -np.exp(sp.gammaln(alpha + n) - sp.gammaln(n)) / (pp * n * Lp) return x, w
def Vmat(N,L): q = la_roots(N,2*L+2)[0].real return diag([-1/qi for qi in q])
def quadrature(self,n): return so.la_roots(n,0) class ChebyshevPolynomial(OrthogonalPolynomial):