Mercurial > hg > sv-dependency-builds

comparison osx/include/fftw3.h @ 32:0b732c03ec57

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
FFTW
author Chris Cannam
date Fri, 04 Jul 2014 10:36:59 +0100
parents
children 879bdc878826
comparison
equal deleted inserted replaced
31:642a72ce5e62 32:0b732c03ec57
1 /*
2 * Copyright (c) 2003, 2007-11 Matteo Frigo
3 * Copyright (c) 2003, 2007-11 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
53 extern "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
89 enum 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
95 struct 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 */
102 struct 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
108 typedef void (*fftw_write_char_func_do_not_use_me)(char c, void *);
109 typedef 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 \
122 FFTW_DEFINE_COMPLEX(R, C); \
123 \
124 typedef struct X(plan_s) *X(plan); \
125 \
126 typedef struct fftw_iodim_do_not_use_me X(iodim); \
127 typedef struct fftw_iodim64_do_not_use_me X(iodim64); \
128 \
129 typedef enum fftw_r2r_kind_do_not_use_me X(r2r_kind); \
130 \
131 typedef fftw_write_char_func_do_not_use_me X(write_char_func); \
132 typedef fftw_read_char_func_do_not_use_me X(read_char_func); \
133 \
134 FFTW_EXTERN void X(execute)(const X(plan) p); \
135 \
136 FFTW_EXTERN X(plan) X(plan_dft)(int rank, const int *n, \
137 C *in, C *out, int sign, unsigned flags); \
138 \
139 FFTW_EXTERN X(plan) X(plan_dft_1d)(int n, C *in, C *out, int sign, \
140 unsigned flags); \
141 FFTW_EXTERN X(plan) X(plan_dft_2d)(int n0, int n1, \
142 C *in, C *out, int sign, unsigned flags); \
143 FFTW_EXTERN X(plan) X(plan_dft_3d)(int n0, int n1, int n2, \
144 C *in, C *out, int sign, unsigned flags); \
145 \
146 FFTW_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 \
154 FFTW_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); \
159 FFTW_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 \
165 FFTW_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); \
171 FFTW_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 \
178 FFTW_EXTERN void X(execute_dft)(const X(plan) p, C *in, C *out); \
179 FFTW_EXTERN void X(execute_split_dft)(const X(plan) p, R *ri, R *ii, \
180 R *ro, R *io); \
181 \
182 FFTW_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 \
190 FFTW_EXTERN X(plan) X(plan_dft_r2c)(int rank, const int *n, \
191 R *in, C *out, unsigned flags); \
192 \
193 FFTW_EXTERN X(plan) X(plan_dft_r2c_1d)(int n,R *in,C *out,unsigned flags); \
194 FFTW_EXTERN X(plan) X(plan_dft_r2c_2d)(int n0, int n1, \
195 R *in, C *out, unsigned flags); \
196 FFTW_EXTERN X(plan) X(plan_dft_r2c_3d)(int n0, int n1, \
197 int n2, \
198 R *in, C *out, unsigned flags); \
199 \
200 \
201 FFTW_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 \
209 FFTW_EXTERN X(plan) X(plan_dft_c2r)(int rank, const int *n, \
210 C *in, R *out, unsigned flags); \
211 \
212 FFTW_EXTERN X(plan) X(plan_dft_c2r_1d)(int n,C *in,R *out,unsigned flags); \
213 FFTW_EXTERN X(plan) X(plan_dft_c2r_2d)(int n0, int n1, \
214 C *in, R *out, unsigned flags); \
215 FFTW_EXTERN X(plan) X(plan_dft_c2r_3d)(int n0, int n1, \
216 int n2, \
217 C *in, R *out, unsigned flags); \
218 \
219 FFTW_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); \
224 FFTW_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 \
230 FFTW_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); \
236 FFTW_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 \
243 FFTW_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); \
249 FFTW_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 \
256 FFTW_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); \
262 FFTW_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 \
269 FFTW_EXTERN void X(execute_dft_r2c)(const X(plan) p, R *in, C *out); \
270 FFTW_EXTERN void X(execute_dft_c2r)(const X(plan) p, C *in, R *out); \
271 \
272 FFTW_EXTERN void X(execute_split_dft_r2c)(const X(plan) p, \
273 R *in, R *ro, R *io); \
274 FFTW_EXTERN void X(execute_split_dft_c2r)(const X(plan) p, \
275 R *ri, R *ii, R *out); \
276 \
277 FFTW_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 \
285 FFTW_EXTERN X(plan) X(plan_r2r)(int rank, const int *n, R *in, R *out, \
286 const X(r2r_kind) *kind, unsigned flags); \
287 \
288 FFTW_EXTERN X(plan) X(plan_r2r_1d)(int n, R *in, R *out, \
289 X(r2r_kind) kind, unsigned flags); \
290 FFTW_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); \
293 FFTW_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 \
298 FFTW_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 \
304 FFTW_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 \
310 FFTW_EXTERN void X(execute_r2r)(const X(plan) p, R *in, R *out); \
311 \
312 FFTW_EXTERN void X(destroy_plan)(X(plan) p); \
313 FFTW_EXTERN void X(forget_wisdom)(void); \
314 FFTW_EXTERN void X(cleanup)(void); \
315 \
316 FFTW_EXTERN void X(set_timelimit)(double t); \
317 \
318 FFTW_EXTERN void X(plan_with_nthreads)(int nthreads); \
319 FFTW_EXTERN int X(init_threads)(void); \
320 FFTW_EXTERN void X(cleanup_threads)(void); \
321 \
322 FFTW_EXTERN int X(export_wisdom_to_filename)(const char *filename); \
323 FFTW_EXTERN void X(export_wisdom_to_file)(FILE *output_file); \
324 FFTW_EXTERN char *X(export_wisdom_to_string)(void); \
325 FFTW_EXTERN void X(export_wisdom)(X(write_char_func) write_char, \
326 void *data); \
327 FFTW_EXTERN int X(import_system_wisdom)(void); \
328 FFTW_EXTERN int X(import_wisdom_from_filename)(const char *filename); \
329 FFTW_EXTERN int X(import_wisdom_from_file)(FILE *input_file); \
330 FFTW_EXTERN int X(import_wisdom_from_string)(const char *input_string); \
331 FFTW_EXTERN int X(import_wisdom)(X(read_char_func) read_char, void *data); \
332 \
333 FFTW_EXTERN void X(fprint_plan)(const X(plan) p, FILE *output_file); \
334 FFTW_EXTERN void X(print_plan)(const X(plan) p); \
335 \
336 FFTW_EXTERN void *X(malloc)(size_t n); \
337 FFTW_EXTERN R *X(alloc_real)(size_t n); \
338 FFTW_EXTERN C *X(alloc_complex)(size_t n); \
339 FFTW_EXTERN void X(free)(void *p); \
340 \
341 FFTW_EXTERN void X(flops)(const X(plan) p, \
342 double *add, double *mul, double *fmas); \
343 FFTW_EXTERN double X(estimate_cost)(const X(plan) p); \
344 FFTW_EXTERN double X(cost)(const X(plan) p); \
345 \
346 FFTW_EXTERN const char X(version)[]; \
347 FFTW_EXTERN const char X(cc)[]; \
348 FFTW_EXTERN const char X(codelet_optim)[];
349
350
351 /* end of FFTW_DEFINE_API macro */
352
353 FFTW_DEFINE_API(FFTW_MANGLE_DOUBLE, double, fftw_complex)
354 FFTW_DEFINE_API(FFTW_MANGLE_FLOAT, float, fftwf_complex)
355 FFTW_DEFINE_API(FFTW_MANGLE_LONG_DOUBLE, long double, fftwl_complex)
356
357 /* __float128 (quad precision) is a gcc extension on i386, x86_64, and ia64
358 for gcc >= 4.6 (compiled in FFTW with --enable-quad-precision) */
359 #if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) \
360 && !(defined(__ICC) || defined(__INTEL_COMPILER)) \
361 && (defined(__i386__) || defined(__x86_64__) || defined(__ia64__))
362 # if !defined(FFTW_NO_Complex) && defined(_Complex_I) && defined(complex) && defined(I)
363 /* note: __float128 is a typedef, which is not supported with the _Complex
364 keyword in gcc, so instead we use this ugly __attribute__ version.
365 However, we can't simply pass the __attribute__ version to
366 FFTW_DEFINE_API because the __attribute__ confuses gcc in pointer
367 types. Hence redefining FFTW_DEFINE_COMPLEX. Ugh. */
368 # undef FFTW_DEFINE_COMPLEX
369 # define FFTW_DEFINE_COMPLEX(R, C) typedef _Complex float __attribute__((mode(TC))) C
370 # endif
371 FFTW_DEFINE_API(FFTW_MANGLE_QUAD, __float128, fftwq_complex)
372 #endif
373
374 #define FFTW_FORWARD (-1)
375 #define FFTW_BACKWARD (+1)
376
377 #define FFTW_NO_TIMELIMIT (-1.0)
378
379 /* documented flags */
380 #define FFTW_MEASURE (0U)
381 #define FFTW_DESTROY_INPUT (1U << 0)
382 #define FFTW_UNALIGNED (1U << 1)
383 #define FFTW_CONSERVE_MEMORY (1U << 2)
384 #define FFTW_EXHAUSTIVE (1U << 3) /* NO_EXHAUSTIVE is default */
385 #define FFTW_PRESERVE_INPUT (1U << 4) /* cancels FFTW_DESTROY_INPUT */
386 #define FFTW_PATIENT (1U << 5) /* IMPATIENT is default */
387 #define FFTW_ESTIMATE (1U << 6)
388 #define FFTW_WISDOM_ONLY (1U << 21)
389
390 /* undocumented beyond-guru flags */
391 #define FFTW_ESTIMATE_PATIENT (1U << 7)
392 #define FFTW_BELIEVE_PCOST (1U << 8)
393 #define FFTW_NO_DFT_R2HC (1U << 9)
394 #define FFTW_NO_NONTHREADED (1U << 10)
395 #define FFTW_NO_BUFFERING (1U << 11)
396 #define FFTW_NO_INDIRECT_OP (1U << 12)
397 #define FFTW_ALLOW_LARGE_GENERIC (1U << 13) /* NO_LARGE_GENERIC is default */
398 #define FFTW_NO_RANK_SPLITS (1U << 14)
399 #define FFTW_NO_VRANK_SPLITS (1U << 15)
400 #define FFTW_NO_VRECURSE (1U << 16)
401 #define FFTW_NO_SIMD (1U << 17)
402 #define FFTW_NO_SLOW (1U << 18)
403 #define FFTW_NO_FIXED_RADIX_LARGE_N (1U << 19)
404 #define FFTW_ALLOW_PRUNING (1U << 20)
405
406 #ifdef __cplusplus
407 } /* extern "C" */
408 #endif /* __cplusplus */
409
410 #endif /* FFTW3_H */