Cfft1d/Zfft1d executes the Fast Fourier Transform in place and requires no
additional processing for inverse transforms.  Results of an inverse transform
have already been scaled to return the values of the original array.

Usage:

    Fortran:

        call cfft1d (data_in, num_pts, isign, temp_data)
        call zfft1d (data_in, num_pts, isign, temp_data)

    C:

        cfft1d_ (data_in, &num_pts, &isign, temp_data);
        zfft1d_ (data_in, &num_pts, &isign, temp_data);

Description:

    Cfft1d/zfft1d computes the forward or inverse FFT on complex data in
    single (cfft1d) or double (zfft1d) precision.  For an inverse FFT,
    results are scaled by 1/num_pts to return the original values.

Routine parameters:

    Fortran:

        cfft1d:

            complex    data_in (num_pts), temp_data (num_pts)
            integer    num_pts, isign

        zfft1d:

            complex*16 data_in (num_pts), temp_data (num_pts)
            integer    num_pts, isign

    C:

        cfft1d:

            typedef struct {
               float real, imag;
            } complex;

            complex    data_in [num_pts], temp_data [num_pts];
            int        num_pts, isign;

        zfft1d:

            typedef struct {
               double real, imag;
            } dcomplex;
 
            dcomplex   data_in [num_pts], temp_data [num_pts];
            int        num_pts, isign;

            Where num_pts is at least as large as the size of the transform to
            be calculated.

Parameter Description:

            data_in:  array of at least size num_pts which contains the data
                      points to be processed.

            temp_data:  array of at least size num_pts which will be used by the
                        routine for temporary storage of intermediate values.

            num_pts:  integer indicating the size of the transform desired

            isign:  integer value which indicates the action desired:

                    0:  decompose the problem and initialize the coefficient
                        arrays

                   -1:  perform a forward FFT on the data held in data_in

                    1:  perform an inverse FFT on the data held in data_in

    The input arrays may also be simple arrays of real values with the data
ordered appropriately (real1, complex1, real2, complex2, real3, complex3, ...).
In any case, the output data will be arranged in the same order.

    A call to cfft1d/zfft1d must first be made with isign = 0 to decompose
the problem and initialize the coefficient arrays.  After this, any number of
transforms of the same length may be computed.  If a transform of a different
size is desired, another call to cfft1d/zfft1d with isign = 0 is required to
decompose the new problem and generate new coefficients.  The array temp_data
may safely be used for other work between invocations of cfft1d/zfft1d.

    Transform sizes are restricted to values which factor completely
into the numbers 2, 3, 5, and 7.  Each of these numbers may appear
multiple times in the factorization.  In addition, transform sizes whose
factorizations contain 11 or 13 exactly once (11 or 13, but not both) are
also allowed.  For example, a transform of size 55 (11 * 5) or 39 (13 * 3)
can be computed, while a transform of size 143 (11 * 13) can not.  Work is
currently underway to allow odd sizes to be processed using an N**2
algorithm.  If an unsupported transform size is attempted, the routine will
exit with an error message.

Behavior:

    isign = 0:

        any values in data_in or temp_data are unchanged

    isign < 0:

        data_in contains the results of a forward FFT performed on the data
        points previously held in the array.  Any previous values in
        temp_data will be lost.

    isign > 0:

        data_in contains the results of an inverse FFT performed on the
        data points previously held in the array.  Values have already been
        scaled by 1/num_pts.  Any previous values in temp_data will be lost.