code: def _qnwlege1(n, a, b):
      
      # import ipdb; ipdb.set_trace()
      maxit = 100
      m = int(fix((n + 1) / 2.0))
      xm = 0.5 * (b + a)
      xl = 0.5 * (b - a)
      nodes = np.zeros(n)
  
      weights = nodes.copy()
      i = np.arange(m)
  
      z = np.cos(np.pi * ((i + 1.0) - 0.25) / (n + 0.5))
  
      for its in range(maxit):
          p1 = np.ones_like(z)
          p2 = np.zeros_like(z)
          for j in range(1, n+1):
              p3 = p2
              p2 = p1
              p1 = ((2 * j - 1) * z * p2 - (j - 1) * p3) / j
  
          pp = n * (z * p1 - p2)/(z * z - 1.0)
          z1 = z.copy()
          z = z1 - p1/pp
          if np.all(np.abs(z - z1) < 1e-14):
              break
  
      if its == maxit - 1:
          raise ValueError("Maximum iterations in _qnwlege1")
  
      nodes[i] = xm - xl * z
      nodes[- i - 1] = xm + xl * z
  
      weights[i] = 2 * xl / ((1 - z * z) * pp * pp)
      weights[- i - 1] = weights[i]
  
      return nodes, weights
docs: Compute univariate Guass-Legendre quadrature nodes and weights
  
      Parameters
      ----------
      n : int
          The number of nodes
  
      a : int
          The lower endpoint
  
      b : int
          The upper endpoint
  
      Returns
      -------
      nodes : np.ndarray(dtype=float)
          An n element array of nodes
  
      nodes : np.ndarray(dtype=float)
          An n element array of weights
  
      Notes
      -----
      Based of original function ``qnwlege1`` in CompEcon toolbox by
      Miranda and Fackler
  
      References
      ----------
      Miranda, Mario J, and Paul L Fackler. Applied Computational
      Economics and Finance, MIT Press, 2002.