csfftm1du(3F)

NAME
     csfftm1du, zdfftm1du - Multiple 1D, Complex to Real, Inverse Fast Fourier
     Transforms.

SYNOPSYS
     Fortran :
     subroutine csfftm1du( sign, n, p, array, inc, lda, coef )
          integer            sign, n, p, inc, lda
          real               array(lda,p), coef(n+15)

     subroutine zdfftm1du( sign, n, p, array, inc, lda, coef )
          integer            sign, n, p, inc, lda
          real*8             array(lda,p), coef(n+15)


     C :
     #include <fft.h>
     int csfftm1du ( int sign, int n, int p, float *array,
               int inc, int lda, float *coef);
     int zdfftm1du ( int sign, int n, int p, double *array,
               int inc, int lda, double *coef);


DESCRIPTION
     csfftm1du and zdfftm1du compute the P real sequences of N samples each,
     from their Fourier transform. The i-th index f(i) of a sequence of N
     samples, with Fourier transform F(k) is equal to:
          f(i) = Sum ( W^(i*k) * F(k) ), for k =0, ..., (N-1)
               W = exp( (Sign*2*sqrt(-1)*PI) / N )


     The Inverse Fourier transforms are performed in-place, so the input
     Fourier transform is overwritten by the final sequence output. As the
     output sequences have real values, only the first half of the transform
     is needed. The (N-k)-th sample of the transform would be the conjugate of
     the k-th sample.

     However, some extra space is necessary. For an N sample output sequence,
     the input complex transform takes ((N+2)/2) complex values.  This
     represents either N+1(odd case) or N+2(even case) real values, that's one
     or two more real values than the output real sequence.


PARAMETERS
     SIGN Integer specifying which sign to be used for the expression of W
     (see above) - must be either +1 or -1.  Unchanged on exit.

     N Integer, the number of samples in each sequence.  Unchanged on exit.

     P Integer, the number of sequences.  Unchanged on exit.
     ARRAY Array containing the samples of the sequence to be transformed.
     On input, the element "i" of the sequence "j" is stored as A(i*inc,j) in
     Fortran , and A[i*inc+j*lda] in C.
     On exit, the array is overwritten by its transform.

     INC Integer, increment between two consecutive elements of a sequence.
     Unchanged on exit.

     LDA Integer, leading dimension: increment between the first samples of
     two consecutive sequences.  Unchanged on exit.

     COEFF Array of at least ( N + 15 ) elements.  On entry it contains the
     Sines/Cosines and factorization of N. COEFF needs to be initialized with
     a call to scfftm1dui or dzfftm1dui.  Unchanged on exit.


Example of Calling Sequence
     Working on 64 sequences of 1024 real values each.  We successively apply
     a Direct Fourier Transform, an Inverse Fourier Trasnform and finally
     scale back the result by a factor 1/N (1/1024.)-
     This sequence DirectFFT-InverseFFT-Scaling is equivalent to the identity
     operator and the final sequence should be equal (with round-off
     precision) to the initial sequence.
     Elements of each sequence are stored with increment (stride) 1, and the
     offset between the first element of two succesive sequence (leading
     dimension) is 1026 (1026 >= 1024+2).
     Fortran
          real array(0:1026-1,0:64-1), coeff(1024+15)
          call scfftm1dui( 1024, coeff)
          call csfftm1du( -1, 1024, 64, array, 1, 1026, coeff)
          call scfftm1du(  1, 1024, 64, array, 1, 1026, coeff)
          call sscalm1d( 1024,64,(1./real(1024)),array,1,1026)

     C
          #include <fft.h>
          float array[64*1026], *coeff;
          coeff = scfftm1dui( 1024, NULL);
          csfftm1du( -1, 1024, 64, array, 1, 1026, coeff);
          scfftm1du(  1, 1024, 64, array, 1, 1026, coeff);
          sscalm1d( 1024, 64, 1./(float)1024, array, 1, 1026);

     NOTE_1 : The Direct and Inverse transforms should use opposite signs -
     Which one is used (+1 or -1) for Direct transform is just a matter of
     convention-

     NOTE_2 : The Fourier Transforms are not normalized so the succession
     Direct-Inverse transform scales the input data by a factor equal to the
     size of the transform.

SEE ALSO
     fft, scfftm1dui, dzfftm1dui, scfftm1du, dzfftm1du, sscalm1d, dscalm1d