Return the Reverse (unnormalized) Fourier Transform of a periodic sequence of type complex or real of arbitrary kind type parameter. More...

Detailed Description

Return the Reverse (unnormalized) Fourier Transform of a periodic sequence of type complex or real of arbitrary kind type parameter.

For an input data sequence of length \(N\) of type complex, the output coefficients fftr (either stored in data or work) contain the following,

\begin{equation} \ms{fftr}(k) = \sum_{j = 1}^{N} \ms{data}(j) \exp\left( +i \cdot (k - 1)(j - 1) \frac{2\pi}{N} \right) ~, \\ \end{equation}

where \(i = \sqrt{-1}\).

For an input data sequence of length \(N\) of type real, the output coefficients fftr (either stored in data or work) contain the following,

\begin{eqnarray} \ms{fftr}(k) &=& \ms{data}(1) \\ &+& \sum_{j = 2}^{\left\lceil\frac{N}{2}\right\rceil} 2\left[ \ms{data}(2j - 2) \cos\left((k - 1)(j - 1)\frac{2\pi}{N}\right) - \ms{data}(2j - 1) \sin\left((k - 1)(j - 1)\frac{2\pi}{N}\right) \right] \\ &+& (-1)^{(k - 1)} \ms{data}(N) \times 2\left( \frac{n+1}{2} - \left\lceil\frac{N}{2}\right\rceil \right) ~, \end{eqnarray}

where the expression \(2\left( \frac{n+1}{2} - \left\lceil\frac{N}{2}\right\rceil \right)\) in the last term ensures the last term is non-zero only when \(N\) is even.

A call to setFFTF() followed by a call to setFFTR() will multiply the initial sequence data by its length \(N\).
A call to setFFTF() followed by a call to setFFTI() will retrieve the initial sequence data.
See the documentation of pm_fftpack for more details.

Parameters

[in]	factor	: The input `contiguous` vector of shape `(:)` of type `integer` of default kind IK, containing the factorization of the length of the input `data` sequence whose FFT is to be computed. This input argument along with `coef` is the direct output of getFactorFFT.
[in]	coef	: The input `contiguous` vector of shape `(1:size(data))` of the same type and kind as the input argument `data`, containing the trigonometric look up table required for FFT of the specified `data` sequence. This input argument along with `factor` is the direct output of getFactorFFT.
[in,out]	data	: The input/output `contiguous` vector of arbitrary size of, type `complex` of kind any supported by the processor (e.g., CK, CK32, CK64, or CK128), type `real` of kind any supported by the processor (e.g., RK, RK32, RK64, or RK128), containing the periodic sequence whose FFT is to be computed. On output, `data` contains the FFT result if `inwork == .true.`. Otherwise, the original input data is completely destroyed on return.
[out]	work	: The output `contiguous` vector of the same type, kind, and size as the input `data`, that is used as a workspace. On output, `work` contains the FFT result if `inwork == .false.`.
[out]	inwork	: The output scalar of type `logical` of default kind LK. If `.true.`, the FFT result is stored in the output `work` argument upon return from the procedure. If `.false.`, the FFT result is stored in the output `data` argument upon return from the procedure.

Possible calling interfaces ⛓

: use pm_fftpack, only: setFFTR

call setFFTR(factor(:), coef(1:size(data)), data(:), work(1:size(data)), inwork)

pm_fftpack::setFFTR
Return the Reverse (unnormalized) Fourier Transform of a periodic sequence of type complex or real of...
Definition: pm_fftpack.F90:1361

pm_fftpack
This module contains procedures and generic interfaces for computing the Discrete Fourier Transform o...
Definition: pm_fftpack.F90:205

Warning: The condition size(data) == size(coef) must hold for the corresponding input arguments.
The condition size(data) == size(work) must hold for the corresponding input arguments.
These conditions are verified only if the library is built with the preprocessor macro CHECK_ENABLED=1.; The pure procedure(s) documented herein become impure when the ParaMonte library is compiled with preprocessor macro CHECK_ENABLED=1.
By default, these procedures are pure in release build and impure in debug and testing builds.

See also: getFFTF
getFFTR
getFFTI
setFFTF
setFFTR
setFFTI

Example usage ⛓

: 1program example

2

3 use pm_kind, only: SK, IK, LK

4 use pm_io, only: display_type

