*** JMFFT - émulation des FFTs de la SciLib de CRAY - (c) CNRS/IDRIS ***

NOM

     CCFFT - Applique une transformée de Fourier rapide (FFT) complexe-complexe.

SYNTAXE

     CALL CCFFT	(isign,	n, scale, x, y,	table, work, isys)

IMPLEMENTATION

     Ce sous-programme émule le sous-programme de même nom de la SCILIB de
     CRAY. Tous les arguments réels ou complexes doivent être déclarés
     en double précision.

DESCRIPTION

     CCFFT calcule la FFT du vecteur complexe x, et retourne le
     résultat dans le vector complexe y.

     Soient deux tabeaux X et Y dimensionnés de la façon suivante :

	  COMPLEX(KIND=8), DIMENSION(0:N-1) :: X, Y

     Le résultat Y représente la FFT du vecteur X, si nous appliquons la
     formule suivante :

			 n-1
	  Y(k) = scale * Sum [ X(j)*w**(isign*j*k) ] ; k = 0, ..., n-1
			 j=0

	  où

	  w = exp(2*pi*i/n),
	  i = +	sqrt(-1),
	  pi = 3.14159...,
	  isign	= +1 ou	-1

     En général, si une FFT est appliquée avec des valeurs particulières de
     isign et scale, alors son inverse est calculée avec les valeurs -isign
     et 1/(n*scale).

     En particulier, avec les valeurs isign = +1 et scale = 1.0, la FFT
     inverse se calcule en prenant isign = -1 et scale = 1.0/n

ARGUMENTS

     isign   Scalaire du type INTEGER. (entrée)

	     Indique si la table des coefficients doit être initialisée ou s'il faut
	     appliquer une FFT ou son inverse.

	     Si isign = 0, le sous-programme initialise le tableau table et
	     retourne sa valeur. Dans ce cas, seuls les arguments isign, n et
	     table sont vérifés et utilisés.

	     Si isign = +1 ou -1, la FFT ou son inverse est appliquée.

     n	     Scalaire du type INTEGER. (entrée).

	     Longueur de la FFT (Nombre d'éléments du tableau x). n >= 2.

     scale   Scalaire du type REAL(KIND=8). (entrée)

	     Facteur d'échelle.  Chaque élément du vecteur y est multiplié par
	     scale une fois la FFT effectuée ainsi qu'il est spécifié dans la
	     formule ci-dessus.

     x       Tableau du type COMPLEX(KIND=8) de dimension
             (0:n-1). (entrée)

	     Tableau contenant la valeurs des éléments à transformer.

     y       Tableau du type COMPLEX(KIND=8) de dimension (0:n-1). (sortie).

	     Tableau contenant en sortie les valeurs transformées. On peut 
             utiliser le tableau d'entrée x.

     table   Tableau du type REAL(KIND=8) de dimension 100 + 8*n. (entrée ou
             sortie).

	     Tableau contenant la table des coefficients et des fonctions
	     trigonométriques.

	     Si isign = 0, le sous-programme initialise table (table est en
	     sortie seulement).

	     Si isign = +1 ou -1, table est supposé être déja initialisé
	     (table est en entrée seulement).

     work    Tableau du type REAL(KIND=8) de dimension 8*n.

	     Tableau de travail.

     isys    Scalaire du type INTEGER. (entrée)
             
	     Cet argument n'est pas utilisé. Il est conservé pour des raisons
	     de compatibilité avec la SCILIB de CRAY.

EXEMPLES

     Exemple 1 : initialise le tableau TABLE dans le but d'appliquer
     ultérieurement une FFT de dimension n=1024. Dans ce cas, seuls les
     arguments ISIGN, N et TABLE sont utilisés.

	  REAL(KIND=8), DIMENSION(100 + 8*1024) :: TABLE
	  CALL CCFFT(0,	1024, 0.d0, DUMMY, DUMMY, TABLE, DUMMY, 0)

     Exemple 2 : X et Y sont des tableaux complexes de dimension (0:1023). Ici
     on applique une FFT sur X et on enregistre le résultat dans Y. Il est
     impératif d'initialiser TABLE, comme il est indiqué dans l'exemple 1
     avant d'effectuer la FFT.

	  COMPLEX(KIND=8), DIMENSION(0:1023)    :: X, Y
	  REAL(KIND=8), DIMENSION(100 + 8*1024) :: TABLE
	  REAL(KIND=8), DIMENSION(8*1024)       :: WORK
	  CALL CCFFT(0,	1024, 1.d0, X, Y, TABLE, WORK, 0)
	  CALL CCFFT(1,	1024, 1.d0, X, Y, TABLE, WORK, 0)

     Exemple 3 : on complète l'exemple 2 pour réaliser une FFT inverse de
     Y dont le résultat est enregisté dans X.  Le facteur d'échelle SCALE vaut
     1/1024.  On suppose que le tableau TABLE ait été initialisé auparavant.

	  CALL CCFFT(-1, 1024, 1.d0/1024.d0, Y, X, TABLE, WORK, 0)

     Exemple 4 : ici on effectue le meme calcul que dans l'exemple 2. La seule
     différence se trouve dans la valeur des indices inférieurs des tableaux X
     et Y qui démarrent à 1 au lieu de 0.

	  COMPLEX(KIND=8), DIMENSION(1024) :: X, Y
	  CALL CCFFT(0,	1024, 1.d0, X, Y, TABLE, WORK, 0)
	  CALL CCFFT(1,	1024, 1.d0, X, Y, TABLE, WORK, 0)

     Exemple 5 : idem que l'exemple 4. Cependant, pour réaliser une économie de
     place mémoire, le résultat est enregistré dans le vecteur X (on suppose
     que le tableau TABLE ait été initialisé auparavant).

	  COMPLEX(KIND=8), DIMENSION(1024) :: X
	  CALL CCFFT(1,	1024, 1.d0, X, X, TABLE, WORK, 0)

VOIR AUSSI

     CCFFTM, SCFFT, SCFFTM
© CNRS-IDRIS 2013