code: def rfft(
      x,
      n=None,
      axis=-1,
      norm=None,
      overwrite_x=False,
      workers=None,
      *,
      plan=None,
  ):
      """
      Compute the 1-D discrete Fourier Transform for real input.
  
      This function computes the 1-D *n*-point discrete Fourier
      Transform (DFT) of a real-valued array by means of an efficient algorithm
      called the Fast Fourier Transform (FFT).
  
      Parameters
      ----------
      x : array_like
          Input array
      n : int, optional
          Number of points along transformation axis in the input to use.
          If `n` is smaller than the length of the input, the input is cropped.
          If it is larger, the input is padded with zeros. If `n` is not given,
          the length of the input along the axis specified by `axis` is used.
      axis : int, optional
          Axis over which to compute the FFT. If not given, the last axis is
          used.
      norm : {"backward", "ortho", "forward"}, optional
          Normalization mode (see `fft`). Default is "backward".
      overwrite_x : bool, optional
          If True, the contents of `x` can be destroyed; the default is False.
          See :func:`fft` for more details.
      workers : int, optional
          Maximum number of workers to use for parallel computation. If negative,
          the value wraps around from ``os.cpu_count()``.
          See :func:`~scipy.fft.fft` for more details.
      plan : object, optional
          This argument is reserved for passing in a precomputed plan provided
          by downstream FFT vendors. It is currently not used in SciPy.
  
          .. versionadded:: 1.5.0
  
      Returns
      -------
      out : complex ndarray
          The truncated or zero-padded input, transformed along the axis
          indicated by `axis`, or the last one if `axis` is not specified.
          If `n` is even, the length of the transformed axis is ``(n/2)+1``.
          If `n` is odd, the length is ``(n+1)/2``.
  
      Raises
      ------
      IndexError
          If `axis` is larger than the last axis of `a`.
  
      See Also
      --------
      irfft : The inverse of `rfft`.
      fft : The 1-D FFT of general (complex) input.
      fftn : The N-D FFT.
      rfft2 : The 2-D FFT of real input.
      rfftn : The N-D FFT of real input.
  
      Notes
      -----
      When the DFT is computed for purely real input, the output is
      Hermitian-symmetric, i.e., the negative frequency terms are just the complex
      conjugates of the corresponding positive-frequency terms, and the
      negative-frequency terms are therefore redundant. This function does not
      compute the negative frequency terms, and the length of the transformed
      axis of the output is therefore ``n//2 + 1``.
  
      When ``X = rfft(x)`` and fs is the sampling frequency, ``X[0]`` contains
      the zero-frequency term 0*fs, which is real due to Hermitian symmetry.
  
      If `n` is even, ``A[-1]`` contains the term representing both positive
      and negative Nyquist frequency (+fs/2 and -fs/2), and must also be purely
      real. If `n` is odd, there is no term at fs/2; ``A[-1]`` contains
      the largest positive frequency (fs/2*(n-1)/n), and is complex in the
      general case.
  
      If the input `a` contains an imaginary part, it is silently discarded.
  
      Examples
      --------
      >>> import scipy.fft
      >>> scipy.fft.fft([0, 1, 0, 0])
      array([ 1.+0.j,  0.-1.j, -1.+0.j,  0.+1.j]) # may vary
      >>> scipy.fft.rfft([0, 1, 0, 0])
      array([ 1.+0.j,  0.-1.j, -1.+0.j]) # may vary
  
      Notice how the final element of the `fft` output is the complex conjugate
      of the second element, for real input. For `rfft`, this symmetry is
      exploited to compute only the non-negative frequency terms.
  
      """
      return (Dispatchable(x, np.ndarray),)
  
imports: from scipy._lib.uarray import generate_multimethod, Dispatchable
  import numpy
label_desc: Use image node_id 5 for calling a global function with example usage: rfft(x, n, axis, norm, overwrite_x, workers) and returns: Dispatchable