Download
0: {--------------------------------------------------------------}
1: { Delphi interface to the FFTW library -- FFTW Version 3.2.2. }
2: { Note that this interface is incomplete. Additional function }
3: { interface entries may be added in an anologous manner, see }
4: { fftw for more details. }
5: { }
6: { Last modified 2011.01.14 }
7: { Written by Istvan Szikra https://en.szikraistvan.hu/ }
8: { based on Mark G. Beckett (g.beckett@epcc.ed.ac.uk) }
9: { and Free Pascal version by Daniel Mantione }
10: {--------------------------------------------------------------}
11:
12: unit fftw3;
13:
14: interface
15: {$define DFFTW_NODOUBLE=1}
16: { $define DFFTW_NOSINGLE=1}
17:
18: uses
19: FSTypes, Types;
20:
21: const
22: fftw3dllname='libfftw3-3.dll'; /// double
23: fftw3dllname_double='libfftw3-3.dll';
24: fftw3dllname_single='libfftw3f-3.dll';
25: // fftw3dllname_longdouble='libfftw3l-3.dll';
26:
27: type
28: Tfftw_complex = TComplexDouble;
29: Pfftw_complex = PComplexDoubleArray;
30: Pfftw_plan = Pointer;
31:
32: Tfftw_sign = (fftw_sforward=-1,fftw_sbackward=1 ,fftw_sfake2=10241024); /// force 32 bit
33: Tfftw_flag = (//fftw_measure, {generated optimized algorithm}
34: fftw_fdestroy_input, {default}
35: fftw_funaligned, {data is unaligned}
36: fftw_fconserve_memory, {needs no explanation}
37: fftw_fexhaustive, {search optimal algorithm}
38: fftw_fpreserve_input, {don't overwrite input}
39: fftw_fpatient, {generate highly optimized alg.}
40: fftw_festimate, {don't optimize, just use an alg.}
41: fftw_ffake7, /// the rest is to force delphi to use 32 bit integer for the set type
42: fftw_ffake8, fftw_ffake9, fftw_ffake10, fftw_ffake11, /// (freepascal always uses 32 bit for small sets)
43: fftw_ffake12, fftw_ffake13, fftw_ffake14, fftw_ffake15,
44: fftw_ffake16, fftw_ffake17, fftw_ffake18, fftw_ffake19,
45: fftw_ffake20, fftw_ffake21, fftw_ffake22, fftw_ffake23,
46: fftw_ffake24, fftw_ffake25, fftw_ffake26, fftw_ffake27,
47: fftw_ffake28, fftw_ffake29, fftw_ffake30, fftw_ffake31
48: );
49: Tfftw_flagset = set of Tfftw_flag;
50:
51: Tfftwf_complex = TComplexSingle;
52: Pfftwf_complex = PComplexSingleArray;
53: Pfftwf_plan = Pfftw_plan;
54: Tfftwf_sign = Tfftw_sign;
55: Tfftwf_flagset = Tfftw_flagset;
56:
57: { Steps:
58: - Allocate memory (16 byte alligned)
59: - FFTW’s planner “learns” the fastest way to compute the transform on your machine.
60: - the plan is executed to transform the array of input data as dictated by the plan.
61: [ execute on multiple data, multiple runs ]
62: - destroy the plan
63: - free memory
64:
65: The basic interface computes a single transform of contiguous data.
66: The advanced interface computes transforms of multiple or strided arrays.
67: The guru interface supports the most general data layouts, multiplicities, and strides.
68: }
69:
70: //// Double precision version:
71: {$ifndef DFFTW_NODOUBLE}
72: function fftw_malloc(n : Integer) : Pointer; cdecl; external fftw3dllname_double;
73: procedure fftw_free(p : Pointer); cdecl; external fftw3dllname_double;
74:
75: {Complex to complex transformations.}
76: function fftw_plan_dft_1d(n:LongWord; cin:Pfftw_complex; cout:Pfftw_complex;
77: sign:Tfftw_sign; flags:Tfftw_flagset):Pfftw_plan;
78: cdecl; external fftw3dllname_double name 'fftw_plan_dft_1d'; overload;
79: function fftw_plan_dft_2d(nx,ny:LongWord; cin:Pfftw_complex; cout:Pfftw_complex;
80: sign:Tfftw_sign; flags:Tfftw_flagset):Pfftw_plan;
81: cdecl; external fftw3dllname_double name 'fftw_plan_dft_2d'; overload;
82: function fftw_plan_dft_3d(nx,ny,nz:LongWord; cin:Pfftw_complex; cout:Pfftw_complex;
83: sign:Tfftw_sign; flags:Tfftw_flagset):Pfftw_plan;
84: cdecl; external fftw3dllname_double name 'fftw_plan_dft_3d'; overload;
85: function fftw_plan_dft( rank:LongWord; ns:PLongWord; cin:Pfftw_complex; cout:Pfftw_complex;
86: sign:Tfftw_sign; flags:Tfftw_flagset):Pfftw_plan;
87: cdecl; external fftw3dllname_double name 'fftw_plan_dft'; overload;
88:
89: {Real to complex transformations.}
90: function fftw_plan_dft_1d(n:LongWord; rin:PDoubleArray; cout:Pfftw_complex;
91: flags:Tfftw_flagset):Pfftw_plan;
92: cdecl; external fftw3dllname_double name 'fftw_plan_dft_r2c_1d'; overload;
93: function fftw_plan_dft_2d(nx,ny:LongWord; rin:PDoubleArray; cout:Pfftw_complex;
94: flags:Tfftw_flagset):Pfftw_plan;
95: cdecl; external fftw3dllname_double name 'fftw_plan_dft_r2c_2d'; overload;
96: function fftw_plan_dft_3d(nx,ny,nz:LongWord; rin:PDoubleArray; cout:Pfftw_complex;
97: flags:Tfftw_flagset):Pfftw_plan;
98: cdecl; external fftw3dllname_double name 'fftw_plan_dft_r2c_3d'; overload;
99: function fftw_plan_dft( rank:LongWord; ns:PLongWord; rin:PDoubleArray; cout:Pfftw_complex;
100: flags:Tfftw_flagset):Pfftw_plan;
101: cdecl; external fftw3dllname_double name 'fftw_plan_dft_r2c'; overload;
102:
103: {Complex to real transformations.}
104: function fftw_plan_dft_1d(n:LongWord; cin:Pfftw_complex; rout:PDoubleArray;
105: flags:Tfftw_flagset):Pfftw_plan;
106: cdecl; external fftw3dllname_double name 'fftw_plan_dft_c2r_1d'; overload;
107: function fftw_plan_dft_2d(nx,ny:LongWord; cin:Pfftw_complex; rout:PDoubleArray;
108: flags:Tfftw_flagset):Pfftw_plan;
109: cdecl; external fftw3dllname_double name 'fftw_plan_dft_c2r_2d'; overload;
110: function fftw_plan_dft_3d(nx,ny,nz:LongWord; cin:Pfftw_complex; rout:PDoubleArray;
111: flags:Tfftw_flagset):Pfftw_plan;
112: cdecl; external fftw3dllname_double name 'fftw_plan_dft_c2r_3d'; overload;
113: function fftw_plan_dft( rank:LongWord; ns:PLongWord; cin:Pfftw_complex; rout:PDoubleArray;
114: flags:Tfftw_flagset):Pfftw_plan;
115: cdecl; external fftw3dllname_double name 'fftw_plan_dft_c2r'; overload;
116:
117: { There is a lot more ... (New-array Execute, Advanced - many array)
118: fftw_plan_many_dft
119: fftw_plan_guru_dft
120: fftw_plan_guru_split_dft
121: fftw_plan_guru64_dft
122: fftw_plan_guru64_split_dft
123: fftw_execute_dft
124: fftw_execute_split_dft
125: fftw_execute_dft_r2c
126: fftw_execute_dft_c2r
127: fftw_execute_r2r
128: fftw_execute_split_dft_r2c
129: fftw_execute_split_dft_c2r
130: ...
131: fftw_plan_r2r
132: fftw_plan_r2r_1d
133: fftw_plan_r2r_2d
134: fftw_plan_r2r_3d
135: }
136:
137: procedure fftw_destroy_plan(plan :Pfftw_plan);
138: cdecl; external fftw3dllname_double name 'fftw_destroy_plan';
139:
140: procedure fftw_execute(plan :Pfftw_plan);
141: cdecl; external fftw3dllname_double name 'fftw_execute';
142:
143: procedure fftw_cleanup();
144: cdecl; external fftw3dllname_double name 'fftw_cleanup';
145: /// fftw_cleanup does not deallocate your plans, however. To prevent memory leaks, you must still call fftw_destroy_plan before executing fftw_cleanup.
146: {$endif}
147:
148: //// Single precision version:
149: {$ifndef DFFTW_NOSINGLE}
150: function fftwf_malloc(n : Integer) : Pointer; cdecl; external fftw3dllname_single;
151: procedure fftwf_free(p : Pointer); cdecl; external fftw3dllname_single;
152:
153: {Complex to complex transformations.}
154: function fftwf_plan_dft_1d(n:LongWord; cin:Pfftwf_complex; cout:Pfftwf_complex;
155: sign:Tfftwf_sign; flags:Tfftwf_flagset):Pfftwf_plan;
156: cdecl; external fftw3dllname_single name 'fftwf_plan_dft_1d'; overload;
157: function fftwf_plan_dft_2d(nx,ny:LongWord; cin:Pfftwf_complex; cout:Pfftwf_complex;
158: sign:Tfftwf_sign; flags:Tfftwf_flagset):Pfftwf_plan;
159: cdecl; external fftw3dllname_single name 'fftwf_plan_dft_2d'; overload;
160: function fftwf_plan_dft_3d(nx,ny,nz:LongWord; cin:Pfftwf_complex; cout:Pfftwf_complex;
161: sign:Tfftwf_sign; flags:Tfftwf_flagset):Pfftwf_plan;
162: cdecl; external fftw3dllname_single name 'fftwf_plan_dft_3d'; overload;
163: function fftwf_plan_dft( rank:LongWord; ns:PLongWord; cin:Pfftwf_complex; cout:Pfftwf_complex;
164: sign:Tfftwf_sign; flags:Tfftwf_flagset):Pfftwf_plan;
165: cdecl; external fftw3dllname_single name 'fftwf_plan_dft'; overload;
166:
167: {Real to complex transformations.}
168: function fftwf_plan_dft_1d(n:LongWord; rin:PSingleArray; cout:Pfftwf_complex;
169: flags:Tfftwf_flagset):Pfftwf_plan;
170: cdecl; external fftw3dllname_single name 'fftwf_plan_dft_r2c_1d'; overload;
171: function fftwf_plan_dft_2d(nx,ny:LongWord; rin:PSingleArray; cout:Pfftwf_complex;
172: flags:Tfftwf_flagset):Pfftwf_plan;
173: cdecl; external fftw3dllname_single name 'fftwf_plan_dft_r2c_2d'; overload;
174: function fftwf_plan_dft_3d(nx,ny,nz:LongWord; rin:PSingleArray; cout:Pfftwf_complex;
175: flags:Tfftwf_flagset):Pfftwf_plan;
176: cdecl; external fftw3dllname_single name 'fftwf_plan_dft_r2c_3d'; overload;
177: function fftwf_plan_dft( rank:LongWord; ns:PLongWord; rin:PSingleArray; cout:Pfftwf_complex;
178: flags:Tfftwf_flagset):Pfftwf_plan;
179: cdecl; external fftw3dllname_single name 'fftwf_plan_dft_r2c'; overload;
180:
181: {Complex to real transformations.}
182: function fftwf_plan_dft_1d(n:LongWord; cin:Pfftwf_complex; rout:PSingleArray;
183: flags:Tfftwf_flagset):Pfftwf_plan;
184: cdecl; external fftw3dllname_single name 'fftwf_plan_dft_c2r_1d'; overload;
185: function fftwf_plan_dft_2d(nx,ny:LongWord; cin:Pfftwf_complex; rout:PSingleArray;
186: flags:Tfftwf_flagset):Pfftwf_plan;
187: cdecl; external fftw3dllname_single name 'fftwf_plan_dft_c2r_2d'; overload;
188: function fftwf_plan_dft_3d(nx,ny,nz:LongWord; cin:Pfftwf_complex; rout:PSingleArray;
189: flags:Tfftwf_flagset):Pfftwf_plan;
190: cdecl; external fftw3dllname_single name 'fftwf_plan_dft_c2r_3d'; overload;
191: function fftwf_plan_dft( rank:LongWord; ns:PLongWord; cin:Pfftwf_complex; rout:PSingleArray;
192: flags:Tfftwf_flagset):Pfftwf_plan;
193: cdecl; external fftw3dllname_single name 'fftwf_plan_dft_c2r'; overload;
194:
195: { There is a lot more ... (New-array Execute, Advanced - many array)
196: fftwf_plan_many_dft
197: fftwf_plan_guru_dft
198: fftwf_plan_guru_split_dft
199: fftwf_plan_guru64_dft
200: fftwf_plan_guru64_split_dft
201: fftwf_execute_dft
202: fftwf_execute_split_dft
203: fftwf_execute_dft_r2c
204: fftwf_execute_dft_c2r
205: fftwf_execute_r2r
206: fftwf_execute_split_dft_r2c
207: fftwf_execute_split_dft_c2r
208: ...
209: fftwf_plan_r2r
210: fftwf_plan_r2r_1d
211: fftwf_plan_r2r_2d
212: fftwf_plan_r2r_3d
213: }
214:
215: procedure fftwf_destroy_plan(plan :Pfftwf_plan);
216: cdecl; external fftw3dllname_single name 'fftwf_destroy_plan';
217:
218: procedure fftwf_execute(plan :Pfftwf_plan);
219: cdecl; external fftw3dllname_single name 'fftwf_execute';
220:
221: procedure fftwf_cleanup();
222: cdecl; external fftw3dllname_single name 'fftwf_cleanup';
223: /// fftwf_cleanup does not deallocate your plans, however. To prevent memory leaks, you must still call fftwf_destroy_plan before executing fftwf_cleanup.
224: {$endif}
225:
226: const
227: CFFTW_FORWARD = -1;
228: CFFTW_BACKWARD = 1;
229:
230: CFFTW_MEASURE =(0);
231: CFFTW_DESTROY_INPUT =(1);
232: CFFTW_UNALIGNED =(2);
233: CFFTW_CONSERVE_MEMORY =(4);
234: CFFTW_EXHAUSTIVE =(8); /// NO_EXHAUSTIVE is default *
235: CFFTW_PRESERVE_INPUT =(16); /// cancels fftwf_DESTROY_INPUT *
236: CFFTW_PATIENT =(32); /// IMPATIENT is default *
237: CFFTW_ESTIMATE =(64);
238: {
239: type
240: Tfftw_r2r_kind_do_not_use_me = (
241: FFTW_R2HC = 0, FFTW_HC2R = 1, FFTW_DHT = 2,
242: FFTW_REDFT00 = 3,FFTW_REDFT01 = 4,
243: FFTW_REDFT10 = 5,FFTW_REDFT11 = 6,
244: FFTW_RODFT00 = 7,FFTW_RODFT01 = 8,
245: FFTW_RODFT10 = 9,FFTW_RODFT11 = 10
246: );
247:
248: Tfftw_iodim_do_not_use_me = record
249: n : longint;
250: i : longint; // is
251: o : longint; // os
252: end;
253:
254: Tfftw_iodim64_do_not_use_me = Tfftw_iodim_do_not_use_me;
255: }
256:
257: implementation
258:
259: //// Double precision version:
260:
261: //// Single precision version:
262:
263: end.