Cmfft1d/Zmfft1d executes the Fast Fourier Transform in place on the rows or
columns of a complex matrix 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 cmfft1d (data_in, lead_x, num_cols, num_rows, isign, temp_data, rc)
      call zmfft1d (data_in, lead_x, num_cols, num_rows, isign, temp_data, rc)

   C:

      cmfft1d_ (data_in, &lead_x, &num_cols, &num_rows, &isign, temp_data, &rc);
      zmfft1d_ (data_in, &lead_x, &num_cols, &num_rows, &isign, temp_data, &rc);

Description:

    Cmfft1d/zmfft1d computes the forward or inverse FFT on either the rows or
    the columns of a matrix of complex data in single (cmfft1d) or double
    (zmfft1d) precision.  For an inverse FFT, results are scaled by 1/num_pts
    to return the values of the original matrix.

Routine parameters:

    Fortran:

        cmfft1d:

            complex    data_in (num_cols, num_rows)
            integer    num_cols, num_rows, lead_x, isign
            character  rc
c                 rc = 'c'
            complex    temp_data (num_cols)
c                 rc = 'r'
            complex    temp_data (num_rows)

        zmfft1d:

            complex*16 data_in (num_cols, num_rows)
            integer    num_cols, num_rows, lead_x, isign
            character  rc
c                 rc = 'c'
            complex*16 temp_data (num_cols)
c                 rc = 'r'
            complex*16 temp_data (num_rows)

    C:

        cmfft1d:

            typedef struct {
               float real, imag;
            } complex;

            complex    data_in [num_rows, num_cols];
/*                      if rc == 'c'   */
            complex    temp_data [num_cols];
/*                      if rc == 'r'   */
            complex    temp_data [num_rows];
            int        num_cols, num_rows, lead_x, isign;
            char       rc;

        zmfft1d:

            typedef struct {
               double real, imag;
            } dcomplex;
 
            dcomplex   data_in [num_rows, num_cols];
            dcomplex   temp_data [num_rows, num_cols];
            int        num_cols, num_rows, lead_x, isign;
            char       rc;

            Where num_rows is at least as large as the number of rows to be
            processed in the complex matrix and num_cols is the number of
            columns in the complex matrix which are to be processed.

Parameter Description:

            data_in:  

                Fortran: matrix with dimensions of lead_x X num_rows

                C:       matrix with dimensions of num_rows X lead_x 

            temp_data:  rc = 'c': array of size num_cols
                        rc = 'r': array of size num_rows

            num_rows:  rc = 'c':  indicates the number of transforms to compute;
                       rc = 'r':  indicates the size of the transform

            num_cols:  rc = 'c':  indicates the size of the transform;
                       rc = 'r':  indicates the number of transforms to compute

            lead_x:  integer which indicates the actual size of the first
                     dimension if a subset of the matrix is to be transformed.
                     If the entire matrix is to be transformed, this will be
                     equal to num_cols.

            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

                    1:  perform an inverse FFT on the data

            rc:  character used to control row or column mode for the routine.

    A call to cmfft1d/zmfft1d 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 cmfft1d/zmfft1d 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 cmfft1d/zmfft1d.

    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.