def __init__(self, domain, range=None, axes=None, sign='-',
                 halfcomplex=False, impl=None):
        """Initialize a new instance.

        Parameters
        ----------
        domain : `DiscreteLp`
            Domain of the Fourier transform. If its
            `DiscreteLp.exponent` is equal to 2.0, this operator has
            an adjoint which is equal to the inverse.
        range : `DiscreteLp`, optional
            Range of the Fourier transform. If not given, the range
            is determined from ``domain`` and the other parameters as
            a `discr_sequence_space` with exponent ``p / (p - 1)``
            (read as 'inf' for p=1 and 1 for p='inf').
        axes : int or sequence of ints, optional
            Dimensions in which a transform is to be calculated. ``None``
            means all axes.
        sign : {'-', '+'}, optional
            Sign of the complex exponent.
        halfcomplex : bool, optional
            If ``True``, calculate only the negative frequency part
            along the last axis in ``axes`` for real input. This
            reduces the size of the range to ``floor(N[i]/2) + 1`` in
            this axis ``i``, where ``N`` is the shape of the input
            arrays.
            Otherwise, calculate the full complex FFT. If ``dom_dtype``
            is a complex type, this option has no effect.
        impl : {'numpy', 'pyfftw'}, optional
            Backend for the FFT implementation. The ``'pyfftw'`` backend
            is faster but requires the ``pyfftw`` package.
            ``None`` selects the fastest available backend.

        Examples
        --------
        Complex-to-complex (default) transforms have the same grids
        in domain and range:

        >>> domain = discr_sequence_space((2, 4))
        >>> fft = DiscreteFourierTransform(domain)
        >>> fft.domain.shape
        (2, 4)
        >>> fft.range.shape
        (2, 4)

        Real-to-complex transforms have a range grid with shape
        ``n // 2 + 1`` in the last tranform axis:

        >>> domain = discr_sequence_space((2, 3, 4), dtype='float')
        >>> axes = (0, 1)
        >>> fft = DiscreteFourierTransform(
        ...     domain, halfcomplex=True, axes=axes)
        >>> fft.range.shape   # shortened in the second axis
        (2, 2, 4)
        >>> fft.domain.shape
        (2, 3, 4)
        """
        super(DiscreteFourierTransform, self).__init__(
            inverse=False, domain=domain, range=range, axes=axes,
            sign=sign, halfcomplex=halfcomplex, impl=impl)
def __init__ ( self , domain , range = None , axes = None , sign = '-' , halfcomplex = False , impl = None ) : super ( DiscreteFourierTransform , self ) . __init__ ( inverse = False , domain = domain , range = range , axes = axes , sign = sign , halfcomplex = halfcomplex , impl = impl )
Initialize a new instance.

        Parameters
        ----------
        domain : `DiscreteLp`
            Domain of the Fourier transform. If its
            `DiscreteLp.exponent` is equal to 2.0, this operator has
            an adjoint which is equal to the inverse.
        range : `DiscreteLp`, optional
            Range of the Fourier transform. If not given, the range
            is determined from ``domain`` and the other parameters as
            a `discr_sequence_space` with exponent ``p / (p - 1)``
            (read as 'inf' for p=1 and 1 for p='inf').
        axes : int or sequence of ints, optional
            Dimensions in which a transform is to be calculated. ``None``
            means all axes.
        sign : {'-', '+'}, optional
            Sign of the complex exponent.
        halfcomplex : bool, optional
            If ``True``, calculate only the negative frequency part
            along the last axis in ``axes`` for real input. This
            reduces the size of the range to ``floor(N[i]/2) + 1`` in
            this axis ``i``, where ``N`` is the shape of the input
            arrays.
            Otherwise, calculate the full complex FFT. If ``dom_dtype``
            is a complex type, this option has no effect.
        impl : {'numpy', 'pyfftw'}, optional
            Backend for the FFT implementation. The ``'pyfftw'`` backend
            is faster but requires the ``pyfftw`` package.
            ``None`` selects the fastest available backend.

        Examples
        --------
        Complex-to-complex (default) transforms have the same grids
        in domain and range:

        >>> domain = discr_sequence_space((2, 4))
        >>> fft = DiscreteFourierTransform(domain)
        >>> fft.domain.shape
        (2, 4)
        >>> fft.range.shape
        (2, 4)

        Real-to-complex transforms have a range grid with shape
        ``n // 2 + 1`` in the last tranform axis:

        >>> domain = discr_sequence_space((2, 3, 4), dtype='float')
        >>> axes = (0, 1)
        >>> fft = DiscreteFourierTransform(
        ...     domain, halfcomplex=True, axes=axes)
        >>> fft.range.shape   # shortened in the second axis
        (2, 2, 4)
        >>> fft.domain.shape
        (2, 3, 4)