[ новости /+++ | форум | теги | ]

NAME
     rfft2f - compute the  Fourier  coefficients  of  a  periodic
     sequence.   The  xFFT operations are unnormalized, so a call
     of xFFT2F followed by a call of  xFFT2B  will  multiply  the
     input sequence by M*N.

SYNOPSIS
     SUBROUTINE RFFT2F (PLACE, FULL, M,  N,  RX,  LDX,  RY,  LDY,
               RWSAVE, LWSAVE)

     SUBROUTINE DFFT2F (PLACE, FULL, M,  N,  DX,  LDX,  DY,  LDY,
               DWSAVE, LWSAVE)

     SUBROUTINE CFFT2F (M, N, CX, LDX, RWSAVE, LWSAVE)

     SUBROUTINE ZFFT2F (M, N, ZX, LDX, DWSAVE, LWSAVE)



     #include <sunperf.h>

     void rfft2f (char place, char full, int m, int n, float *rx,
               int  ldx,  float  *ry,  int ldy, float *wsave, int
               lwsave);

     void dfft2f (char place, char full, int  m,  int  n,  double
               *dx,  int  ldx, float *dy, int ldy, double *wsave,
               int lwsave);

     void cfft2f (int m, int n, complex  *cx,  int  ldx,  complex
               *wsave, int lwsave);

     void zfft2f (int m, int n, doublecomplex *zx, int ldx, doub-
               lecomplex *wsave, int lwsave);

ARGUMENTS
     PLACE     Determines whether or not to perform  an  in-place
               or  out-of-place  transform.  'I' or 'i' indicates
               in-place and 'O' or 'o' indicates out-of-place.

     FULL      Indicates whether or  not  to  generate  the  full
               result  matrix.   'F'  or 'f' will cause xFFT2F to
               generate the full result matrix, otherwise only  a
               partial  matrix  that  takes advantage of symmetry
               will be generated.

     M         Number of rows to be transformed.   These  subrou-
               tines  are  most  efficient when M is a product of
               small primes.  M >= 0.

     N         Number of columns to be transformed.   These  sub-
               routines are most efficient when N is a product of
               small primes.  N >= 0.

     xX        On entry, a  two-dimensional  array  xX(M,N)  that
               contains the sequences to be transformed.

     LDX       Leading dimension of the array containing the data
               to be transformed.  LDX >= M.

     xY        On exit, a two-dimensional array xY(M,N) that con-
               tains  the  transformed  sequences  in the out-of-
               place case.

     LDY       Leading dimension  of  the  array  containing  the
               transformed out-of-place data.  LDY >= M.

     xWSAVE    Scratch space.  The array must have been  initial-
               ized by xFFT2I.

     LWSAVE    Length of the WSAVE array.  LWSAVE >=  (M  +  N  +
               MAX(M,N)  +  45) for real inputs or LWSAVE >= (2 *
               (M + N + MAX(M,N)) + 45) for complex inputs.

SAMPLE PROGRAM
           PROGRAM TEST
           IMPLICIT NONE
     C
           INTEGER           LWSAVE, M, N
           PARAMETER        (M = 2)
           PARAMETER        (N = 4)
           PARAMETER        (LWSAVE = 2 * (M + N + MAX(M,N)) + 45)
     C
           INTEGER           I, J
           REAL              PI
           COMPLEX           WSAVE(LWSAVE)
           REAL              X, Y
           COMPLEX           C(M,N)
     C
           EXTERNAL          CFFT2B, CFFT2F, CFFT2I
           INTRINSIC         ACOS, CMPLX, COS, SIN
     C
     C     Initialize the array C to a complex sequence.
     C
           PI = ACOS (-1.0)
           DO 110, J = 1, N
             DO 100, I = 1, M
               X = SIN ((I - 1.0) * 2.0 * PI / N)
               Y = COS ((J - 1.0) * 2.0 * PI / M)
               C(I,J) = CMPLX (X, Y)
       100   CONTINUE
       110 CONTINUE
     C
           PRINT 1000
           DO 200, I = 1, M
             PRINT 1010, (C(I,J), J = 1, N)
       200 CONTINUE
           CALL CFFT2I (M, N, WSAVE)
           CALL CFFT2F (M, N, C, M, WSAVE, LWSAVE)
           PRINT 1020
           DO 300, I = 1, M
             PRINT 1010, (C(I,J), J = 1, N)
       300 CONTINUE
           CALL CFFT2B (M, N, C, M, WSAVE, LWSAVE)
           PRINT 1030
           DO 400, I = 1, M
             PRINT 1010, (C(I,J), J = 1, N)
       400 CONTINUE
     C
      1000 FORMAT (1X, 'Original Sequences:')
      1010 FORMAT (1X, 100(F4.1' +',F4.1,'i  '))
      1020 FORMAT (1X, 'Transformed Sequences:')
      1030 FORMAT (1X, 'Recovered Sequences:')
     C
           END

SAMPLE OUTPUT
       0.0 + 1.0i   0.0 +-1.0i   0.0 + 1.0i   0.0 +-1.0i
       1.0 + 1.0i   1.0 +-1.0i   1.0 + 1.0i   1.0 +-1.0i
      Transformed Sequences:
       4.0 + 0.0i   0.0 + 0.0i   0.0 + 8.0i   0.0 + 0.0i
      -4.0 + 0.0i   0.0 + 0.0i   0.0 + 0.0i   0.0 + 0.0i
      Recovered Sequences:
       0.0 + 8.0i   0.0 +-8.0i   0.0 + 8.0i   0.0 +-8.0i
       8.0 + 8.0i   8.0 +-8.0i   8.0 + 8.0i   8.0 +-8.0i

Партнёры:

Хостинг: