code: def roots(p):
      """
      Return the roots of a polynomial with coefficients given in p.
  
      The values in the rank-1 array `p` are coefficients of a polynomial.
      If the length of `p` is n+1 then the polynomial is described by::
  
        p[0] * x**n + p[1] * x**(n-1) + ... + p[n-1]*x + p[n]
  
      Parameters
      ----------
      p : array_like
          Rank-1 array of polynomial coefficients.
  
      Returns
      -------
      out : ndarray
          An array containing the roots of the polynomial.
  
      Raises
      ------
      ValueError
          When `p` cannot be converted to a rank-1 array.
  
      See also
      --------
      poly : Find the coefficients of a polynomial with a given sequence
             of roots.
      polyval : Compute polynomial values.
      polyfit : Least squares polynomial fit.
      poly1d : A one-dimensional polynomial class.
  
      Notes
      -----
      The algorithm relies on computing the eigenvalues of the
      companion matrix [1]_.
  
      References
      ----------
      .. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*.  Cambridge, UK:
          Cambridge University Press, 1999, pp. 146-7.
  
      Examples
      --------
      >>> coeff = [3.2, 2, 1]
      >>> np.roots(coeff)
      array([-0.3125+0.46351241j, -0.3125-0.46351241j])
  
      """
      # If input is scalar, this makes it an array
      p = atleast_1d(p)
      if p.ndim != 1:
          raise ValueError("Input must be a rank-1 array.")
  
      # find non-zero array entries
      non_zero = NX.nonzero(NX.ravel(p))[0]
  
      # Return an empty array if polynomial is all zeros
      if len(non_zero) == 0:
          return NX.array([])
  
      # find the number of trailing zeros -- this is the number of roots at 0.
      trailing_zeros = len(p) - non_zero[-1] - 1
  
      # strip leading and trailing zeros
      p = p[int(non_zero[0]) : int(non_zero[-1]) + 1]
  
      # casting: if incoming array isn't floating point, make it floating point.
      if not issubclass(
          p.dtype.type, (NX.floating, NX.complexfloating)
      ):
          p = p.astype(float)
  
      N = len(p)
      if N > 1:
          # build companion matrix and find its eigenvalues (the roots)
          A = diag(NX.ones((N - 2,), p.dtype), -1)
          A[0, :] = -p[1:] / p[0]
          roots = eigvals(A)
      else:
          roots = NX.array([])
  
      # tack any zeros onto the back of the array
      roots = hstack((roots, NX.zeros(trailing_zeros, roots.dtype)))
      return roots
  
imports: from __future__ import division, absolute_import, print_function
  import functools
  import re
  import warnings
  import numpy.core.numeric
  from numpy.core import isscalar, abs, finfo, atleast_1d, hstack, dot, array, ones
  from numpy.core import overrides
  from numpy.core.overrides import set_module
  from numpy.lib.twodim_base import diag, vander
  from numpy.lib.function_base import trim_zeros
  from numpy.lib.type_check import iscomplex, real, imag, mintypecode
  from numpy.linalg import eigvals, lstsq, inv
label_desc: Use image node_id 4 for calling a global function with example usage: roots(p) and returns: roots, NX