code: def legfromroots(roots):
      """
      Generate a Legendre series with given roots.
  
      The function returns the coefficients of the polynomial
  
      .. math:: p(x) = (x - r_0) * (x - r_1) * ... * (x - r_n),
  
      in Legendre form, where the `r_n` are the roots specified in `roots`.
      If a zero has multiplicity n, then it must appear in `roots` n times.
      For instance, if 2 is a root of multiplicity three and 3 is a root of
      multiplicity 2, then `roots` looks something like [2, 2, 2, 3, 3]. The
      roots can appear in any order.
  
      If the returned coefficients are `c`, then
  
      .. math:: p(x) = c_0 + c_1 * L_1(x) + ... +  c_n * L_n(x)
  
      The coefficient of the last term is not generally 1 for monic
      polynomials in Legendre form.
  
      Parameters
      ----------
      roots : array_like
          Sequence containing the roots.
  
      Returns
      -------
      out : ndarray
          1-D array of coefficients.  If all roots are real then `out` is a
          real array, if some of the roots are complex, then `out` is complex
          even if all the coefficients in the result are real (see Examples
          below).
  
      See Also
      --------
      polyfromroots, chebfromroots, lagfromroots, hermfromroots,
      hermefromroots.
  
      Examples
      --------
      >>> import numpy.polynomial.legendre as L
      >>> L.legfromroots((-1,0,1)) # x^3 - x relative to the standard basis
      array([ 0. , -0.4,  0. ,  0.4])
      >>> j = complex(0,1)
      >>> L.legfromroots((-j,j)) # x^2 + 1 relative to the standard basis
      array([ 1.33333333+0.j,  0.00000000+0.j,  0.66666667+0.j])
  
      """
      if len(roots) == 0:
          return np.ones(1)
      else:
          [roots] = pu.as_series([roots], trim=False)
          roots.sort()
          p = [legline(-r, 1) for r in roots]
          n = len(p)
          while n > 1:
              m, r = divmod(n, 2)
              tmp = [legmul(p[i], p[i + m]) for i in range(m)]
              if r:
                  tmp[0] = legmul(tmp[0], p[-1])
              p = tmp
              n = m
          return p[0]
  
imports: from __future__ import division, absolute_import, print_function
  import warnings
  import numpy
  import numpy.linalg
  from numpy.core.multiarray import normalize_axis_index
  from .None import polyutils
  from ._polybase import ABCPolyBase
label_desc: Use image node_id 4 for calling a global function with example usage: legfromroots(roots) and returns: np, p