Home

Context Navigation

source: palm/trunk/SOURCE/singleton.f90 @ 543

Last change on this file since 543 was 484, checked in by raasch, 15 years ago
typo in file headers removed
Property svn:keywords set to `Id`
File size: 35.5 KB

Line
1	MODULE singleton
2
3	!-----------------------------------------------------------------------------
4	! Current revisions:
5	! -----------------
6	!
7	!
8	! Former revisions:
9	! -----------------
10	! $Id: singleton.f90 484 2010-02-05 07:36:54Z heinze $
11	! RCS Log replace by Id keyword, revision history cleaned up
12	!
13	! Revision 1.2 2004/04/30 12:52:09 raasch
14	! Shape of arrays is explicitly stored in ishape and handled to the
15	! fft-routines instead of the shape-function (due to a compiler error on
16	! decalpha)
17	!
18	! Revision 1.1 2002/05/02 18:56:59 raasch
19	! Initial revision
20	!
21	!
22	! Description:
23	! ------------
24	! Multivariate Fast Fourier Transform
25	!
26	! Fortran 90 Implementation of Singleton's mixed-radix algorithm,
27	! RC Singleton, Stanford Research Institute, Sept. 1968.
28	!
29	! Adapted from fftn.c, translated from Fortran 66 to C by Mark Olesen and
30	! John Beale.
31	!
32	! Fourier transforms can be computed either in place, using assumed size
33	! arguments, or by generic function, using assumed shape arguments.
34	!
35	!
36	! Public:
37	!
38	! fftkind kind parameter of complex arguments
39	! and function results.
40	!
41	! fft(array, dim, inv, stat) generic transform function
42	! COMPLEX(fftkind), DIMENSION(:,...,:), INTENT(IN) :: array
43	! INTEGER, DIMENSION(:), INTENT(IN), OPTIONAL:: dim
44	! LOGICAL, INTENT(IN), OPTIONAL:: inv
45	! INTEGER, INTENT(OUT), OPTIONAL:: stat
46	!
47	! fftn(array, shape, dim, inv, stat) in place transform subroutine
48	! COMPLEX(fftkind), DIMENSION(*), INTENT(INOUT) :: array
49	! INTEGER, DIMENSION(:), INTENT(IN) :: shape
50	! INTEGER, DIMENSION(:), INTENT(IN), OPTIONAL:: dim
51	! LOGICAL, INTENT(IN), OPTIONAL:: inv
52	! INTEGER, INTENT(OUT), OPTIONAL:: stat
53	!
54	!
55	! Formal Parameters:
56	!
57	! array The complex array to be transformed. array can be of arbitrary
58	! rank (i.e. up to seven).
59	!
60	! shape With subroutine fftn, the shape of the array to be transformed
61	! has to be passed separately, since fftradix - the internal trans-
62	! formation routine - will treat array always as one dimensional.
63	! The product of elements in shape must be the number of
64	! elements in array.
65	! Although passing array with assumed shape would have been nicer,
66	! I prefered assumed size in order to prevent the compiler from
67	! using a copy-in-copy-out mechanism. That would generally be
68	! necessary with fftn passing array to fftradix and with fftn
69	! being prepared for accepting non consecutive array sections.
70	! Using assumed size, it's up to the user to pass an array argu-
71	! ment, that can be addressed as continous one dimensional array
72	! without copying. Otherwise, transformation will not really be
73	! performed in place.
74	! On the other hand, since the rank of array and the size of
75	! shape needn't match, fftn is appropriate for handling more than
76	! seven dimensions.
77	! As far as function fft is concerned all this doesn't matter,
78	! because the argument will be copied anyway. Thus no extra
79	! shape argument is needed for fft.
80	!
81	! Optional Parameters:
82	!
83	! dim One dimensional integer array, containing the dimensions to be
84	! transformed. Default is (/1,...,N/) with N being the rank of
85	! array, i.e. complete transform. dim can restrict transformation
86	! to a subset of available dimensions. Its size must not exceed the
87	! rank of array or the size of shape respectivly.
88	!
89	! inv If .true., inverse transformation will be performed. Default is
90	! .false., i.e. forward transformation.
91	!
92	! stat If present, a system dependent nonzero status value will be
93	! returned in stat, if allocation of temporary storage failed.
94	!
95	!
96	! Scaling:
97	!
98	! Transformation results will always be scaled by the square root of the
99	! product of sizes of each dimension in dim. (See examples below)
100	!
101	!
102	! Examples:
103	!
104	! Let A be a LMN three dimensional complex array. Then
105	!
106	! result = fft(A)
107	!
108	! will produce a three dimensional transform, scaled by sqrt(LMN), while
109	!
110	! call fftn(A, SHAPE(A))
111	!
112	! will do the same in place.
113	!
114	! result = fft(A, dim=(/1,3/))
115	!
116	! will transform with respect to the first and the third dimension, scaled
117	! by sqrt(L*N).
118	!
119	! result = fft(fft(A), inv=.true.)
120	!
121	! should (approximately) reproduce A.
122	! With B having the same shape as A
123	!
124	! result = fft(fft(A) * CONJG(fft(B)), inv=.true.)
125	!
126	! will correlate A and B.
127	!
128	!
129	! Remarks:
130	!
131	! Following changes have been introduced with respect to fftn.c:
132	! - complex arguments and results are of type complex, rather than
133	! real an imaginary part separately.
134	! - increment parameter (magnitude of isign) has been dropped,
135	! inc is always one, direction of transform is given by inv.
136	! - maxf and maxp have been dropped. The amount of temporary storage
137	! needed is determined by the fftradix routine. Both fftn and fft
138	! can handle any size of array. (Maybe they take a lot of time and
139	! memory, but they will do it)
140	!
141	! Redesigning fftradix in a way, that it handles assumed shape arrays
142	! would have been desirable. However, I found it rather hard to do this
143	! in an efficient way. Problems were:
144	! - to prevent stride multiplications when indexing arrays. At least our
145	! compiler was not clever enough to discover that in fact additions
146	! would do the job as well. On the other hand, I haven't been clever
147	! enough to find an implementation using array operations.
148	! - fftradix is rather large and different versions would be necessaray
149	! for each possible rank of array.
150	! Consequently, in place transformation still needs the argument stored
151	! in a consecutive bunch of memory and can't be performed on array
152	! sections like A(100:199:-3, 50:1020). Calling fftn with such sections
153	! will most probably imply copy-in-copy-out. However, the function fft
154	! works with everything it gets and should be convenient to use.
155	!
156	! Michael Steffens, 09.12.96, <Michael.Steffens@mbox.muk.uni-hannover.de>
157	! Restructured fftradix for better optimization. M. Steffens, 4 June 1997
158	!-----------------------------------------------------------------------------
159
160	IMPLICIT NONE
161
162	PRIVATE
163	PUBLIC:: fft, fftn, fftkind
164
165	INTEGER, PARAMETER:: fftkind = KIND(0.0) ! adjust here for other precisions
166
167	REAL(fftkind), PARAMETER:: sin60 = 0.86602540378443865_fftkind
168	REAL(fftkind), PARAMETER:: cos72 = 0.30901699437494742_fftkind
169	REAL(fftkind), PARAMETER:: sin72 = 0.95105651629515357_fftkind
170	REAL(fftkind), PARAMETER:: pi = 3.14159265358979323_fftkind
171
172	INTERFACE fft
173	MODULE PROCEDURE fft1d
174	MODULE PROCEDURE fft2d
175	MODULE PROCEDURE fft3d
176	MODULE PROCEDURE fft4d
177	MODULE PROCEDURE fft5d
178	MODULE PROCEDURE fft6d
179	MODULE PROCEDURE fft7d
180	END INTERFACE
181
182
183	CONTAINS
184
185
186	FUNCTION fft1d(array, dim, inv, stat) RESULT(ft)
187	!
188	!-- Formal parameters
189	COMPLEX(fftkind), DIMENSION(:), INTENT(IN) :: array
190	INTEGER, DIMENSION(:), INTENT(IN), OPTIONAL:: dim
191	LOGICAL, INTENT(IN), OPTIONAL:: inv
192	INTEGER, INTENT(OUT), OPTIONAL:: stat
193	!
194	!-- Function result
195	COMPLEX(fftkind), DIMENSION(SIZE(array, 1)):: ft
196
197	INTEGER :: ishape(1)
198
199	!
200	!-- Intrinsics used
201	INTRINSIC SIZE, SHAPE
202
203	ft = array
204	ishape = SHAPE( array )
205	CALL fftn(ft, ishape, inv = inv, stat = stat)
206
207	END FUNCTION fft1d
208
209
210	FUNCTION fft2d(array, dim, inv, stat) RESULT(ft)
211	!
212	!-- Formal parameters
213	COMPLEX(fftkind), DIMENSION(:,:), INTENT(IN) :: array
214	INTEGER, DIMENSION(:), INTENT(IN), OPTIONAL:: dim
215	LOGICAL, INTENT(IN), OPTIONAL:: inv
216	INTEGER, INTENT(OUT), OPTIONAL:: stat
217	!
218	!-- Function result
219	COMPLEX(fftkind), DIMENSION(SIZE(array, 1), SIZE(array, 2)):: ft
220
221	INTEGER :: ishape(2)
222	!
223	!-- Intrinsics used
224	INTRINSIC SIZE, SHAPE
225
226	ft = array
227	ishape = SHAPE( array )
228	CALL fftn(ft, ishape, dim, inv, stat)
229
230	END FUNCTION fft2d
231
232
233	FUNCTION fft3d(array, dim, inv, stat) RESULT(ft)
234	!
235	!-- Formal parameters
236	COMPLEX(fftkind), DIMENSION(:,:,:), INTENT(IN) :: array
237	INTEGER, DIMENSION(:), INTENT(IN), OPTIONAL:: dim
238	LOGICAL, INTENT(IN), OPTIONAL:: inv
239	INTEGER, INTENT(OUT), OPTIONAL:: stat
240	!
241	!-- Function result
242	COMPLEX(fftkind), &
243	DIMENSION(SIZE(array, 1), SIZE(array, 2), SIZE(array, 3)):: ft
244
245	INTEGER :: ishape(3)
246
247	!
248	!-- Intrinsics used
249	INTRINSIC SIZE, SHAPE
250
251	ft = array
252	ishape = SHAPE( array)
253	CALL fftn(ft, ishape, dim, inv, stat)
254
255	END FUNCTION fft3d
256
257
258	FUNCTION fft4d(array, dim, inv, stat) RESULT(ft)
259	!
260	!-- Formal parameters
261	COMPLEX(fftkind), DIMENSION(:,:,:,:), INTENT(IN) :: array
262	INTEGER, DIMENSION(:), INTENT(IN), OPTIONAL:: dim
263	LOGICAL, INTENT(IN), OPTIONAL:: inv
264	INTEGER, INTENT(OUT), OPTIONAL:: stat
265	!
266	!-- Function result
267	COMPLEX(fftkind), DIMENSION( &
268	SIZE(array, 1), SIZE(array, 2), SIZE(array, 3), SIZE(array, 4)):: ft
269
270	INTEGER :: ishape(4)
271	!
272	!-- Intrinsics used
273	INTRINSIC SIZE, SHAPE
274
275	ft = array
276	ishape = SHAPE( array )
277	CALL fftn(ft, ishape, dim, inv, stat)
278
279	END FUNCTION fft4d
280
281
282	FUNCTION fft5d(array, dim, inv, stat) RESULT(ft)
283	!
284	!-- Formal parameters
285	COMPLEX(fftkind), DIMENSION(:,:,:,:,:), INTENT(IN) :: array
286	INTEGER, DIMENSION(:), INTENT(IN), OPTIONAL:: dim
287	LOGICAL, INTENT(IN), OPTIONAL:: inv
288	INTEGER, INTENT(OUT), OPTIONAL:: stat
289	!
290	!-- Function result
291	COMPLEX(fftkind), DIMENSION( &
292	SIZE(array, 1), SIZE(array, 2), SIZE(array, 3), SIZE(array, 4), &
293	SIZE(array, 5)):: ft
294
295	INTEGER :: ishape(5)
296
297	!
298	!-- Intrinsics used
299	INTRINSIC SIZE, SHAPE
300
301	ft = array
302	ishape = SHAPE( array )
303	CALL fftn(ft, ishape, dim, inv, stat)
304
305	END FUNCTION fft5d
306
307
308	FUNCTION fft6d(array, dim, inv, stat) RESULT(ft)
309	!
310	!-- Formal parameters
311	COMPLEX(fftkind), DIMENSION(:,:,:,:,:,:), INTENT(IN) :: array
312	INTEGER, DIMENSION(:), INTENT(IN), OPTIONAL:: dim
313	LOGICAL, INTENT(IN), OPTIONAL:: inv
314	INTEGER, INTENT(OUT), OPTIONAL:: stat
315	!
316	!-- Function result
317	COMPLEX(fftkind), DIMENSION( &
318	SIZE(array, 1), SIZE(array, 2), SIZE(array, 3), SIZE(array, 4), &
319	SIZE(array, 5), SIZE(array, 6)):: ft
320
321	INTEGER :: ishape(6)
322
323	!
324	!-- Intrinsics used
325	INTRINSIC SIZE, SHAPE
326
327	ft = array
328	ishape = SHAPE( array )
329	CALL fftn(ft, ishape, dim, inv, stat)
330
331	END FUNCTION fft6d
332
333
334	FUNCTION fft7d(array, dim, inv, stat) RESULT(ft)
335	!
336	!-- Formal parameters
337	COMPLEX(fftkind), DIMENSION(:,:,:,:,:,:,:), INTENT(IN) :: array
338	INTEGER, DIMENSION(:), INTENT(IN), OPTIONAL:: dim
339	LOGICAL, INTENT(IN), OPTIONAL:: inv
340	INTEGER, INTENT(OUT), OPTIONAL:: stat
341	!
342	!-- Function result
343	COMPLEX(fftkind), DIMENSION( &
344	SIZE(array, 1), SIZE(array, 2), SIZE(array, 3), SIZE(array, 4), &
345	SIZE(array, 5), SIZE(array, 6), SIZE(array, 7)):: ft
346
347	INTEGER :: ishape(7)
348
349	!
350	!-- Intrinsics used
351	INTRINSIC SIZE, SHAPE
352
353	ft = array
354	ishape = SHAPE( array )
355	CALL fftn(ft, ishape, dim, inv, stat)
356
357	END FUNCTION fft7d
358
359
360	SUBROUTINE fftn(array, shape, dim, inv, stat)
361	!
362	!-- Formal parameters
363	COMPLEX(fftkind), DIMENSION(*), INTENT(INOUT) :: array
364	INTEGER, DIMENSION(:), INTENT(IN) :: shape
365	INTEGER, DIMENSION(:), INTENT(IN), OPTIONAL:: dim
366	LOGICAL, INTENT(IN), OPTIONAL:: inv
367	INTEGER, INTENT(OUT), OPTIONAL:: stat
368	!
369	!-- Local arrays
370	INTEGER, DIMENSION(SIZE(shape)):: d
371	!
372	!-- Local scalars
373	LOGICAL :: inverse
374	INTEGER :: i, ndim, ntotal
375	REAL(fftkind):: scale
376	!
377	!-- Intrinsics used
378	INTRINSIC PRESENT, MIN, PRODUCT, SIZE, SQRT
379
380	!
381	!-- Optional parameter settings
382	IF (PRESENT(inv)) THEN
383	inverse = inv
384	ELSE
385	inverse = .FALSE.
386	END IF
387	IF (PRESENT(dim)) THEN
388	ndim = MIN(SIZE(dim), SIZE(d))
389	d(1:ndim) = DIM(1:ndim)
390	ELSE
391	ndim = SIZE(d)
392	d = (/(i, i = 1, SIZE(d))/)
393	END IF
394
395	ntotal = PRODUCT(shape)
396	scale = SQRT(1.0_fftkind / PRODUCT(shape(d(1:ndim))))
397	DO i = 1, ntotal
398	array(i) = CMPLX(REAL(array(i)) * scale, AIMAG(array(i)) * scale, &
399	KIND=fftkind)
400	END DO
401
402	DO i = 1, ndim
403	CALL fftradix(array, ntotal, shape(d(i)), PRODUCT(shape(1:d(i))), &
404	inverse, stat)
405	IF (PRESENT(stat)) THEN
406	IF (stat /=0) RETURN
407	END IF
408	END DO
409
410	END SUBROUTINE fftn
411
412
413	SUBROUTINE fftradix(array, ntotal, npass, nspan, inv, stat)
414	!
415	!-- Formal parameters
416	COMPLEX(fftkind), DIMENSION(*), INTENT(INOUT) :: array
417	INTEGER, INTENT(IN) :: ntotal, npass, nspan
418	LOGICAL, INTENT(IN) :: inv
419	INTEGER, INTENT(OUT), OPTIONAL:: stat
420	!
421	!-- Local arrays
422	INTEGER, DIMENSION(BIT_SIZE(0)) :: factor
423	COMPLEX(fftkind), DIMENSION(:), ALLOCATABLE :: ctmp
424	REAL(fftkind), DIMENSION(:), ALLOCATABLE :: sine, cosine
425	INTEGER, DIMENSION(:), ALLOCATABLE :: perm
426	!
427	!-- Local scalars
428	INTEGER :: maxfactor, nfactor, nsquare, nperm
429	!
430	!-- Intrinsics used
431	INTRINSIC MAXVAL, MOD, PRESENT, ISHFT, BIT_SIZE, SIN, COS, &
432	CMPLX, REAL, AIMAG
433
434	IF (npass <= 1) RETURN
435
436	CALL factorize(npass, factor, nfactor, nsquare)
437
438	maxfactor = MAXVAL(factor(:nfactor))
439	IF (nfactor - ISHFT(nsquare, 1) > 0) THEN
440	nperm = MAX(nfactor + 1, PRODUCT(factor(nsquare+1: nfactor-nsquare)) - 1)
441	ELSE
442	nperm = nfactor + 1
443	END IF
444
445	IF (PRESENT(stat)) THEN
446	ALLOCATE(ctmp(maxfactor), sine(maxfactor), cosine(maxfactor), STAT=stat)
447	IF (stat /= 0) RETURN
448	CALL transform(array, ntotal, npass, nspan, &
449	factor, nfactor, ctmp, sine, cosine, inv)
450	DEALLOCATE(sine, cosine, STAT=stat)
451	IF (stat /= 0) RETURN
452	ALLOCATE(perm(nperm), STAT=stat)
453	IF (stat /= 0) RETURN
454	CALL permute(array, ntotal, npass, nspan, &
455	factor, nfactor, nsquare, maxfactor, &
456	ctmp, perm)
457	DEALLOCATE(perm, ctmp, STAT=stat)
458	IF (stat /= 0) RETURN
459	ELSE
460	ALLOCATE(ctmp(maxfactor), sine(maxfactor), cosine(maxfactor))
461	CALL transform(array, ntotal, npass, nspan, &
462	factor, nfactor, ctmp, sine, cosine, inv)
463	DEALLOCATE(sine, cosine)
464	ALLOCATE(perm(nperm))
465	CALL permute(array, ntotal, npass, nspan, &
466	factor, nfactor, nsquare, maxfactor, &
467	ctmp, perm)
468	DEALLOCATE(perm, ctmp)
469	END IF
470
471
472	CONTAINS
473
474
475	SUBROUTINE factorize(npass, factor, nfactor, nsquare)
476	!
477	!-- Formal parameters
478	INTEGER, INTENT(IN) :: npass
479	INTEGER, DIMENSION(*), INTENT(OUT):: factor
480	INTEGER, INTENT(OUT):: nfactor, nsquare
481	!
482	!-- Local scalars
483	INTEGER:: j, jj, k
484
485	nfactor = 0
486	k = npass
487	DO WHILE (MOD(k, 16) == 0)
488	nfactor = nfactor + 1
489	factor(nfactor) = 4
490	k = k / 16
491	END DO
492	j = 3
493	jj = 9
494	DO
495	DO WHILE (MOD(k, jj) == 0)
496	nfactor = nfactor + 1
497	factor(nfactor) = j
498	k = k / jj
499	END DO
500	j = j + 2
501	jj = j * j
502	IF (jj > k) EXIT
503	END DO
504	IF (k <= 4) THEN
505	nsquare = nfactor
506	factor(nfactor + 1) = k
507	IF (k /= 1) nfactor = nfactor + 1
508	ELSE
509	IF (k - ISHFT(k / 4, 2) == 0) THEN
510	nfactor = nfactor + 1
511	factor(nfactor) = 2
512	k = k / 4
513	END IF
514	nsquare = nfactor
515	j = 2
516	DO
517	IF (MOD(k, j) == 0) THEN
518	nfactor = nfactor + 1
519	factor(nfactor) = j
520	k = k / j
521	END IF
522	j = ISHFT((j + 1) / 2, 1) + 1
523	IF (j > k) EXIT
524	END DO
525	END IF
526	IF (nsquare > 0) THEN
527	j = nsquare
528	DO
529	nfactor = nfactor + 1
530	factor(nfactor) = factor(j)
531	j = j - 1
532	IF (j==0) EXIT
533	END DO
534	END IF
535
536	END SUBROUTINE factorize
537
538
539	SUBROUTINE transform(array, ntotal, npass, nspan, &
540	factor, nfactor, ctmp, sine, cosine, inv) !-- compute fourier transform
541	!
542	!-- Formal parameters
543	COMPLEX(fftkind), DIMENSION(*), INTENT(IN OUT):: array
544	INTEGER, INTENT(IN) :: ntotal, npass, nspan
545	INTEGER, DIMENSION(*), INTENT(IN) :: factor
546	INTEGER, INTENT(IN) :: nfactor
547	COMPLEX(fftkind), DIMENSION(*), INTENT(OUT) :: ctmp
548	REAL(fftkind), DIMENSION(*), INTENT(OUT) :: sine, cosine
549	LOGICAL, INTENT(IN) :: inv
550	!
551	!-- Local scalars
552	INTEGER :: ii, ispan
553	INTEGER :: j, jc, jf, jj
554	INTEGER :: k, kk, kspan, k1, k2, k3, k4
555	INTEGER :: nn, nt
556	REAL(fftkind) :: s60, c72, s72, pi2, radf
557	REAL(fftkind) :: c1, s1, c2, s2, c3, s3, cd, sd, ak
558	COMPLEX(fftkind):: cc, cj, ck, cjp, cjm, ckp, ckm
559
560	c72 = cos72
561	IF (inv) THEN
562	s72 = sin72
563	s60 = sin60
564	pi2 = pi
565	ELSE
566	s72 = -sin72
567	s60 = -sin60
568	pi2 = -pi
569	END IF
570
571	nt = ntotal
572	nn = nt - 1
573	kspan = nspan
574	jc = nspan / npass
575	radf = pi2 * jc
576	pi2 = pi2 * 2.0_fftkind !-- use 2 PI from here on
577
578	ii = 0
579	jf = 0
580	DO
581	sd = radf / kspan
582	cd = SIN(sd)
583	cd = 2.0_fftkind * cd * cd
584	sd = SIN(sd + sd)
585	kk = 1
586	ii = ii + 1
587
588	SELECT CASE (factor(ii))
589	CASE (2)
590	!
591	!-- Transform for factor of 2 (including rotation factor)
592	kspan = kspan / 2
593	k1 = kspan + 2
594	DO
595	DO
596	k2 = kk + kspan
597	ck = array(k2)
598	array(k2) = array(kk)-ck
599	array(kk) = array(kk) + ck
600	kk = k2 + kspan
601	IF (kk > nn) EXIT
602	END DO
603	kk = kk - nn
604	IF (kk > jc) EXIT
605	END DO
606	IF (kk > kspan) RETURN
607	DO
608	c1 = 1.0_fftkind - cd
609	s1 = sd
610	DO
611	DO
612	DO
613	k2 = kk + kspan
614	ck = array(kk) - array(k2)
615	array(kk) = array(kk) + array(k2)
616	array(k2) = ck * CMPLX(c1, s1, KIND=fftkind)
617	kk = k2 + kspan
618	IF (kk >= nt) EXIT
619	END DO
620	k2 = kk - nt
621	c1 = -c1
622	kk = k1 - k2
623	IF (kk <= k2) EXIT
624	END DO
625	ak = c1 - (cd * c1 + sd * s1)
626	s1 = sd * c1 - cd * s1 + s1
627	c1 = 2.0_fftkind - (ak * ak + s1 * s1)
628	s1 = s1 * c1
629	c1 = c1 * ak
630	kk = kk + jc
631	IF (kk >= k2) EXIT
632	END DO
633	k1 = k1 + 1 + 1
634	kk = (k1 - kspan) / 2 + jc
635	IF (kk > jc + jc) EXIT
636	END DO
637
638	CASE (4) !-- transform for factor of 4
639	ispan = kspan
640	kspan = kspan / 4
641
642	DO
643	c1 = 1.0_fftkind
644	s1 = 0.0_fftkind
645	DO
646	DO
647	k1 = kk + kspan
648	k2 = k1 + kspan
649	k3 = k2 + kspan
650	ckp = array(kk) + array(k2)
651	ckm = array(kk) - array(k2)
652	cjp = array(k1) + array(k3)
653	cjm = array(k1) - array(k3)
654	array(kk) = ckp + cjp
655	cjp = ckp - cjp
656	IF (inv) THEN
657	ckp = ckm + CMPLX(-AIMAG(cjm), REAL(cjm), KIND=fftkind)
658	ckm = ckm + CMPLX(AIMAG(cjm), -REAL(cjm), KIND=fftkind)
659	ELSE
660	ckp = ckm + CMPLX(AIMAG(cjm), -REAL(cjm), KIND=fftkind)
661	ckm = ckm + CMPLX(-AIMAG(cjm), REAL(cjm), KIND=fftkind)
662	END IF
663	!
664	!-- Avoid useless multiplies
665	IF (s1 == 0.0_fftkind) THEN
666	array(k1) = ckp
667	array(k2) = cjp
668	array(k3) = ckm
669	ELSE
670	array(k1) = ckp * CMPLX(c1, s1, KIND=fftkind)
671	array(k2) = cjp * CMPLX(c2, s2, KIND=fftkind)
672	array(k3) = ckm * CMPLX(c3, s3, KIND=fftkind)
673	END IF
674	kk = k3 + kspan
675	IF (kk > nt) EXIT
676	END DO
677
678	c2 = c1 - (cd * c1 + sd * s1)
679	s1 = sd * c1 - cd * s1 + s1
680	c1 = 2.0_fftkind - (c2 * c2 + s1 * s1)
681	s1 = s1 * c1
682	c1 = c1 * c2
683	!
684	!-- Values of c2, c3, s2, s3 that will get used next time
685	c2 = c1 * c1 - s1 * s1
686	s2 = 2.0_fftkind * c1 * s1
687	c3 = c2 * c1 - s2 * s1
688	s3 = c2 * s1 + s2 * c1
689	kk = kk - nt + jc
690	IF (kk > kspan) EXIT
691	END DO
692	kk = kk - kspan + 1
693	IF (kk > jc) EXIT
694	END DO
695	IF (kspan == jc) RETURN
696
697	CASE default
698	!
699	!-- Transform for odd factors
700	k = factor(ii)
701	ispan = kspan
702	kspan = kspan / k
703
704	SELECT CASE (k)
705	CASE (3) !-- transform for factor of 3 (optional code)
706	DO
707	DO
708	k1 = kk + kspan
709	k2 = k1 + kspan
710	ck = array(kk)
711	cj = array(k1) + array(k2)
712	array(kk) = ck + cj
713	ck = ck - CMPLX( &
714	0.5_fftkind * REAL (cj), &
715	0.5_fftkind * AIMAG(cj), &
716	KIND=fftkind)
717	cj = CMPLX( &
718	(REAL (array(k1)) - REAL (array(k2))) * s60, &
719	(AIMAG(array(k1)) - AIMAG(array(k2))) * s60, &
720	KIND=fftkind)
721	array(k1) = ck + CMPLX(-AIMAG(cj), REAL(cj), KIND=fftkind)
722	array(k2) = ck + CMPLX(AIMAG(cj), -REAL(cj), KIND=fftkind)
723	kk = k2 + kspan
724	IF (kk >= nn) EXIT
725	END DO
726	kk = kk - nn
727	IF (kk > kspan) EXIT
728	END DO
729
730	CASE (5) !-- transform for factor of 5 (optional code)
731	c2 = c72 * c72 - s72 * s72
732	s2 = 2.0_fftkind * c72 * s72
733	DO
734	DO
735	k1 = kk + kspan
736	k2 = k1 + kspan
737	k3 = k2 + kspan
738	k4 = k3 + kspan
739	ckp = array(k1) + array(k4)
740	ckm = array(k1) - array(k4)
741	cjp = array(k2) + array(k3)
742	cjm = array(k2) - array(k3)
743	cc = array(kk)
744	array(kk) = cc + ckp + cjp
745	ck = CMPLX(REAL(ckp) * c72, AIMAG(ckp) * c72, &
746	KIND=fftkind) + &
747	CMPLX(REAL(cjp) * c2, AIMAG(cjp) * c2, &
748	KIND=fftkind) + cc
749	cj = CMPLX(REAL(ckm) * s72, AIMAG(ckm) * s72, &
750	KIND=fftkind) + &
751	CMPLX(REAL(cjm) * s2, AIMAG(cjm) * s2, &
752	KIND=fftkind)
753	array(k1) = ck + CMPLX(-AIMAG(cj), REAL(cj), KIND=fftkind)
754	array(k4) = ck + CMPLX(AIMAG(cj), -REAL(cj), KIND=fftkind)
755	ck = CMPLX(REAL(ckp) * c2, AIMAG(ckp) * c2, &
756	KIND=fftkind) + &
757	CMPLX(REAL(cjp) * c72, AIMAG(cjp) * c72, &
758	KIND=fftkind) + cc
759	cj = CMPLX(REAL(ckm) * s2, AIMAG(ckm) * s2, &
760	KIND=fftkind) - &
761	CMPLX(REAL(cjm) * s72, AIMAG(cjm) * s72, &
762	KIND=fftkind)
763	array(k2) = ck + CMPLX(-AIMAG(cj), REAL(cj), KIND=fftkind)
764	array(k3) = ck + CMPLX(AIMAG(cj), -REAL(cj), KIND=fftkind)
765	kk = k4 + kspan
766	IF (kk >= nn) EXIT
767	END DO
768	kk = kk - nn
769	IF (kk > kspan) EXIT
770	END DO
771
772	CASE default
773	IF (k /= jf) THEN
774	jf = k
775	s1 = pi2 / k
776	c1 = COS(s1)
777	s1 = SIN(s1)
778	cosine (jf) = 1.0_fftkind
779	sine (jf) = 0.0_fftkind
780	j = 1
781	DO
782	cosine (j) = cosine (k) * c1 + sine (k) * s1
783	sine (j) = cosine (k) * s1 - sine (k) * c1
784	k = k-1
785	cosine (k) = cosine (j)
786	sine (k) = -sine (j)
787	j = j + 1
788	IF (j >= k) EXIT
789	END DO
790	END IF
791	DO
792	DO
793	k1 = kk
794	k2 = kk + ispan
795	cc = array(kk)
796	ck = cc
797	j = 1
798	k1 = k1 + kspan
799	DO
800	k2 = k2 - kspan
801	j = j + 1
802	ctmp(j) = array(k1) + array(k2)
803	ck = ck + ctmp(j)
804	j = j + 1
805	ctmp(j) = array(k1) - array(k2)
806	k1 = k1 + kspan
807	IF (k1 >= k2) EXIT
808	END DO
809	array(kk) = ck
810	k1 = kk
811	k2 = kk + ispan
812	j = 1
813	DO
814	k1 = k1 + kspan
815	k2 = k2 - kspan
816	jj = j
817	ck = cc
818	cj = (0.0_fftkind, 0.0_fftkind)
819	k = 1
820	DO
821	k = k + 1
822	ck = ck + CMPLX( &
823	REAL (ctmp(k)) * cosine(jj), &
824	AIMAG(ctmp(k)) * cosine(jj), KIND=fftkind)
825	k = k + 1
826	cj = cj + CMPLX( &
827	REAL (ctmp(k)) * sine(jj), &
828	AIMAG(ctmp(k)) * sine(jj), KIND=fftkind)
829	jj = jj + j
830	IF (jj > jf) jj = jj - jf
831	IF (k >= jf) EXIT
832	END DO
833	k = jf - j
834	array(k1) = ck + CMPLX(-AIMAG(cj), REAL(cj), &
835	KIND=fftkind)
836	array(k2) = ck + CMPLX(AIMAG(cj), -REAL(cj), &
837	KIND=fftkind)
838	j = j + 1
839	IF (j >= k) EXIT
840	END DO
841	kk = kk + ispan
842	IF (kk > nn) EXIT
843	END DO
844	kk = kk - nn
845	IF (kk > kspan) EXIT
846	END DO
847
848	END SELECT
849	!
850	!-- Multiply by rotation factor (except for factors of 2 and 4)
851	IF (ii == nfactor) RETURN
852	kk = jc + 1
853	DO
854	c2 = 1.0_fftkind - cd
855	s1 = sd
856	DO
857	c1 = c2
858	s2 = s1
859	kk = kk + kspan
860	DO
861	DO
862	array(kk) = CMPLX(c2, s2, KIND=fftkind) * array(kk)
863	kk = kk + ispan
864	IF (kk > nt) EXIT
865	END DO
866	ak = s1 * s2
867	s2 = s1 * c2 + c1 * s2
868	c2 = c1 * c2 - ak
869	kk = kk - nt + kspan
870	IF (kk > ispan) EXIT
871	END DO
872	c2 = c1 - (cd * c1 + sd * s1)
873	s1 = s1 + sd * c1 - cd * s1
874	c1 = 2.0_fftkind - (c2 * c2 + s1 * s1)
875	s1 = s1 * c1
876	c2 = c2 * c1
877	kk = kk - ispan + jc
878	IF (kk > kspan) EXIT
879	END DO
880	kk = kk - kspan + jc + 1
881	IF (kk > jc + jc) EXIT
882	END DO
883
884	END SELECT
885	END DO
886	END SUBROUTINE transform
887
888
889	SUBROUTINE permute(array, ntotal, npass, nspan, &
890	factor, nfactor, nsquare, maxfactor, &
891	ctmp, perm)
892	!
893	!-- Formal parameters
894	COMPLEX(fftkind), DIMENSION(*), INTENT(IN OUT):: array
895	INTEGER, INTENT(IN) :: ntotal, npass, nspan
896	INTEGER, DIMENSION(*), INTENT(IN OUT):: factor
897	INTEGER, INTENT(IN) :: nfactor, nsquare
898	INTEGER, INTENT(IN) :: maxfactor
899	COMPLEX(fftkind), DIMENSION(*), INTENT(OUT) :: ctmp
900	INTEGER, DIMENSION(*), INTENT(OUT) :: perm
901	!
902	!-- Local scalars
903	INTEGER :: ii, ispan
904	INTEGER :: j, jc, jj
905	INTEGER :: k, kk, kspan, kt, k1, k2, k3
906	INTEGER :: nn, nt
907	COMPLEX(fftkind):: ck
908
909	!
910	!-- Permute the results to normal order---done in two stages
911	!-- Permutation for square factors of n
912
913	nt = ntotal
914	nn = nt - 1
915	kt = nsquare
916	kspan = nspan
917	jc = nspan / npass
918
919	perm (1) = nspan
920	IF (kt > 0) THEN
921	k = kt + kt + 1
922	IF (nfactor < k) k = k - 1
923	j = 1
924	perm (k + 1) = jc
925	DO
926	perm (j + 1) = perm (j) / factor(j)
927	perm (k) = perm (k + 1) * factor(j)
928	j = j + 1
929	k = k - 1
930	IF (j >= k) EXIT
931	END DO
932	k3 = perm (k + 1)
933	kspan = perm (2)
934	kk = jc + 1
935	k2 = kspan + 1
936	j = 1
937
938	IF (npass /= ntotal) THEN
939	permute_multi: DO
940	DO
941	DO
942	k = kk + jc
943	DO
944	!
945	!-- Swap array(kk) <> array(k2)
946	ck = array(kk)
947	array(kk) = array(k2)
948	array(k2) = ck
949	kk = kk + 1
950	k2 = k2 + 1
951	IF (kk >= k) EXIT
952	END DO
953	kk = kk + nspan - jc
954	k2 = k2 + nspan - jc
955	IF (kk >= nt) EXIT
956	END DO
957	kk = kk - nt + jc
958	k2 = k2 - nt + kspan
959	IF (k2 >= nspan) EXIT
960	END DO
961	DO
962	DO
963	k2 = k2 - perm (j)
964	j = j + 1
965	k2 = perm (j + 1) + k2
966	IF (k2 <= perm (j)) EXIT
967	END DO
968	j = 1
969	DO
970	IF (kk < k2) CYCLE permute_multi
971	kk = kk + jc
972	k2 = k2 + kspan
973	IF (k2 >= nspan) EXIT
974	END DO
975	IF (kk >= nspan) EXIT
976	END DO
977	EXIT
978	END DO permute_multi
979	ELSE
980	permute_single: DO
981	DO
982	!
983	!-- Swap array(kk) <> array(k2)
984	ck = array(kk)
985	array(kk) = array(k2)
986	array(k2) = ck
987	kk = kk + 1
988	k2 = k2 + kspan
989	IF (k2 >= nspan) EXIT
990	END DO
991	DO
992	DO
993	k2 = k2 - perm (j)
994	j = j + 1
995	k2 = perm (j + 1) + k2
996	IF (k2 <= perm (j)) EXIT
997	END DO
998	j = 1
999	DO
1000	IF (kk < k2) CYCLE permute_single
1001	kk = kk + 1
1002	k2 = k2 + kspan
1003	IF (k2 >= nspan) EXIT
1004	END DO
1005	IF (kk >= nspan) EXIT
1006	END DO
1007	EXIT
1008	END DO permute_single
1009	END IF
1010	jc = k3
1011	END IF
1012
1013	IF (ISHFT(kt, 1) + 1 >= nfactor) RETURN
1014
1015	ispan = perm (kt + 1)
1016	!
1017	!-- Permutation for square-free factors of n
1018	j = nfactor - kt
1019	factor(j + 1) = 1
1020	DO
1021	factor(j) = factor(j) * factor(j+1)
1022	j = j - 1
1023	IF (j == kt) EXIT
1024	END DO
1025	kt = kt + 1
1026	nn = factor(kt) - 1
1027	j = 0
1028	jj = 0
1029	DO
1030	k = kt + 1
1031	k2 = factor(kt)
1032	kk = factor(k)
1033	j = j + 1
1034	IF (j > nn) EXIT !-- exit infinite loop
1035	jj = jj + kk
1036	DO WHILE (jj >= k2)
1037	jj = jj - k2
1038	k2 = kk
1039	k = k + 1
1040	kk = factor(k)
1041	jj = jj + kk
1042	END DO
1043	perm (j) = jj
1044	END DO
1045	!
1046	!-- Determine the permutation cycles of length greater than 1
1047	j = 0
1048	DO
1049	DO
1050	j = j + 1
1051	kk = perm(j)
1052	IF (kk >= 0) EXIT
1053	END DO
1054	IF (kk /= j) THEN
1055	DO
1056	k = kk
1057	kk = perm (k)
1058	perm (k) = -kk
1059	IF (kk == j) EXIT
1060	END DO
1061	k3 = kk
1062	ELSE
1063	perm (j) = -j
1064	IF (j == nn) EXIT !-- exit infinite loop
1065	END IF
1066	END DO
1067	!
1068	!-- Reorder a and b, following the permutation cycles
1069	DO
1070	j = k3 + 1
1071	nt = nt - ispan
1072	ii = nt - 1 + 1
1073	IF (nt < 0) EXIT !-- exit infinite loop
1074	DO
1075	DO
1076	j = j-1
1077	IF (perm(j) >= 0) EXIT
1078	END DO
1079	jj = jc
1080	DO
1081	kspan = jj
1082	IF (jj > maxfactor) kspan = maxfactor
1083	jj = jj - kspan
1084	k = perm(j)
1085	kk = jc * k + ii + jj
1086	k1 = kk + kspan
1087	k2 = 0
1088	DO
1089	k2 = k2 + 1
1090	ctmp(k2) = array(k1)
1091	k1 = k1 - 1
1092	IF (k1 == kk) EXIT
1093	END DO
1094	DO
1095	k1 = kk + kspan
1096	k2 = k1 - jc * (k + perm(k))
1097	k = -perm(k)
1098	DO
1099	array(k1) = array(k2)
1100	k1 = k1 - 1
1101	k2 = k2 - 1
1102	IF (k1 == kk) EXIT
1103	END DO
1104	kk = k2
1105	IF (k == j) EXIT
1106	END DO
1107	k1 = kk + kspan
1108	k2 = 0
1109	DO
1110	k2 = k2 + 1
1111	array(k1) = ctmp(k2)
1112	k1 = k1 - 1
1113	IF (k1 == kk) EXIT
1114	END DO
1115	IF (jj == 0) EXIT
1116	END DO
1117	IF (j == 1) EXIT
1118	END DO
1119	END DO
1120
1121	END SUBROUTINE permute
1122
1123	END SUBROUTINE fftradix
1124
1125	END MODULE singleton

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

| Impressum | ©Leibniz Universität Hannover |