code: def curfft(inp, norm=None):
      """
      Performs the fast Fourier transform of a real-valued input on the GPU.
  
      The input must be a real-valued float32 variable of dimensions (m, ..., n).
      It performs FFTs of size (..., n) on m batches.
  
      The output is a GpuArray of dimensions (m, ..., n//2+1, 2). The second to
      last dimension of the output contains the n//2+1 non-trivial elements of
      the real-valued FFTs. The real and imaginary parts are stored as a pair of
      float32 arrays.
  
      Parameters
      ----------
      inp
          Array of real-valued float32 of size (m, ..., n), containing m inputs of
          size (..., n).
      norm : {None, 'ortho', 'no_norm'}
          Normalization of transform. Following numpy, default *None* normalizes
          only the inverse transform by n, 'ortho' yields the unitary transform
          (:math:`1/\sqrt n` forward and inverse). In addition, 'no_norm' leaves
          the transform unnormalized.
  
      """
  
      s = inp.shape[1:]
      cond_norm = _unitary(norm)
      scaling = 1
      if cond_norm == "ortho":
          scaling = T.sqrt(s.prod().astype("float32"))
  
      return curfft_op(inp, s) / scaling
  
imports: from __future__ import absolute_import, print_function, division
  import numpy
  import theano
  from theano import Op
  import theano.tensor
  from theano.gradient import DisconnectedType
  from .basic_ops import gpu_contiguous, as_gpuarray_variable, infer_context_name
  from .type import GpuArrayType
  import theano.tensor.fft
  from .opt import register_opt, op_lifter, register_opt2
label_desc: Use image node_id 1 for calling a global function with example usage: curfft(inp, norm) and returns: unknown