class_docstr: WARNING: for officially supported FFTs, use theano.tensor.fft, which
  provides real-input FFTs. Gradients are supported, as well as optimization
  transfers to GPU ops.
  
  An instance of this class returns a finite fourier transform calcutated
  along one dimension of an input array.
  
  inputs:
  
  a : Array of at least one dimension.  Can be complex.
  n : Integer, optional. Length of the transformed axis of the output. 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 : Integer, optional. Axis over which to compute the FFT. If not
  supplied, the last axis is used.
  
  output:
  
  Complex array.  The input array, transformed along the axis
  indicated by 'axis' or along the last axis if 'axis' is not specified. It
  is truncated or zero-padded as required if 'n' is specified.
  (From numpy.fft.fft's documentation:)
  The values in the output follow so-called standard order. If A = fft(a, n),
  then A[0] contains the zero-frequency term (the mean of the signal), which
  is always purely real for real inputs. Then A[1:n/2] contains the
  positive-frequency terms, and A[n/2+1:] contains the negative-frequency
  terms, in order of decreasingly negative frequency. For an even number of
  input points, A[n/2] represents both positive and negative Nyquist
  frequency, and is also purely real for real input. For an odd number of
  input points, A[(n-1)/2] contains the largest positive frequency, while
  A[(n+1)/2] contains the largest negative frequency.
code: def make_node(self, a, n, axis):
      a = tensor.as_tensor_variable(a)
      if a.ndim < 1:
          raise TypeError(
              "%s: input must be an array, not a scalar"
              % self.__class__.__name__
          )
      if axis is None:
          axis = a.ndim - 1
          axis = tensor.as_tensor_variable(axis)
      else:
          axis = tensor.as_tensor_variable(axis)
          if axis.dtype not in tensor.integer_dtypes:
              raise TypeError(
                  "%s: index of the transformed axis must be"
                  " of type integer" % self.__class__.__name__
              )
          elif axis.ndim != 0 or (
              isinstance(axis, tensor.TensorConstant)
              and (axis.data < 0 or axis.data > a.ndim - 1)
          ):
              raise TypeError(
                  "%s: index of the transformed axis must be"
                  " a scalar not smaller than 0 and smaller than"
                  " dimension of array" % self.__class__.__name__
              )
      if n is None:
          n = a.shape[axis]
          n = tensor.as_tensor_variable(n)
      else:
          n = tensor.as_tensor_variable(n)
          if n.dtype not in tensor.integer_dtypes:
              raise TypeError(
                  "%s: length of the transformed axis must be"
                  " of type integer" % self.__class__.__name__
              )
          elif n.ndim != 0 or (
              isinstance(n, tensor.TensorConstant) and n.data < 1
          ):
              raise TypeError(
                  "%s: length of the transformed axis must be a"
                  " strictly positive scalar" % self.__class__.__name__
              )
      return gof.Apply(
          self,
          [a, n, axis],
          [tensor.TensorType("complex128", a.type.broadcastable)()],
      )
  
file_path: Theano/theano/tensor/fourier.py
imports: from __future__ import absolute_import, print_function, division
  import numpy
  import math
  from theano import gof, tensor
label_desc: Use image node_id 1 for calling the Fourier obj's underlying member method code with example usage: obj.make_node(a, n, axis) and returns: gof