code: def upfirdn(h, x, up=1, down=1, axis=-1, mode="constant", cval=0):
      """Upsample, FIR filter, and downsample.
  
      Parameters
      ----------
      h : array_like
          1-D FIR (finite-impulse response) filter coefficients.
      x : array_like
          Input signal array.
      up : int, optional
          Upsampling rate. Default is 1.
      down : int, optional
          Downsampling rate. Default is 1.
      axis : int, optional
          The axis of the input data array along which to apply the
          linear filter. The filter is applied to each subarray along
          this axis. Default is -1.
      mode : str, optional
          The signal extension mode to use. The set
          ``{"constant", "symmetric", "reflect", "edge", "wrap"}`` correspond to
          modes provided by `numpy.pad`. ``"smooth"`` implements a smooth
          extension by extending based on the slope of the last 2 points at each
          end of the array. ``"antireflect"`` and ``"antisymmetric"`` are
          anti-symmetric versions of ``"reflect"`` and ``"symmetric"``. The mode
          `"line"` extends the signal based on a linear trend defined by the
          first and last points along the ``axis``.
  
          .. versionadded:: 1.4.0
      cval : float, optional
          The constant value to use when ``mode == "constant"``.
  
          .. versionadded:: 1.4.0
  
      Returns
      -------
      y : ndarray
          The output signal array. Dimensions will be the same as `x` except
          for along `axis`, which will change size according to the `h`,
          `up`,  and `down` parameters.
  
      Notes
      -----
      The algorithm is an implementation of the block diagram shown on page 129
      of the Vaidyanathan text [1]_ (Figure 4.3-8d).
  
      The direct approach of upsampling by factor of P with zero insertion,
      FIR filtering of length ``N``, and downsampling by factor of Q is
      O(N*Q) per output sample. The polyphase implementation used here is
      O(N/P).
  
      .. versionadded:: 0.18
  
      References
      ----------
      .. [1] P. P. Vaidyanathan, Multirate Systems and Filter Banks,
             Prentice Hall, 1993.
  
      Examples
      --------
      Simple operations:
  
      >>> import numpy as np
      >>> from scipy.signal import upfirdn
      >>> upfirdn([1, 1, 1], [1, 1, 1])   # FIR filter
      array([ 1.,  2.,  3.,  2.,  1.])
      >>> upfirdn([1], [1, 2, 3], 3)  # upsampling with zeros insertion
      array([ 1.,  0.,  0.,  2.,  0.,  0.,  3.])
      >>> upfirdn([1, 1, 1], [1, 2, 3], 3)  # upsampling with sample-and-hold
      array([ 1.,  1.,  1.,  2.,  2.,  2.,  3.,  3.,  3.])
      >>> upfirdn([.5, 1, .5], [1, 1, 1], 2)  # linear interpolation
      array([ 0.5,  1. ,  1. ,  1. ,  1. ,  1. ,  0.5])
      >>> upfirdn([1], np.arange(10), 1, 3)  # decimation by 3
      array([ 0.,  3.,  6.,  9.])
      >>> upfirdn([.5, 1, .5], np.arange(10), 2, 3)  # linear interp, rate 2/3
      array([ 0. ,  1. ,  2.5,  4. ,  5.5,  7. ,  8.5])
  
      Apply a single filter to multiple signals:
  
      >>> x = np.reshape(np.arange(8), (4, 2))
      >>> x
      array([[0, 1],
             [2, 3],
             [4, 5],
             [6, 7]])
  
      Apply along the last dimension of ``x``:
  
      >>> h = [1, 1]
      >>> upfirdn(h, x, 2)
      array([[ 0.,  0.,  1.,  1.],
             [ 2.,  2.,  3.,  3.],
             [ 4.,  4.,  5.,  5.],
             [ 6.,  6.,  7.,  7.]])
  
      Apply along the 0th dimension of ``x``:
  
      >>> upfirdn(h, x, 2, axis=0)
      array([[ 0.,  1.],
             [ 0.,  1.],
             [ 2.,  3.],
             [ 2.,  3.],
             [ 4.,  5.],
             [ 4.,  5.],
             [ 6.,  7.],
             [ 6.,  7.]])
      """
      x = np.asarray(x)
      ufd = _UpFIRDn(h, x.dtype, up, down)
      # This is equivalent to (but faster than) using np.apply_along_axis
      return ufd.apply_filter(x, axis, mode, cval)
  
file_path: scipy/scipy/signal/_upfirdn.py
imports: import numpy
  from ._upfirdn_apply import _output_len, _apply, mode_enum
label_desc: Use image node_id 3 for calling a global function with example usage: upfirdn(h, x, up, down, axis, mode, cval) and returns: ufd