5 use pm_fftpack, only: getfactorFFT

6 use pm_fftpack, only: setFFTF, setFFTR

7 use pm_arrayResize, only: setResized

8

9 implicit none

10

11 logical(LK) :: inwork

12 integer(IK), allocatable :: factor(:)

13

14 type(display_type) :: disp

15 disp = display_type(file = "main.out.F90")

16

17 block

18 use pm_kind, only: CKG => CKS

19 complex(CKG), allocatable :: data(:), coef(:), work(:)

20 call disp%skip()

21 call disp%show("data = [complex(CKG) :: (1., -6.), (2., -5.), (3., -4.), (4., -3.), (5., -2.), (6., -1.)]")

22 data = [complex(CKG) :: (1., -6.), (2., -5.), (3., -4.), (4., -3.), (5., -2.), (6., -1.)]

23 call disp%show("if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)")

24 if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)

25 call disp%show("if (allocated(work)) deallocate(work); allocate(work, mold = data)")

26 if (allocated(work)) deallocate(work); allocate(work, mold = data)

27 call disp%show("factor = getfactorFFT(data, coef)")

28 factor = getfactorFFT(data, coef)

29 call disp%show("coef")

30 call disp%show( coef )

31 call disp%show("factor")

32 call disp%show( factor )

33 call disp%show("call setFFTF(factor, coef, data, work, inwork)")

34 call setFFTF(factor, coef, data, work, inwork)

35 call disp%show("if (inwork) data = work")

36 if (inwork) data = work

37 call disp%show("data")

38 call disp%show( data )

39 call disp%skip()

40 call disp%show("call setFFTR(factor, coef, data, work, inwork)")

41 call setFFTR(factor, coef, data, work, inwork)

42 call disp%show("if (inwork) data = work")

43 if (inwork) data = work

44 call disp%show("data / size(data)")

45 call disp%show( data / size(data) )

46 call disp%skip()

47 end block

48

49 block

50 use pm_kind, only: CKG => CKD

51 complex(CKG), allocatable :: data(:), coef(:), work(:)

52 call disp%skip()

53 call disp%show("data = [complex(CKG) :: (1., -6.), (2., -5.), (3., -4.), (4., -3.), (5., -2.), (6., -1.)]")

54 data = [complex(CKG) :: (1., -6.), (2., -5.), (3., -4.), (4., -3.), (5., -2.), (6., -1.)]

55 call disp%show("if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)")

56 if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)

57 call disp%show("if (allocated(work)) deallocate(work); allocate(work, mold = data)")

58 if (allocated(work)) deallocate(work); allocate(work, mold = data)

59 call disp%show("factor = getfactorFFT(data, coef)")

60 factor = getfactorFFT(data, coef)

61 call disp%show("coef")

62 call disp%show( coef )

63 call disp%show("factor")

64 call disp%show( factor )

65 call disp%show("call setFFTF(factor, coef, data, work, inwork)")

66 call setFFTF(factor, coef, data, work, inwork)

67 call disp%show("if (inwork) data = work")

68 if (inwork) data = work

69 call disp%show("data")

70 call disp%show( data )

71 call disp%skip()

72 call disp%show("call setFFTR(factor, coef, data, work, inwork)")

73 call setFFTR(factor, coef, data, work, inwork)

74 call disp%show("if (inwork) data = work")

75 if (inwork) data = work

76 call disp%show("data / size(data)")

77 call disp%show( data / size(data) )

78 call disp%skip()

79 end block

80

81 block

82 use pm_kind, only: CKG => CKH

83 complex(CKG), allocatable :: data(:), coef(:), work(:)

84 call disp%skip()

85 call disp%show("data = [complex(CKG) :: (1., -6.), (2., -5.), (3., -4.), (4., -3.), (5., -2.), (6., -1.)]")

86 data = [complex(CKG) :: (1., -6.), (2., -5.), (3., -4.), (4., -3.), (5., -2.), (6., -1.)]

87 call disp%show("if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)")

88 if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)

89 call disp%show("if (allocated(work)) deallocate(work); allocate(work, mold = data)")

90 if (allocated(work)) deallocate(work); allocate(work, mold = data)

91 call disp%show("factor = getfactorFFT(data, coef)")

92 factor = getfactorFFT(data, coef)

93 call disp%show("coef")

94 call disp%show( coef )

95 call disp%show("factor")

