code: def poly(seq_of_zeros):
      """
      Find the coefficients of a polynomial with the given sequence of roots.
  
      .. note::
         This forms part of the old polynomial API. Since version 1.4, the
         new polynomial API defined in `numpy.polynomial` is preferred.
         A summary of the differences can be found in the
         :doc:`transition guide </reference/routines.polynomials>`.
  
      Returns the coefficients of the polynomial whose leading coefficient
      is one for the given sequence of zeros (multiple roots must be included
      in the sequence as many times as their multiplicity; see Examples).
      A square matrix (or array, which will be treated as a matrix) can also
      be given, in which case the coefficients of the characteristic polynomial
      of the matrix are returned.
  
      Parameters
      ----------
      seq_of_zeros : array_like, shape (N,) or (N, N)
          A sequence of polynomial roots, or a square array or matrix object.
  
      Returns
      -------
      c : ndarray
          1D array of polynomial coefficients from highest to lowest degree:
  
          ``c[0] * x**(N) + c[1] * x**(N-1) + ... + c[N-1] * x + c[N]``
          where c[0] always equals 1.
  
      Raises
      ------
      ValueError
          If input is the wrong shape (the input must be a 1-D or square
          2-D array).
  
      See Also
      --------
      polyval : Compute polynomial values.
      roots : Return the roots of a polynomial.
      polyfit : Least squares polynomial fit.
      poly1d : A one-dimensional polynomial class.
  
      Notes
      -----
      Specifying the roots of a polynomial still leaves one degree of
      freedom, typically represented by an undetermined leading
      coefficient. [1]_ In the case of this function, that coefficient -
      the first one in the returned array - is always taken as one. (If
      for some reason you have one other point, the only automatic way
      presently to leverage that information is to use ``polyfit``.)
  
      The characteristic polynomial, :math:`p_a(t)`, of an `n`-by-`n`
      matrix **A** is given by
  
      :math:`p_a(t) = \\mathrm{det}(t\\, \\mathbf{I} - \\mathbf{A})`,
  
      where **I** is the `n`-by-`n` identity matrix. [2]_
  
      References
      ----------
      .. [1] M. Sullivan and M. Sullivan, III, "Algebra and Trigonometry,
         Enhanced With Graphing Utilities," Prentice-Hall, pg. 318, 1996.
  
      .. [2] G. Strang, "Linear Algebra and Its Applications, 2nd Edition,"
         Academic Press, pg. 182, 1980.
  
      Examples
      --------
      Given a sequence of a polynomial's zeros:
  
      >>> np.poly((0, 0, 0)) # Multiple root example
      array([1., 0., 0., 0.])
  
      The line above represents z**3 + 0*z**2 + 0*z + 0.
  
      >>> np.poly((-1./2, 0, 1./2))
      array([ 1.  ,  0.  , -0.25,  0.  ])
  
      The line above represents z**3 - z/4
  
      >>> np.poly((np.random.random(1)[0], 0, np.random.random(1)[0]))
      array([ 1.        , -0.77086955,  0.08618131,  0.        ]) # random
  
      Given a square array object:
  
      >>> P = np.array([[0, 1./3], [-1./2, 0]])
      >>> np.poly(P)
      array([1.        , 0.        , 0.16666667])
  
      Note how in all cases the leading coefficient is always 1.
  
      """
      seq_of_zeros = atleast_1d(seq_of_zeros)
      sh = seq_of_zeros.shape
  
      if len(sh) == 2 and sh[0] == sh[1] and sh[0] != 0:
          seq_of_zeros = eigvals(seq_of_zeros)
      elif len(sh) == 1:
          dt = seq_of_zeros.dtype
          # Let object arrays slip through, e.g. for arbitrary precision
          if dt != object:
              seq_of_zeros = seq_of_zeros.astype(mintypecode(dt.char))
      else:
          raise ValueError(
              "input must be 1d or non-empty square 2d array."
          )
  
      if len(seq_of_zeros) == 0:
          return 1.0
      dt = seq_of_zeros.dtype
      a = ones((1,), dtype=dt)
      for zero in seq_of_zeros:
          a = NX.convolve(a, array([1, -zero], dtype=dt), mode="full")
  
      if issubclass(a.dtype.type, NX.complexfloating):
          # if complex roots are all complex conjugates, the roots are real.
          roots = NX.asarray(seq_of_zeros, complex)
          if NX.all(NX.sort(roots) == NX.sort(roots.conjugate())):
              a = a.real.copy()
  
      return a
  
imports: import functools
  import re
  import warnings
  from .._utils import set_module
  import numpy._core.numeric
  from numpy._core import isscalar, abs, finfo, atleast_1d, hstack, dot, array, ones
  from numpy._core import overrides
  from numpy.exceptions import RankWarning
  from numpy.lib._twodim_base_impl import diag, vander
  from numpy.lib._function_base_impl import trim_zeros
  from numpy.lib._type_check_impl import iscomplex, real, imag, mintypecode
  from numpy.linalg import eigvals, lstsq, inv
label_desc: Use image node_id 2 for calling a global function with example usage: poly(seq_of_zeros) and returns: a, int