code: def correlate(
      in1,
      in2,
      mode="full",
      method="auto",
  ):
      r"""
      Cross-correlate two N-dimensional arrays.
  
      Cross-correlate `in1` and `in2`, with the output size determined by the
      `mode` argument.
  
      Parameters
      ----------
      in1 : array_like
          First input.
      in2 : array_like
          Second input. Should have the same number of dimensions as `in1`.
      mode : str {'full', 'valid', 'same'}, optional
          A string indicating the size of the output:
  
          ``full``
             The output is the full discrete linear cross-correlation
             of the inputs. (Default)
          ``valid``
             The output consists only of those elements that do not
             rely on the zero-padding. In 'valid' mode, either `in1` or `in2`
             must be at least as large as the other in every dimension.
          ``same``
             The output is the same size as `in1`, centered
             with respect to the 'full' output.
      method : str {'auto', 'direct', 'fft'}, optional
          A string indicating which method to use to calculate the correlation.
  
          ``direct``
             The correlation is determined directly from sums, the definition of
             correlation.
          ``fft``
             The Fast Fourier Transform is used to perform the correlation more
             quickly (only available for numerical arrays.)
          ``auto``
             Automatically chooses direct or Fourier method based on an estimate
             of which is faster (default).  See `convolve` Notes for more detail.
  
      Returns
      -------
      correlate : array
          An N-dimensional array containing a subset of the discrete linear
          cross-correlation of `in1` with `in2`.
  
      See Also
      --------
      choose_conv_method : contains more documentation on `method`.
  
      Notes
      -----
      The correlation z of two d-dimensional arrays x and y is defined as::
  
          z[...,k,...] =
              sum[..., i_l, ...] x[..., i_l,...] * conj(y[..., i_l - k,...])
  
      This way, if x and y are 1-D arrays and ``z = correlate(x, y, 'full')``
      then
  
      .. math::
  
            z[k] = (x * y)(k - N + 1)
                 = \sum_{l=0}^{||x||-1}x_l y_{l-k+N-1}^{*}
  
      for :math:`k = 0, 1, ..., ||x|| + ||y|| - 2`
  
      where :math:`||x||` is the length of ``x``, :math:`N = \max(||x||,||y||)`,
      and :math:`y_m` is 0 when m is outside the range of y.
  
      ``method='fft'`` only works for numerical arrays as it relies on
      `fftconvolve`. In certain cases (i.e., arrays of objects or when
      rounding integers can lose precision), ``method='direct'`` is always used.
  
      Examples
      --------
      Implement a matched filter using cross-correlation, to recover a signal
      that has passed through a noisy channel.
  
      >>> import cusignal
      >>> import cupy as cp
      >>> sig = cp.repeat(cp.array([0., 1., 1., 0., 1., 0., 0., 1.]), 128)
      >>> sig_noise = sig + cp.random.randn(len(sig))
      >>> corr = cusignal.correlate(sig_noise, cp.ones(128), mode='same') / 128
  
      >>> import matplotlib.pyplot as plt
      >>> clock = cp.arange(64, len(sig), 128)
      >>> fig, (ax_orig, ax_noise, ax_corr) = plt.subplots(3, 1, sharex=True)
      >>> ax_orig.plot(cp.asnumpy(sig))
      >>> ax_orig.plot(cp.asnumpy(clock), cp.asnumpy(sig[clock]), 'ro')
      >>> ax_orig.set_title('Original signal')
      >>> ax_noise.plot(cp.asnumpy(sig_noise))
      >>> ax_noise.set_title('Signal with noise')
      >>> ax_corr.plot(cp.asnumpy(corr))
      >>> ax_corr.plot(cp.asnumpy(clock), cp.asnumpy(corr[clock]), 'ro')
      >>> ax_corr.axhline(0.5, ls=':')
      >>> ax_corr.set_title('Cross-correlated with rectangular pulse')
      >>> ax_orig.margins(0, 0.1)
      >>> fig.tight_layout()
      >>> fig.show()
  
      """
  
      in1 = cp.asarray(in1)
      in2 = cp.asarray(in2)
  
      if in1.ndim == in2.ndim == 0:
          return in1 * in2.conj()
      elif in1.ndim != in2.ndim:
          raise ValueError(
              "in1 and in2 should have the same dimensionality"
          )
  
      # this either calls fftconvolve or this function with method=='direct'
      if method in ("fft", "auto"):
          return convolve(in1, _reverse_and_conj(in2), mode, method)
  
      elif method == "direct":
          if in1.ndim > 1:
              raise ValueError(
                  "Direct method is only implemented for 1D"
              )
  
          swapped_inputs = in2.size > in1.size
  
          if swapped_inputs:
              in1, in2 = in2, in1
  
          return _convolution_cuda._convolve(
              in1, in2, False, swapped_inputs, mode
          )
  
      else:
          raise ValueError(
              "Acceptable method flags are 'auto',"
              " 'direct', or 'fft'."
          )
  
imports: import cupy
  from .None import _convolution_cuda
  from .convolution_utils import _inputs_swap_needed, _reverse_and_conj
  from .convolve import convolve
label_desc: Use image node_id 1 for calling a global function with example usage: correlate(in1, in2, mode, method) and returns: unknown, convolve, _convolution_cuda