96 call disp%show( factor )

97 call disp%show("call setFFTF(factor, coef, data, work, inwork)")

98 call setFFTF(factor, coef, data, work, inwork)

99 call disp%show("if (inwork) data = work")

100 if (inwork) data = work

101 call disp%show("data")

102 call disp%show( data )

103 call disp%skip()

104 call disp%show("call setFFTR(factor, coef, data, work, inwork)")

105 call setFFTR(factor, coef, data, work, inwork)

106 call disp%show("if (inwork) data = work")

107 if (inwork) data = work

108 call disp%show("data / size(data)")

109 call disp%show( data / size(data) )

110 call disp%skip()

111 end block

112

113 block

114 use pm_kind, only: RKG => RKS

115 real(RKG), allocatable :: data(:), coef(:), work(:)

116 call disp%skip()

117 call disp%show("data = [real(RKG) :: 1., 2., 3., 4., 5., 6.5]")

118 data = [real(RKG) :: 1., 2., 3., 4., 5., 6.5]

119 call disp%show("if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)")

120 if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)

121 call disp%show("if (allocated(work)) deallocate(work); allocate(work, mold = data)")

122 if (allocated(work)) deallocate(work); allocate(work, mold = data)

123 call disp%show("factor = getfactorFFT(data, coef)")

124 factor = getfactorFFT(data, coef)

125 call disp%show("coef")

126 call disp%show( coef )

127 call disp%show("factor")

128 call disp%show( factor )

129 call disp%show("call setFFTF(factor, coef, data, work, inwork)")

130 call setFFTF(factor, coef, data, work, inwork)

131 call disp%show("if (inwork) data = work")

132 if (inwork) data = work

133 call disp%show("data")

134 call disp%show( data )

135 call disp%skip()

136 call disp%show("call setFFTR(factor, coef, data, work, inwork)")

137 call setFFTR(factor, coef, data, work, inwork)

138 call disp%show("if (inwork) data = work")

139 if (inwork) data = work

140 call disp%show("data / size(data)")

141 call disp%show( data / size(data) )

142 call disp%skip()

143 end block

144

145 block

146 use pm_kind, only: RKG => RKD

147 real(RKG), allocatable :: data(:), coef(:), work(:)

148 call disp%skip()

149 call disp%show("data = [real(RKG) :: 1., 2., 3., 4., 5., 6.5]")

150 data = [real(RKG) :: 1., 2., 3., 4., 5., 6.5]

151 call disp%show("if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)")

152 if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)

153 call disp%show("if (allocated(work)) deallocate(work); allocate(work, mold = data)")

154 if (allocated(work)) deallocate(work); allocate(work, mold = data)

155 call disp%show("factor = getfactorFFT(data, coef)")

156 factor = getfactorFFT(data, coef)

157 call disp%show("coef")

158 call disp%show( coef )

159 call disp%show("factor")

160 call disp%show( factor )

161 call disp%show("call setFFTF(factor, coef, data, work, inwork)")

162 call setFFTF(factor, coef, data, work, inwork)

163 call disp%show("if (inwork) data = work")

164 if (inwork) data = work

165 call disp%show("data")

166 call disp%show( data )

167 call disp%skip()

168 call disp%show("call setFFTR(factor, coef, data, work, inwork)")

169 call setFFTR(factor, coef, data, work, inwork)

170 call disp%show("if (inwork) data = work")

171 if (inwork) data = work

172 call disp%show("data / size(data)")

173 call disp%show( data / size(data) )

174 call disp%skip()

175 end block

176

177 block

178 use pm_kind, only: RKG => RKH

179 real(RKG), allocatable :: data(:), coef(:), work(:)

180 call disp%skip()

181 call disp%show("data = [real(RKG) :: 1., 2., 3., 4., 5., 6.5]")

182 data = [real(RKG) :: 1., 2., 3., 4., 5., 6.5]

183 call disp%show("if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)")

184 if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)

185 call disp%show("if (allocated(work)) deallocate(work); allocate(work, mold = data)")

186 if (allocated(work)) deallocate(work); allocate(work, mold = data)

187 call disp%show("factor = getfactorFFT(data, coef)")

188 factor = getfactorFFT(data, coef)

189 call disp%show("coef")

190 call disp%show( coef )

191 call disp%show("factor")

192 call disp%show( factor )

