Csmfft1d/Zdmfft1d executes the Fast Fourier Transform in place on complex
matrix.

Usage:

   Fortran:

      call csmfft1d (data_in, lead_x, num_cols, num_rows, isign, temp_data, rc)
      call zdmfft1d (data_in, lead_x, num_cols, num_rows, isign, temp_data, rc)

   C:

      csmfft1d_(data_in, &lead_x, &num_cols, &num_rows, &isign, temp_data, &rc);
      zdmfft1d_(data_in, &lead_x, &num_cols, &num_rows, &isign, temp_data, &rc);

Description:

    Csmfft1d/zdmfft1d computes the complex to real inverse FFT on the columns
    or rows of a matrix of complex data in single (csmfft1d) or double
    (zdmfft1d) precision.  If rc = 'c', num_cols must be even and equal to
    the resulting number of real data points.  If rc = 'r', num_rows must be
    even and equal to the resulting number of real data points.

Routine parameters:

    Fortran:

        csmfft1d:

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

        zdmfft1d:

            integer    lead_x, num_cols, num_rows, isign
            character  rc
c                rc = 'c'
            real*8     data_in (num_cols + 2, num_rows)
            real*8     temp_data (num_cols + 2)
c                rc = 'r'
            real*8     data_in (num_cols, num_rows + 2)
            real*8     temp_data (num_rows + 2)

    C:

        csmfft1d:

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

        zdmfft1d:

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

Parameter descriptions:

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

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

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

            num_cols:  rc = 'c': denotes the size of the transforms
                       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 held in data_in

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

    A call to csmfft1d/zdmfft1d 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 csmfft1d/zdmfft1d 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 csmfft1d/zdmfft1d.

    Transform sizes are restricted to values which factor completely
into the numbers 2, 3, 5, and 7 and must be even.  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 110 (11 * 5 * 2) or 78
(13 * 3 * 2) 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 complex to real inverse FFT
        performed on the data points previously held in the array.  Any
        previous values in temp_data will be lost.