code: def convolve1d3o(in1, in2, mode="valid", method="direct"):
      """
      Convolve a 1-dimensional array with a 3rd order filter.
      This results in a third order convolution.
  
      Convolve `in1` and `in2`, with the output size determined by the
      `mode` argument.
  
      Parameters
      ----------
      in1 : array_like
          First input. Should have one dimension.
      in2 : array_like
          Second input. Should have three dimensions.
      mode : str {'full', 'valid', 'same'}, optional
          A string indicating the size of the output:
  
          ``full``
             The output is the full discrete linear convolution
             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 convolution.
  
          ``direct``
             The convolution is determined directly from sums, the definition of
             convolution.
          ``fft``
             The Fourier Transform is used to perform the convolution by calling
             `fftconvolve`.
          ``auto``
             Automatically chooses direct or Fourier method based on an estimate
             of which is faster (default).
  
      Returns
      -------
      out : ndarray
          A 1-dimensional array containing a subset of the discrete linear
          convolution of `in1` with `in2`.
  
      See Also
      --------
      convolve
      convolve1d2o
      convolve1d3o
      """
  
      if in1.ndim != 1:
          raise ValueError("in1 should have one dimension")
      if in2.ndim != 3:
          raise ValueError("in2 should have three dimension")
  
      if mode in ["same", "full"]:
          raise NotImplementedError(
              "Mode == {} not implemented".format(mode)
          )
  
      if method == "direct":
          return _convolve1d3o(in1, in2, mode)
      else:
          raise NotImplementedError("Only Direct method implemented")
  
imports: import cupy
label_desc: Use image node_id 4 for calling a global function with example usage: convolve1d3o(in1, in2, mode, method) and returns: _convolve1d3o