193 call disp%show("call setFFTF(factor, coef, data, work, inwork)")

194 call setFFTF(factor, coef, data, work, inwork)

195 call disp%show("if (inwork) data = work")

196 if (inwork) data = work

197 call disp%show("data")

198 call disp%show( data )

199 call disp%skip()

200 call disp%show("call setFFTR(factor, coef, data, work, inwork)")

201 call setFFTR(factor, coef, data, work, inwork)

202 call disp%show("if (inwork) data = work")

203 if (inwork) data = work

204 call disp%show("data / size(data)")

205 call disp%show( data / size(data) )

206 call disp%skip()

207 end block

208

209end program example

pm_arrayResize::setResized
Allocate or resize (shrink or expand) an input allocatable scalar string or array of rank 1....
Definition: pm_arrayResize.F90:249

pm_fftpack::setFFTF
Return the Forward Fourier Transform (or equivalently, the Fourier coefficients) of a periodic sequen...
Definition: pm_fftpack.F90:949

pm_io::show
This is a generic method of the derived type display_type with pass attribute.
Definition: pm_io.F90:11726

pm_io::skip
This is a generic method of the derived type display_type with pass attribute.
Definition: pm_io.F90:11508

pm_arrayResize
This module contains procedures and generic interfaces for resizing allocatable arrays of various typ...
Definition: pm_arrayResize.F90:81

pm_io
This module contains classes and procedures for input/output (IO) or generic display operations on st...
Definition: pm_io.F90:252

pm_io::disp
type(display_type) disp
This is a scalar module variable an object of type display_type for general display.
Definition: pm_io.F90:11393

pm_kind
This module defines the relevant Fortran kind type-parameters frequently used in the ParaMonte librar...
Definition: pm_kind.F90:268

pm_kind::LK
integer, parameter LK
The default logical kind in the ParaMonte library: kind(.true.) in Fortran, kind(....
Definition: pm_kind.F90:541

pm_kind::CKH
integer, parameter CKH
The scalar integer constant of intrinsic default kind, representing the highest-precision complex kin...
Definition: pm_kind.F90:843

pm_kind::CKS
integer, parameter CKS
The single-precision complex kind in Fortran mode. On most platforms, this is a 32-bit real kind.
Definition: pm_kind.F90:570

pm_kind::IK
integer, parameter IK
The default integer kind in the ParaMonte library: int32 in Fortran, c_int32_t in C-Fortran Interoper...
Definition: pm_kind.F90:540

pm_kind::CKD
integer, parameter CKD
The double precision complex kind in Fortran mode. On most platforms, this is a 64-bit real kind.
Definition: pm_kind.F90:571

pm_kind::RKD
integer, parameter RKD
The double precision real kind in Fortran mode. On most platforms, this is an 64-bit real kind.
Definition: pm_kind.F90:568

pm_kind::SK
integer, parameter SK
The default character kind in the ParaMonte library: kind("a") in Fortran, c_char in C-Fortran Intero...
Definition: pm_kind.F90:539

pm_kind::RKH
integer, parameter RKH
The scalar integer constant of intrinsic default kind, representing the highest-precision real kind t...
Definition: pm_kind.F90:858

pm_kind::RKS
integer, parameter RKS
The single-precision real kind in Fortran mode. On most platforms, this is an 32-bit real kind.
Definition: pm_kind.F90:567

pm_io::display_type
Generate and return an object of type display_type.
Definition: pm_io.F90:10282

Example Unix compile command via Intel ifort compiler ⛓
1#!/usr/bin/env sh

2rm main.exe

3ifort -fpp -standard-semantics -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe

4./main.exe

Example Windows Batch compile command via Intel ifort compiler ⛓
1del main.exe

2set PATH=..\..\..\lib;%PATH%

3ifort /fpp /standard-semantics /O3 /I:..\..\..\include main.F90 ..\..\..\lib\libparamonte*.lib /exe:main.exe

4main.exe

Example Unix / MinGW compile command via GNU gfortran compiler ⛓
1#!/usr/bin/env sh

2rm main.exe

3gfortran -cpp -ffree-line-length-none -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe

4./main.exe

Example output ⛓
1

2data = [complex(CKG) :: (1., -6.), (2., -5.), (3., -4.), (4., -3.), (5., -2.), (6., -1.)]

3if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)

