code: def lp2bp(b, a, wo=1.0, bw=1.0):
      r"""
      Transform a lowpass filter prototype to a bandpass filter.
  
      Return an analog band-pass filter with center frequency `wo` and
      bandwidth `bw` from an analog low-pass filter prototype with unity
      cutoff frequency, in transfer function ('ba') representation.
  
      Parameters
      ----------
      b : array_like
          Numerator polynomial coefficients.
      a : array_like
          Denominator polynomial coefficients.
      wo : float
          Desired passband center, as angular frequency (e.g., rad/s).
          Defaults to no change.
      bw : float
          Desired passband width, as angular frequency (e.g., rad/s).
          Defaults to 1.
  
      Returns
      -------
      b : array_like
          Numerator polynomial coefficients of the transformed band-pass filter.
      a : array_like
          Denominator polynomial coefficients of the transformed band-pass
          filter.
  
      See Also
      --------
      lp2lp, lp2hp, lp2bs, bilinear
      lp2bp_zpk
      scipy.signal.lp2bp
  
      Notes
      -----
      This is derived from the s-plane substitution
  
      .. math:: s \rightarrow \frac{s^2 + {\omega_0}^2}{s \cdot \mathrm{BW}}
  
      This is the "wideband" transformation, producing a passband with
      geometric (log frequency) symmetry about `wo`.
  
      """
      a, b = map(cupy.atleast_1d, (a, b))
      D = len(a) - 1
      N = len(b) - 1
      artype = cupy.mintypecode((a.dtype, b.dtype))
      ma = max(N, D)
      Np = N + ma
      Dp = D + ma
      bprime = cupy.empty(Np + 1, artype)
      aprime = cupy.empty(Dp + 1, artype)
      wosq = wo * wo
      for j in range(Np + 1):
          val = 0.0
          for i in range(0, N + 1):
              for k in range(0, i + 1):
                  if ma - i + 2 * k == j:
                      val += (
                          comb(i, k)
                          * b[N - i]
                          * (wosq) ** (i - k)
                          / bw**i
                      )
          bprime[Np - j] = val
  
      for j in range(Dp + 1):
          val = 0.0
          for i in range(0, D + 1):
              for k in range(0, i + 1):
                  if ma - i + 2 * k == j:
                      val += (
                          comb(i, k)
                          * a[D - i]
                          * (wosq) ** (i - k)
                          / bw**i
                      )
          aprime[Dp - j] = val
  
      return normalize(bprime, aprime)
  
imports: import warnings
  import math
  from math import pi, prod
  import cupy
  from cupyx.scipy.special import binom
  import cupyx.scipy.special
  from cupyx.scipy.signal import _optimize
  from cupyx.scipy.signal._polyutils import roots, poly
  from cupyx.scipy.signal._lti_conversion import abcd_normalize
label_desc: Use image node_id 18 for calling a global function with example usage: lp2bp(b, a, wo, bw) and returns: normalize