csfft3du(3F)

NAME
     csfft3du, zdfft3du - 3D, Complex to Real, Inverse Fast Fourier
     Transforms.

SYNOPSYS
     Fortran :
     subroutine csfft3du(sign,n1,n2,n3,array,la1,la2,coef)
          integer            sign, n1, n2, n3, la1, la2
          real      array(la1,la2,n3)
          real    coef((n1+15)+2*(n2+15)+2*(n3+15))

     subroutine zdfft3du(sign,n1,n2,n3,array,la1,la2,coef)
          integer            sign, n1, n2, n3, la1, la2
          real*8  array(la1,la2,n3)
          real*8  coef((n1+15)+2*(n2+15)+2*(n3+15))


     C :
     #include <fft.h>
     int csfft3du(int sign,int n1,int n2,int n3,float *array,
                    int la1, int la2, float *coef);
     int zdfft3du(int sign,int n1,int n2,int n3,double *array,
                    int la1, int la2, double *coef);


DESCRIPTION
     csfft3du and zdfft3du compute in place the real 3D sequence  of size N1 x
     N2 x N3 from its complex Fourier transform.  The value F{j1,j2,j3} of the
     transform of the 3D sequence f{i1,i2,i3} is equal to:
         F{j1,j2,j3} = Sum( W1^(i1*j1)*W2^(i2*j2)*W3^(i3*j3)*f{i1,i2,i3} ),
                  for i[123] =0,...,(N[123]-1)
              W[123] = exp( (Sign*2*sqrt(-1)*PI) / N[123] )


Storage
     It is assumed that the (N1 x N2 x N3) 3D sequence is stored along
     dimension N1.  So the index {i+1,j,l} has an offset of 1 element with
     respect to {i,j,l}, and {i,j+1,k} an offset of la1 elements with respect
     to {i,j,k}, and {i,j,k+1} an offset of (la1*la2) elements with respect to
     {i,j,k}.
     NOTE : la1 must be larger (or equal) to 2*((N1+2)/2), and la2 larger (or
     equal) to N2.


Algorithm
     The real-to-complex Direct 3D Fourier transform is computed with a row-
     column approach.
      - First, N1*N2 FFTs complex-to-complex of size N3 are performed,
     stride=(la1/2)*la2, and leading_dimension=1.
      - then, N3 2D FFTs real-to-complex of size N1xN2 are evaluated, stride =
     1
      and leading_dimension=la1.
     As the final output sequence has real values, only half of the transform
     are needed since the sample {(N1-k),l,m} of the real-to-complex transform
     is be the conjugate of the sample {k,l,m}.
     However, some extra space is necessary, and the relation
     (la1>=2*((N1+2)/2)) must hold.


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.

     N1 Integer, the first dimension size of the 3D sequence.  Unchanged on
     exit.

     N2 Integer, the second dimension size of the 3D sequence.  Unchanged on
     exit.

     N3 Integer, the third dimension size of the 3D sequence.  Unchanged on
     exit.

     ARRAY Array containing the samples of the 3D sequence to be transformed.
     On input, the element {i,j,k} of the sequence is stored as A(i,j,k) in
     Fortran , and A[i+j*la1+k*la1*la2] in C. On exit, the array is
     overwritten.

     LA1 Integer, first leading dimension: increment between the samples of
     two consecutive 1D sub-sequences (e.g between {i,j+1,k} and {i,j,k} ).
     Unchanged on exit.

     LA2 Integer, second leading dimension: number of the 1D sub-sequence
     between two consecutive 2D sub-sequences (e.g between {i,j,k+1} and
     {i,j,k}).  Unchanged on exit.

     COEFF Array of at least ( (N1+15)+2*(N2+15)+2*(N3+15) ) elements.  On
     entry it contains the Sines/Cosines and factorization of N. COEFF needs
     to be initialized with a call to scfft3dui or dzfft3dui.  Unchanged on
     exit.


Example of Calling Sequence
     3D FFT computed on a real sequence of size 100x64x125. The elements of
     each sequence are stored with increment (stride) 1, the offset between
     the first element of two succesive 1D sub-sequences (first leading
     dimension) is 102, and the number of 1D sub-sequence between two
     succesive 2D sub-sequences (second leading dimension) is 64.
     Note : 102 >= 100+2 , and 64 >= 64.
     Fortran
          real array(0:102-1,0:64-1,0:125-1)
          real coeff(100+15 + 2*(64+15) + 2*(125+15))
          call scfft3dui( 100, 64, 125, coeff)
          call scfft3du( -1, 100, 64, 125, array, 102, 64, coeff)
         call csfft3du(  1, 100, 64, 125, array, 102, 64, coeff)

     C
          #include <fft.h>
          float array[102*64*125], *coeff;
          coeff = scfft3dui( 100, 64, 125, NULL);
          scfft3du( -1, 100, 64, 125, array, 102, 64, coeff)
          csfft3du(  1, 100, 64, 125, array, 102, 64, coeff)

SEE ALSO
     fft, scfft3dui, dzfft3dui, scfft3du, dzfft3du