4if (allocated(work)) deallocate(work); allocate(work, mold = data)

5factor = getfactorFFT(data, coef)

6coef

7(+1.00000000, +0.00000000), (+0.499999970, +0.866025448), (-0.500000060, +0.866025388), (+1.00000000, +0.00000000), (+1.00000000, +0.00000000), (-0.499999911, -0.866025448)

8factor

9+2, +3

10call setFFTF(factor, coef, data, work, inwork)

11if (inwork) data = work

12data

13(+21.0000000, -21.0000000), (-8.19615173, +2.19615269), (-4.73205090, -1.26794922), (-3.00000000, -2.99999976), (-1.26794922, -4.73205090), (+2.19615221, -8.19615269)

14

15call setFFTR(factor, coef, data, work, inwork)

16if (inwork) data = work

17data / size(data)

18(+1.00000000, -6.00000000), (+2.00000000, -5.00000000), (+3.00000000, -4.00000000), (+4.00000000, -3.00000000), (+5.00000000, -2.00000024), (+6.00000000, -1.00000000)

19

20

21data = [complex(CKG) :: (1., -6.), (2., -5.), (3., -4.), (4., -3.), (5., -2.), (6., -1.)]

22if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)

23if (allocated(work)) deallocate(work); allocate(work, mold = data)

24factor = getfactorFFT(data, coef)

25coef

26(+1.0000000000000000, +0.0000000000000000), (+0.50000000000000011, +0.86602540378443860), (-0.49999999999999978, +0.86602540378443871), (+1.0000000000000000, +0.0000000000000000), (+1.0000000000000000, +0.0000000000000000), (-0.50000000000000044, -0.86602540378443837)

27factor

28+2, +3

29call setFFTF(factor, coef, data, work, inwork)

30if (inwork) data = work

31data

32(+21.000000000000000, -21.000000000000000), (-8.1961524227066320, +2.1961524227066302), (-4.7320508075688767, -1.2679491924311228), (-2.9999999999999991, -3.0000000000000000), (-1.2679491924311228, -4.7320508075688767), (+2.1961524227066320, -8.1961524227066302)

33

34call setFFTR(factor, coef, data, work, inwork)

35if (inwork) data = work

36data / size(data)

37(+1.0000000000000000, -6.0000000000000000), (+2.0000000000000004, -4.9999999999999991), (+3.0000000000000004, -4.0000000000000000), (+4.0000000000000009, -3.0000000000000000), (+4.9999999999999991, -2.0000000000000000), (+6.0000000000000000, -1.0000000000000004)

38

39

40data = [complex(CKG) :: (1., -6.), (2., -5.), (3., -4.), (4., -3.), (5., -2.), (6., -1.)]

41if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)

42if (allocated(work)) deallocate(work); allocate(work, mold = data)

43factor = getfactorFFT(data, coef)

44coef

45(+1.00000000000000000000000000000000000, +0.00000000000000000000000000000000000), (+0.499999999999999999999999999999999952, +0.866025403784438646763723170752936161), (-0.500000000000000000000000000000000096, +0.866025403784438646763723170752936161), (+1.00000000000000000000000000000000000, +0.00000000000000000000000000000000000), (+1.00000000000000000000000000000000000, +0.00000000000000000000000000000000000), (-0.499999999999999999999999999999999856, -0.866025403784438646763723170752936257)

46factor

47+2, +3

48call setFFTF(factor, coef, data, work, inwork)

49if (inwork) data = work

50data

51(+21.0000000000000000000000000000000000, -21.0000000000000000000000000000000000), (-8.19615242270663188058233902451761697, +2.19615242270663188058233902451761774), (-4.73205080756887729352744634150587232, -1.26794919243112270647255365849412768), (-3.00000000000000000000000000000000077, -3.00000000000000000000000000000000039), (-1.26794919243112270647255365849412768, -4.73205080756887729352744634150587232), (+2.19615242270663188058233902451761774, -8.19615242270663188058233902451761851)

52

53call setFFTR(factor, coef, data, work, inwork)

54if (inwork) data = work

55data / size(data)

56(+1.00000000000000000000000000000000000, -6.00000000000000000000000000000000000), (+2.00000000000000000000000000000000000, -5.00000000000000000000000000000000000), (+3.00000000000000000000000000000000000, -4.00000000000000000000000000000000000), (+4.00000000000000000000000000000000000, -3.00000000000000000000000000000000000), (+5.00000000000000000000000000000000000, -2.00000000000000000000000000000000000), (+6.00000000000000000000000000000000000, -1.00000000000000000000000000000000000)

