code: def residuez(b, a, tol=1e-3, rtype="avg"):
      """Compute partial-fraction expansion of b(z) / a(z).
  
      If `M` is the degree of numerator `b` and `N` the degree of denominator
      `a`::
  
                  b(z)     b[0] + b[1] z**(-1) + ... + b[M] z**(-M)
          H(z) = ------ = ------------------------------------------
                  a(z)     a[0] + a[1] z**(-1) + ... + a[N] z**(-N)
  
      then the partial-fraction expansion H(z) is defined as::
  
                   r[0]                   r[-1]
           = --------------- + ... + ---------------- + k[0] + k[1]z**(-1) ...
             (1-p[0]z**(-1))         (1-p[-1]z**(-1))
  
      If there are any repeated roots (closer than `tol`), then the partial
      fraction expansion has terms like::
  
               r[i]              r[i+1]                    r[i+n-1]
          -------------- + ------------------ + ... + ------------------
          (1-p[i]z**(-1))  (1-p[i]z**(-1))**2         (1-p[i]z**(-1))**n
  
      This function is used for polynomials in negative powers of z,
      such as digital filters in DSP.  For positive powers, use `residue`.
  
      See Notes of `residue` for details about the algorithm.
  
      Parameters
      ----------
      b : array_like
          Numerator polynomial coefficients.
      a : array_like
          Denominator polynomial coefficients.
      tol : float, optional
          The tolerance for two roots to be considered equal in terms of
          the distance between them. Default is 1e-3. See `unique_roots`
          for further details.
      rtype : {'avg', 'min', 'max'}, optional
          Method for computing a root to represent a group of identical roots.
          Default is 'avg'. See `unique_roots` for further details.
  
      Returns
      -------
      r : ndarray
          Residues corresponding to the poles. For repeated poles, the residues
          are ordered to correspond to ascending by power fractions.
      p : ndarray
          Poles ordered by magnitude in ascending order.
      k : ndarray
          Coefficients of the direct polynomial term.
  
      See Also
      --------
      invresz, residue, unique_roots
      """
      b = np.asarray(b)
      a = np.asarray(a)
      if np.issubdtype(b.dtype, np.complexfloating) or np.issubdtype(
          a.dtype, np.complexfloating
      ):
          b = b.astype(complex)
          a = a.astype(complex)
      else:
          b = b.astype(float)
          a = a.astype(float)
  
      b = np.trim_zeros(np.atleast_1d(b), "b")
      a = np.trim_zeros(np.atleast_1d(a), "b")
  
      if a.size == 0:
          raise ValueError("Denominator `a` is zero.")
      elif a[0] == 0:
          raise ValueError(
              "First coefficient of determinant `a` must be "
              "non-zero."
          )
  
      poles = np.roots(a)
      if b.size == 0:
          return (
              np.zeros(poles.shape),
              cmplx_sort(poles)[0],
              np.array([]),
          )
  
      b_rev = b[::-1]
      a_rev = a[::-1]
  
      if len(b_rev) < len(a_rev):
          k_rev = np.empty(0)
      else:
          k_rev, b_rev = np.polydiv(b_rev, a_rev)
  
      unique_poles, multiplicity = unique_roots(
          poles, tol=tol, rtype=rtype
      )
      unique_poles, order = cmplx_sort(unique_poles)
      multiplicity = multiplicity[order]
  
      residues = _compute_residues(
          1 / unique_poles, multiplicity, b_rev
      )
  
      index = 0
      powers = np.empty(len(residues), dtype=int)
      for pole, mult in zip(unique_poles, multiplicity):
          poles[index : index + mult] = pole
          powers[index : index + mult] = 1 + np.arange(mult)
          index += mult
  
      residues *= (-poles) ** powers / a_rev[0]
  
      return residues, poles, k_rev[::-1]
  
imports: import operator
  import math
  import timeit
  from scipy.spatial import cKDTree
  from .None import sigtools, dlti
  from ._upfirdn import upfirdn, _output_len, _upfirdn_modes
  from scipy import linalg, fft
  from scipy.fft._helper import _init_nd_shape_and_axes
  from scipy._lib._util import prod
  import numpy
  from scipy.special import lambertw
  from .windows import get_window
  from ._arraytools import axis_slice, axis_reverse, odd_ext, even_ext, const_ext
  from .filter_design import cheby1, _validate_sos
  from .fir_filter_design import firwin
  from ._sosfilt import _sosfilt
  import warnings
label_desc: Use image node_id 38 for calling a global function with example usage: residuez(b, a, tol, rtype) and returns: residues,  poles,  k_rev, np,  cmplx_sort,  np