1/*
2 * Copyright (c) 2003, 2007-14 Matteo Frigo
3 * Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology
4 *
5 * The following statement of license applies *only* to this header file,
6 * and *not* to the other files distributed with FFTW or derived therefrom:
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
20 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
23 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
25 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32/***************************** NOTE TO USERS *********************************
33 *
34 * THIS IS A HEADER FILE, NOT A MANUAL
35 *
36 * If you want to know how to use FFTW, please read the manual,
37 * online at http://www.fftw.org/doc/ and also included with FFTW.
38 * For a quick start, see the manual's tutorial section.
39 *
40 * (Reading header files to learn how to use a library is a habit
41 * stemming from code lacking a proper manual. Arguably, it's a
42 * *bad* habit in most cases, because header files can contain
43 * interfaces that are not part of the public, stable API.)
44 *
45 ****************************************************************************/
46
47#ifndef FFTW3_H
48#define FFTW3_H
49
50#include <stdio.h>
51
52#ifdef __cplusplus
53extern "C"
54{
55#endif /* __cplusplus */
56
57/* If <complex.h> is included, use the C99 complex type. Otherwise
58 define a type bit-compatible with C99 complex */
59#if !defined(FFTW_NO_Complex) && defined(_Complex_I) && defined(complex) && defined(I)
60# define FFTW_DEFINE_COMPLEX(R, C) typedef R _Complex C
61#else
62# define FFTW_DEFINE_COMPLEX(R, C) typedef R C[2]
63#endif
64
65#define FFTW_CONCAT(prefix, name) prefix ## name
66#define FFTW_MANGLE_DOUBLE(name) FFTW_CONCAT(fftw_, name)
67#define FFTW_MANGLE_FLOAT(name) FFTW_CONCAT(fftwf_, name)
68#define FFTW_MANGLE_LONG_DOUBLE(name) FFTW_CONCAT(fftwl_, name)
69#define FFTW_MANGLE_QUAD(name) FFTW_CONCAT(fftwq_, name)
70
71/* IMPORTANT: for Windows compilers, you should add a line
72 #define FFTW_DLL
73 here and in kernel/ifftw.h if you are compiling/using FFTW as a
74 DLL, in order to do the proper importing/exporting, or
75 alternatively compile with -DFFTW_DLL or the equivalent
76 command-line flag. This is not necessary under MinGW/Cygwin, where
77 libtool does the imports/exports automatically. */
78#if defined(FFTW_DLL) && (defined(_WIN32) || defined(__WIN32__))
79 /* annoying Windows syntax for shared-library declarations */
80# if defined(COMPILING_FFTW) /* defined in api.h when compiling FFTW */
81# define FFTW_EXTERN extern __declspec(dllexport)
82# else /* user is calling FFTW; import symbol */
83# define FFTW_EXTERN extern __declspec(dllimport)
84# endif
85#else
86# define FFTW_EXTERN extern
87#endif
88
89enum fftw_r2r_kind_do_not_use_me {
90 FFTW_R2HC=0, FFTW_HC2R=1, FFTW_DHT=2,
91 FFTW_REDFT00=3, FFTW_REDFT01=4, FFTW_REDFT10=5, FFTW_REDFT11=6,
92 FFTW_RODFT00=7, FFTW_RODFT01=8, FFTW_RODFT10=9, FFTW_RODFT11=10
93};
94
95struct fftw_iodim_do_not_use_me {
96 int n; /* dimension size */
97 int is; /* input stride */
98 int os; /* output stride */
99};
100
101#include <stddef.h> /* for ptrdiff_t */
102struct fftw_iodim64_do_not_use_me {
103 ptrdiff_t n; /* dimension size */
104 ptrdiff_t is; /* input stride */
105 ptrdiff_t os; /* output stride */
106};
107
108typedef void (*fftw_write_char_func_do_not_use_me)(char c, void *);
109typedef int (*fftw_read_char_func_do_not_use_me)(void *);
110
111/*
112 huge second-order macro that defines prototypes for all API
113 functions. We expand this macro for each supported precision
114
115 X: name-mangling macro
116 R: real data type
117 C: complex data type
118*/
119
120#define FFTW_DEFINE_API(X, R, C) \
121 \
122FFTW_DEFINE_COMPLEX(R, C); \
123 \
124typedef struct X(plan_s) *X(plan); \
125 \
126typedef struct fftw_iodim_do_not_use_me X(iodim); \
127typedef struct fftw_iodim64_do_not_use_me X(iodim64); \
128 \
129typedef enum fftw_r2r_kind_do_not_use_me X(r2r_kind); \
130 \
131typedef fftw_write_char_func_do_not_use_me X(write_char_func); \
132typedef fftw_read_char_func_do_not_use_me X(read_char_func); \
133 \
134FFTW_EXTERN void X(execute)(const X(plan) p); \
135 \
136FFTW_EXTERN X(plan) X(plan_dft)(int rank, const int *n, \
137 C *in, C *out, int sign, unsigned flags); \
138 \
139FFTW_EXTERN X(plan) X(plan_dft_1d)(int n, C *in, C *out, int sign, \
140 unsigned flags); \
141FFTW_EXTERN X(plan) X(plan_dft_2d)(int n0, int n1, \
142 C *in, C *out, int sign, unsigned flags); \
143FFTW_EXTERN X(plan) X(plan_dft_3d)(int n0, int n1, int n2, \
144 C *in, C *out, int sign, unsigned flags); \
145 \
146FFTW_EXTERN X(plan) X(plan_many_dft)(int rank, const int *n, \
147 int howmany, \
148 C *in, const int *inembed, \
149 int istride, int idist, \
150 C *out, const int *onembed, \
151 int ostride, int odist, \
152 int sign, unsigned flags); \
153 \
154FFTW_EXTERN X(plan) X(plan_guru_dft)(int rank, const X(iodim) *dims, \
155 int howmany_rank, \
156 const X(iodim) *howmany_dims, \
157 C *in, C *out, \
158 int sign, unsigned flags); \
159FFTW_EXTERN X(plan) X(plan_guru_split_dft)(int rank, const X(iodim) *dims, \
160 int howmany_rank, \
161 const X(iodim) *howmany_dims, \
162 R *ri, R *ii, R *ro, R *io, \
163 unsigned flags); \
164 \
165FFTW_EXTERN X(plan) X(plan_guru64_dft)(int rank, \
166 const X(iodim64) *dims, \
167 int howmany_rank, \
168 const X(iodim64) *howmany_dims, \
169 C *in, C *out, \
170 int sign, unsigned flags); \
171FFTW_EXTERN X(plan) X(plan_guru64_split_dft)(int rank, \
172 const X(iodim64) *dims, \
173 int howmany_rank, \
174 const X(iodim64) *howmany_dims, \
175 R *ri, R *ii, R *ro, R *io, \
176 unsigned flags); \
177 \
178FFTW_EXTERN void X(execute_dft)(const X(plan) p, C *in, C *out); \
179FFTW_EXTERN void X(execute_split_dft)(const X(plan) p, R *ri, R *ii, \
180 R *ro, R *io); \
181 \
182FFTW_EXTERN X(plan) X(plan_many_dft_r2c)(int rank, const int *n, \
183 int howmany, \
184 R *in, const int *inembed, \
185 int istride, int idist, \
186 C *out, const int *onembed, \
187 int ostride, int odist, \
188 unsigned flags); \
189 \
190FFTW_EXTERN X(plan) X(plan_dft_r2c)(int rank, const int *n, \
191 R *in, C *out, unsigned flags); \
192 \
193FFTW_EXTERN X(plan) X(plan_dft_r2c_1d)(int n,R *in,C *out,unsigned flags); \
194FFTW_EXTERN X(plan) X(plan_dft_r2c_2d)(int n0, int n1, \
195 R *in, C *out, unsigned flags); \
196FFTW_EXTERN X(plan) X(plan_dft_r2c_3d)(int n0, int n1, \
197 int n2, \
198 R *in, C *out, unsigned flags); \
199 \
200 \
201FFTW_EXTERN X(plan) X(plan_many_dft_c2r)(int rank, const int *n, \
202 int howmany, \
203 C *in, const int *inembed, \
204 int istride, int idist, \
205 R *out, const int *onembed, \
206 int ostride, int odist, \
207 unsigned flags); \
208 \
209FFTW_EXTERN X(plan) X(plan_dft_c2r)(int rank, const int *n, \
210 C *in, R *out, unsigned flags); \
211 \
212FFTW_EXTERN X(plan) X(plan_dft_c2r_1d)(int n,C *in,R *out,unsigned flags); \
213FFTW_EXTERN X(plan) X(plan_dft_c2r_2d)(int n0, int n1, \
214 C *in, R *out, unsigned flags); \
215FFTW_EXTERN X(plan) X(plan_dft_c2r_3d)(int n0, int n1, \
216 int n2, \
217 C *in, R *out, unsigned flags); \
218 \
219FFTW_EXTERN X(plan) X(plan_guru_dft_r2c)(int rank, const X(iodim) *dims, \
220 int howmany_rank, \
221 const X(iodim) *howmany_dims, \
222 R *in, C *out, \
223 unsigned flags); \
224FFTW_EXTERN X(plan) X(plan_guru_dft_c2r)(int rank, const X(iodim) *dims, \
225 int howmany_rank, \
226 const X(iodim) *howmany_dims, \
227 C *in, R *out, \
228 unsigned flags); \
229 \
230FFTW_EXTERN X(plan) X(plan_guru_split_dft_r2c)( \
231 int rank, const X(iodim) *dims, \
232 int howmany_rank, \
233 const X(iodim) *howmany_dims, \
234 R *in, R *ro, R *io, \
235 unsigned flags); \
236FFTW_EXTERN X(plan) X(plan_guru_split_dft_c2r)( \
237 int rank, const X(iodim) *dims, \
238 int howmany_rank, \
239 const X(iodim) *howmany_dims, \
240 R *ri, R *ii, R *out, \
241 unsigned flags); \
242 \
243FFTW_EXTERN X(plan) X(plan_guru64_dft_r2c)(int rank, \
244 const X(iodim64) *dims, \
245 int howmany_rank, \
246 const X(iodim64) *howmany_dims, \
247 R *in, C *out, \
248 unsigned flags); \
249FFTW_EXTERN X(plan) X(plan_guru64_dft_c2r)(int rank, \
250 const X(iodim64) *dims, \
251 int howmany_rank, \
252 const X(iodim64) *howmany_dims, \
253 C *in, R *out, \
254 unsigned flags); \
255 \
256FFTW_EXTERN X(plan) X(plan_guru64_split_dft_r2c)( \
257 int rank, const X(iodim64) *dims, \
258 int howmany_rank, \
259 const X(iodim64) *howmany_dims, \
260 R *in, R *ro, R *io, \
261 unsigned flags); \
262FFTW_EXTERN X(plan) X(plan_guru64_split_dft_c2r)( \
263 int rank, const X(iodim64) *dims, \
264 int howmany_rank, \
265 const X(iodim64) *howmany_dims, \
266 R *ri, R *ii, R *out, \
267 unsigned flags); \
268 \
269FFTW_EXTERN void X(execute_dft_r2c)(const X(plan) p, R *in, C *out); \
270FFTW_EXTERN void X(execute_dft_c2r)(const X(plan) p, C *in, R *out); \
271 \
272FFTW_EXTERN void X(execute_split_dft_r2c)(const X(plan) p, \
273 R *in, R *ro, R *io); \
274FFTW_EXTERN void X(execute_split_dft_c2r)(const X(plan) p, \
275 R *ri, R *ii, R *out); \
276 \
277FFTW_EXTERN X(plan) X(plan_many_r2r)(int rank, const int *n, \
278 int howmany, \
279 R *in, const int *inembed, \
280 int istride, int idist, \
281 R *out, const int *onembed, \
282 int ostride, int odist, \
283 const X(r2r_kind) *kind, unsigned flags); \
284 \
285FFTW_EXTERN X(plan) X(plan_r2r)(int rank, const int *n, R *in, R *out, \
286 const X(r2r_kind) *kind, unsigned flags); \
287 \
288FFTW_EXTERN X(plan) X(plan_r2r_1d)(int n, R *in, R *out, \
289 X(r2r_kind) kind, unsigned flags); \
290FFTW_EXTERN X(plan) X(plan_r2r_2d)(int n0, int n1, R *in, R *out, \
291 X(r2r_kind) kind0, X(r2r_kind) kind1, \
292 unsigned flags); \
293FFTW_EXTERN X(plan) X(plan_r2r_3d)(int n0, int n1, int n2, \
294 R *in, R *out, X(r2r_kind) kind0, \
295 X(r2r_kind) kind1, X(r2r_kind) kind2, \
296 unsigned flags); \
297 \
298FFTW_EXTERN X(plan) X(plan_guru_r2r)(int rank, const X(iodim) *dims, \
299 int howmany_rank, \
300 const X(iodim) *howmany_dims, \
301 R *in, R *out, \
302 const X(r2r_kind) *kind, unsigned flags); \
303 \
304FFTW_EXTERN X(plan) X(plan_guru64_r2r)(int rank, const X(iodim64) *dims, \
305 int howmany_rank, \
306 const X(iodim64) *howmany_dims, \
307 R *in, R *out, \
308 const X(r2r_kind) *kind, unsigned flags); \
309 \
310FFTW_EXTERN void X(execute_r2r)(const X(plan) p, R *in, R *out); \
311 \
312FFTW_EXTERN void X(destroy_plan)(X(plan) p); \
313FFTW_EXTERN void X(forget_wisdom)(void); \
314FFTW_EXTERN void X(cleanup)(void); \
315 \
316FFTW_EXTERN void X(set_timelimit)(double t); \
317 \
318FFTW_EXTERN void X(plan_with_nthreads)(int nthreads); \
319FFTW_EXTERN int X(init_threads)(void); \
320FFTW_EXTERN void X(cleanup_threads)(void); \
321 \
322FFTW_EXTERN int X(export_wisdom_to_filename)(const char *filename); \
323FFTW_EXTERN void X(export_wisdom_to_file)(FILE *output_file); \
324FFTW_EXTERN char *X(export_wisdom_to_string)(void); \
325FFTW_EXTERN void X(export_wisdom)(X(write_char_func) write_char, \
326 void *data); \
327FFTW_EXTERN int X(import_system_wisdom)(void); \
328FFTW_EXTERN int X(import_wisdom_from_filename)(const char *filename); \
329FFTW_EXTERN int X(import_wisdom_from_file)(FILE *input_file); \
330FFTW_EXTERN int X(import_wisdom_from_string)(const char *input_string); \
331FFTW_EXTERN int X(import_wisdom)(X(read_char_func) read_char, void *data); \
332 \
333FFTW_EXTERN void X(fprint_plan)(const X(plan) p, FILE *output_file); \
334FFTW_EXTERN void X(print_plan)(const X(plan) p); \
335FFTW_EXTERN char *X(sprint_plan)(const X(plan) p); \
336 \
337FFTW_EXTERN void *X(malloc)(size_t n); \
338FFTW_EXTERN R *X(alloc_real)(size_t n); \
339FFTW_EXTERN C *X(alloc_complex)(size_t n); \
340FFTW_EXTERN void X(free)(void *p); \
341 \
342FFTW_EXTERN void X(flops)(const X(plan) p, \
343 double *add, double *mul, double *fmas); \
344FFTW_EXTERN double X(estimate_cost)(const X(plan) p); \
345FFTW_EXTERN double X(cost)(const X(plan) p); \
346 \
347FFTW_EXTERN int X(alignment_of)(R *p); \
348FFTW_EXTERN const char X(version)[]; \
349FFTW_EXTERN const char X(cc)[]; \
350FFTW_EXTERN const char X(codelet_optim)[];
351
352
353/* end of FFTW_DEFINE_API macro */
354
355FFTW_DEFINE_API(FFTW_MANGLE_DOUBLE, double, fftw_complex)
356FFTW_DEFINE_API(FFTW_MANGLE_FLOAT, float, fftwf_complex)
357FFTW_DEFINE_API(FFTW_MANGLE_LONG_DOUBLE, long double, fftwl_complex)
358
359/* __float128 (quad precision) is a gcc extension on i386, x86_64, and ia64
360 for gcc >= 4.6 (compiled in FFTW with --enable-quad-precision) */
361#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) \
362 && !(defined(__ICC) || defined(__INTEL_COMPILER)) \
363 && (defined(__i386__) || defined(__x86_64__) || defined(__ia64__))
364# if !defined(FFTW_NO_Complex) && defined(_Complex_I) && defined(complex) && defined(I)
365/* note: __float128 is a typedef, which is not supported with the _Complex
366 keyword in gcc, so instead we use this ugly __attribute__ version.
367 However, we can't simply pass the __attribute__ version to
368 FFTW_DEFINE_API because the __attribute__ confuses gcc in pointer
369 types. Hence redefining FFTW_DEFINE_COMPLEX. Ugh. */
370# undef FFTW_DEFINE_COMPLEX
371# define FFTW_DEFINE_COMPLEX(R, C) typedef _Complex float __attribute__((mode(TC))) C
372# endif
373FFTW_DEFINE_API(FFTW_MANGLE_QUAD, __float128, fftwq_complex)
374#endif
375
376#define FFTW_FORWARD (-1)
377#define FFTW_BACKWARD (+1)
378
379#define FFTW_NO_TIMELIMIT (-1.0)
380
381/* documented flags */
382#define FFTW_MEASURE (0U)
383#define FFTW_DESTROY_INPUT (1U << 0)
384#define FFTW_UNALIGNED (1U << 1)
385#define FFTW_CONSERVE_MEMORY (1U << 2)
386#define FFTW_EXHAUSTIVE (1U << 3) /* NO_EXHAUSTIVE is default */
387#define FFTW_PRESERVE_INPUT (1U << 4) /* cancels FFTW_DESTROY_INPUT */
388#define FFTW_PATIENT (1U << 5) /* IMPATIENT is default */
389#define FFTW_ESTIMATE (1U << 6)
390#define FFTW_WISDOM_ONLY (1U << 21)
391
392/* undocumented beyond-guru flags */
393#define FFTW_ESTIMATE_PATIENT (1U << 7)
394#define FFTW_BELIEVE_PCOST (1U << 8)
395#define FFTW_NO_DFT_R2HC (1U << 9)
396#define FFTW_NO_NONTHREADED (1U << 10)
397#define FFTW_NO_BUFFERING (1U << 11)
398#define FFTW_NO_INDIRECT_OP (1U << 12)
399#define FFTW_ALLOW_LARGE_GENERIC (1U << 13) /* NO_LARGE_GENERIC is default */
400#define FFTW_NO_RANK_SPLITS (1U << 14)
401#define FFTW_NO_VRANK_SPLITS (1U << 15)
402#define FFTW_NO_VRECURSE (1U << 16)
403#define FFTW_NO_SIMD (1U << 17)
404#define FFTW_NO_SLOW (1U << 18)
405#define FFTW_NO_FIXED_RADIX_LARGE_N (1U << 19)
406#define FFTW_ALLOW_PRUNING (1U << 20)
407
408#ifdef __cplusplus
409} /* extern "C" */
410#endif /* __cplusplus */
411
412#endif /* FFTW3_H */
413