57

58

59data = [real(RKG) :: 1., 2., 3., 4., 5., 6.5]

60if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)

61if (allocated(work)) deallocate(work); allocate(work, mold = data)

62factor = getfactorFFT(data, coef)

63coef

64+0.499999970, +0.866025448, +0.00000000, +0.00000000, +0.145802732E-18, +0.378001102E-38

65factor

66+2, +3

67call setFFTF(factor, coef, data, work, inwork)

68if (inwork) data = work

69data

70+21.5000000, -2.75000000, +5.62916517, -3.25000000, +2.16506338, -3.50000000

71

72call setFFTR(factor, coef, data, work, inwork)

73if (inwork) data = work

74data / size(data)

75+1.00000000, +1.99999988, +3.00000000, +4.00000000, +5.00000000, +6.50000000

76

77

78data = [real(RKG) :: 1., 2., 3., 4., 5., 6.5]

79if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)

80if (allocated(work)) deallocate(work); allocate(work, mold = data)

81factor = getfactorFFT(data, coef)

82coef

83+0.50000000000000011, +0.86602540378443860, -536871043.12500000, -67108880.437500000, -2097154.5151367188, -8192.0020160675049

84factor

85+2, +3

86call setFFTF(factor, coef, data, work, inwork)

87if (inwork) data = work

88data

89+21.500000000000000, -2.7500000000000009, +5.6291651245988508, -3.2499999999999991, +2.1650635094610968, -3.5000000000000000

90

91call setFFTR(factor, coef, data, work, inwork)

92if (inwork) data = work

93data / size(data)

94+1.0000000000000000, +1.9999999999999998, +3.0000000000000000, +4.0000000000000000, +5.0000000000000000, +6.5000000000000000

95

96

97data = [real(RKG) :: 1., 2., 3., 4., 5., 6.5]

98if (allocated(coef)) deallocate(coef); allocate(coef, mold = data)

99if (allocated(work)) deallocate(work); allocate(work, mold = data)

100factor = getfactorFFT(data, coef)

101coef

102+0.499999999999999999999999999999999952, +0.866025403784438646763723170752936161, -144115188075856000.390625000000000028, -2251799813685250.00683593750000000043, -2199023255552.00196051597595214843708, -33554432.0000003875502443406730890274

103factor

104+2, +3

105call setFFTF(factor, coef, data, work, inwork)

106if (inwork) data = work

107data

108+21.5000000000000000000000000000000000, -2.75000000000000000000000000000000000, +5.62916512459885120396420060989408543, -3.25000000000000000000000000000000000, +2.16506350946109661690930792688234040, -3.50000000000000000000000000000000000

109

110call setFFTR(factor, coef, data, work, inwork)

111if (inwork) data = work

112data / size(data)

113+1.00000000000000000000000000000000000, +2.00000000000000000000000000000000000, +3.00000000000000000000000000000000000, +4.00000000000000000000000000000000000, +5.00000000000000000000000000000000000, +6.50000000000000000000000000000000000

114

115

Test:: test_pm_fftpack

Final Remarks ⛓

If you believe this algorithm or its documentation can be improved, we appreciate your contribution and help to edit this page's documentation and source file on GitHub.
For details on the naming abbreviations, see this page.
For details on the naming conventions, see this page.
This software is distributed under the MIT license with additional terms outlined below.

If you use any parts or concepts from this library to any extent, please acknowledge the usage by citing the relevant publications of the ParaMonte library.
If you regenerate any parts/ideas from this library in a programming environment other than those currently supported by this ParaMonte library (i.e., other than C, C++, Fortran, MATLAB, Python, R), please also ask the end users to cite this original ParaMonte library.

This software is available to the public under a highly permissive license.
Help us justify its continued development and maintenance by acknowledging its benefit to society, distributing it, and contributing to it.

Copyright: Computational Data Science Lab

Author:: Fatemeh Bagheri, Tuesday 11:34 PM, August 10, 2021, Dallas, TX

Definition at line 1361 of file pm_fftpack.F90.

The documentation for this interface was generated from the following file:

src/fortran/main/pm_fftpack.F90