code: def peak_prominences(x, peaks, wlen=None):
      """
      Calculate the prominence of each peak in a signal.
  
      The prominence of a peak measures how much a peak stands out from the
      surrounding baseline of the signal and is defined as the vertical distance
      between the peak and its lowest contour line.
  
      Parameters
      ----------
      x : sequence
          A signal with peaks.
      peaks : sequence
          Indices of peaks in `x`.
      wlen : int, optional
          A window length in samples that optionally limits the evaluated area
          for each peak to a subset of `x`. The peak is always placed in the
          middle of the window therefore the given length is rounded up to the
          next odd integer. This parameter can speed up the calculation
          (see Notes).
  
      Returns
      -------
      prominences : ndarray
          The calculated prominences for each peak in `peaks`.
      left_bases, right_bases : ndarray
          The peaks' bases as indices in `x` to the left and right of each peak.
          The higher base of each pair is a peak's lowest contour line.
  
      Raises
      ------
      ValueError
          If a value in `peaks` is an invalid index for `x`.
  
      Warns
      -----
      PeakPropertyWarning
          For indices in `peaks` that don't point to valid local maxima in `x`,
          the returned prominence will be 0 and this warning is raised. This
          also happens if `wlen` is smaller than the plateau size of a peak.
  
      Warnings
      --------
      This function may return unexpected results for data containing NaNs. To
      avoid this, NaNs should either be removed or replaced.
  
      See Also
      --------
      find_peaks
          Find peaks inside a signal based on peak properties.
      peak_widths
          Calculate the width of peaks.
  
      Notes
      -----
      Strategy to compute a peak's prominence:
  
      1. Extend a horizontal line from the current peak to the left and right
         until the line either reaches the window border (see `wlen`) or
         intersects the signal again at the slope of a higher peak. An
         intersection with a peak of the same height is ignored.
      2. On each side find the minimal signal value within the interval defined
         above. These points are the peak's bases.
      3. The higher one of the two bases marks the peak's lowest contour line.
         The prominence can then be calculated as the vertical difference between
         the peaks height itself and its lowest contour line.
  
      Searching for the peak's bases can be slow for large `x` with periodic
      behavior because large chunks or even the full signal need to be evaluated
      for the first algorithmic step. This evaluation area can be limited with
      the parameter `wlen` which restricts the algorithm to a window around the
      current peak and can shorten the calculation time if the window length is
      short in relation to `x`.
      However, this may stop the algorithm from finding the true global contour
      line if the peak's true bases are outside this window. Instead, a higher
      contour line is found within the restricted window leading to a smaller
      calculated prominence. In practice, this is only relevant for the highest
      set of peaks in `x`. This behavior may even be used intentionally to
      calculate "local" prominences.
  
      """
      x = _arg_x_as_expected(x)
      peaks = _arg_peaks_as_expected(peaks)
      wlen = _arg_wlen_as_expected(wlen)
      return _peak_prominences(x, peaks, wlen, check=True)
  
imports: import math
  import cupy
  from cupy._core._scalar import get_typename
  from cupy_backends.cuda.api import runtime
  from cupyx import jit
label_desc: Use image node_id 14 for calling a global function with example usage: peak_prominences(x, peaks, wlen) and returns: _peak_prominences