| Bsoft 1.9 Bernard's software package

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

fftw-int.h
Go to the documentation of this file.
1 /*
2 * Copyright (c) 1997-1999, 2003 Massachusetts Institute of Technology
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 *
18 */
19
20 /* fftw.h -- system-wide definitions */
21 /* $Id: fftw-int.h,v 1.54 2003/03/16 23:43:46 stevenj Exp $ */
22
23 #ifndef FFTW_INT_H
24 #define FFTW_INT_H
25 #include "config.h"
26 #include "fftw.h"
27
28 #ifdef __cplusplus
29 extern "C" {
30 #endif /* __cplusplus */
31
32 /****************************************************************************/
33 /* Private Functions */
34 /****************************************************************************/
35
36 extern fftw_twiddle *fftw_create_twiddle(int n, const fftw_codelet_desc *d);
37 extern void fftw_destroy_twiddle(fftw_twiddle *tw);
38
39 extern void fftw_strided_copy(int, fftw_complex *, int, fftw_complex *);
40 extern void fftw_executor_simple(int, const fftw_complex *, fftw_complex *,
41 fftw_plan_node *, int, int,
42 fftw_recurse_kind recurse_kind);
43
44 extern fftwnd_plan fftwnd_create_plan_aux(int rank, const int *n,
45 fftw_direction dir, int flags);
46 extern fftw_plan *fftwnd_new_plan_array(int rank);
47 extern fftw_plan *fftwnd_create_plans_generic(fftw_plan *plans,
48 int rank, const int *n,
49 fftw_direction dir, int flags);
50 extern fftw_plan *fftwnd_create_plans_specific(fftw_plan *plans,
51 int rank, const int *n,
52 const int *n_after,
53 fftw_direction dir, int flags,
54 fftw_complex *in, int istride,
55 fftw_complex *out, int ostride);
56 extern int fftwnd_work_size(int rank, const int *n, int flags, int ncopies);
57
58 extern void fftwnd_aux(fftwnd_plan p, int cur_dim,
59 fftw_complex *in, int istride,
60 fftw_complex *out, int ostride,
61 fftw_complex *work);
62 extern void fftwnd_aux_howmany(fftwnd_plan p, int cur_dim,
63 int howmany,
64 fftw_complex *in, int istride, int idist,
65 fftw_complex *out, int ostride, int odist,
66 fftw_complex *work);
67
68 /* wisdom prototypes */
69 enum fftw_wisdom_category {
70 FFTW_WISDOM, RFFTW_WISDOM
71 };
72
73 extern int fftw_wisdom_lookup(int n, int flags, fftw_direction dir,
74 enum fftw_wisdom_category category,
75 int istride, int ostride,
76 enum fftw_node_type *type,
77 int *signature,
78 fftw_recurse_kind *recurse_kind, int replace_p);
79 extern void fftw_wisdom_add(int n, int flags, fftw_direction dir,
80 enum fftw_wisdom_category cat,
81 int istride, int ostride,
82 enum fftw_node_type type,
83 int signature,
84 fftw_recurse_kind recurse_kind);
85
86 /* Private planner functions: */
87 extern double fftw_estimate_node(fftw_plan_node *p);
88 extern fftw_plan_node *fftw_make_node_notw(int size,
89 const fftw_codelet_desc *config);
90 extern fftw_plan_node *fftw_make_node_real2hc(int size,
91 const fftw_codelet_desc *config);
92 extern fftw_plan_node *fftw_make_node_hc2real(int size,
93 const fftw_codelet_desc *config);
94 extern fftw_plan_node *fftw_make_node_twiddle(int n,
95 const fftw_codelet_desc *config,
96 fftw_plan_node *recurse,
97 int flags);
98 extern fftw_plan_node *fftw_make_node_hc2hc(int n,
99 fftw_direction dir,
100 const fftw_codelet_desc *config,
101 fftw_plan_node *recurse,
102 int flags);
103 extern fftw_plan_node *fftw_make_node_generic(int n, int size,
104 fftw_generic_codelet *codelet,
105 fftw_plan_node *recurse,
106 int flags);
107 extern fftw_plan_node *fftw_make_node_rgeneric(int n, int size,
108 fftw_direction dir,
109 fftw_rgeneric_codelet * codelet,
110 fftw_plan_node *recurse,
111 int flags);
112 extern int fftw_factor(int n);
113 extern fftw_plan_node *fftw_make_node(void);
114 extern fftw_plan fftw_make_plan(int n, fftw_direction dir,
115 fftw_plan_node *root, int flags,
116 enum fftw_node_type wisdom_type,
117 int wisdom_signature,
118 fftw_recurse_kind recurse_kind,
119 int vector_size);
120 extern void fftw_use_plan(fftw_plan p);
121 extern void fftw_use_node(fftw_plan_node *p);
122 extern void fftw_destroy_plan_internal(fftw_plan p);
123 extern fftw_plan fftw_pick_better(fftw_plan p1, fftw_plan p2);
124 extern fftw_plan fftw_lookup(fftw_plan *table, int n, int flags,
125 int vector_size);
126 extern void fftw_insert(fftw_plan *table, fftw_plan this_plan);
127 extern void fftw_make_empty_table(fftw_plan *table);
128 extern void fftw_destroy_table(fftw_plan *table);
129 extern void fftw_complete_twiddle(fftw_plan_node *p, int n);
130
131 extern fftw_plan_node *fftw_make_node_rader(int n, int size,
132 fftw_direction dir,
133 fftw_plan_node *recurse,
134 int flags);
135 extern fftw_rader_data *fftw_rader_top;
136
137 /* undocumented debugging hook */
138 typedef void (*fftw_plan_hook_ptr) (fftw_plan plan);
139 extern DL_IMPORT(fftw_plan_hook_ptr) fftw_plan_hook;
140 extern DL_IMPORT(fftw_plan_hook_ptr) rfftw_plan_hook;
141
142 /****************************************************************************/
143 /* Overflow-safe multiply */
144 /****************************************************************************/
145
146 /* The Rader routines do a lot of operations of the form (x * y) % p, which
147 are vulnerable to overflow problems for large p. To get around this,
148 we either use "long long" arithmetic (if it is available and double
149 the size of int), or default to a subroutine defined in twiddle.c. */
150
151 #if defined(FFTW_ENABLE_UNSAFE_MULMOD)
152 # define MULMOD(x,y,p) (((x) * (y)) % (p))
153 #elif defined(LONGLONG_IS_TWOINTS)
154 # define MULMOD(x,y,p) ((int) ((((long long) (x)) * ((long long) (y))) \
155 % ((long long) (p))))
156 #else
157 # define USE_FFTW_SAFE_MULMOD
158 # define MULMOD(x,y,p) fftw_safe_mulmod(x,y,p)
159 extern int fftw_safe_mulmod(int x, int y, int p);
160 #endif
161
162 /****************************************************************************/
163 /* Floating Point Types */
164 /****************************************************************************/
165
166 /*
167 * We use these definitions to make it easier for people to change
168 * FFTW to use long double and similar types. You shouldn't have to
169 * change this just to use float or double.
170 */
171
172 /*
173 * Change this if your floating-point constants need to be expressed
174 * in a special way. For example, if fftw_real is long double, you
175 * will need to append L to your fp constants to make them of the
176 * same precision. Do this by changing "x" below to "x##L".
177 */
178 #define FFTW_KONST(x) ((fftw_real) x)
179
180 /*
181 * Ordinarily, we use the standard sin/cos functions to compute trig.
182 * constants. You'll need to change these if fftw_real has more
183 * than double precision.
184 */
185 #define FFTW_TRIG_SIN sin
186 #define FFTW_TRIG_COS cos
187 typedef double FFTW_TRIG_REAL; /* the argument type for sin and cos */
188
189 #define FFTW_K2PI FFTW_KONST(6.2831853071795864769252867665590057683943388)
190
191 /****************************************************************************/
192 /* gcc/x86 hacks */
193 /****************************************************************************/
194
195 /*
196 * gcc 2.[78].x and x86 specific hacks. These macros align the stack
197 * pointer so that the double precision temporary variables in the
198 * codelets will be aligned to a multiple of 8 bytes (*way* faster on
199 * pentium and pentiumpro)
200 */
201 #ifdef __GNUC__
202 # ifdef __i386__
203 # ifdef FFTW_ENABLE_I386_HACKS
204 # ifndef FFTW_GCC_ALIGNS_STACK
205 # ifndef FFTW_ENABLE_FLOAT
206 # define FFTW_USING_I386_HACKS
207 # define HACK_ALIGN_STACK_EVEN { \
208 if ((((long) (__builtin_alloca(0))) & 0x7)) __builtin_alloca(4); \
209 }
210
211 # define HACK_ALIGN_STACK_ODD { \
212 if (!(((long) (__builtin_alloca(0))) & 0x7)) __builtin_alloca(4); \
213 }
214
215 # endif /* ! FFTW_ENABLE_FLOAT */
216 # endif /* ! FFTW_GCC_ALIGNS_STACK */
217 # endif /* FFTW_ENABLE_I386_HACKS */
218
219 # ifdef FFTW_DEBUG_ALIGNMENT
220 # define ASSERT_ALIGNED_DOUBLE { \
221 double __foo; \
222 if ((((long) &__foo) & 0x7)) abort(); \
223 }
224 # endif /* FFTW_DEBUG_ALIGNMENT */
225
226 # endif /* __i386__ */
227 #endif /* __GNUC__ */
228
229 #ifndef HACK_ALIGN_STACK_EVEN
230 # define HACK_ALIGN_STACK_EVEN {}
231 #endif
232 #ifndef HACK_ALIGN_STACK_ODD
233 # define HACK_ALIGN_STACK_ODD {}
234 #endif
235 #ifndef ASSERT_ALIGNED_DOUBLE
236 # define ASSERT_ALIGNED_DOUBLE {}
237 #endif
238
239 /****************************************************************************/
240 /* Timers */
241 /****************************************************************************/
242
243 /*
244 * Here, you can use all the nice timers available in your machine.
245 */
246
247 /*
248 *
249 Things you should define to include your own clock:
250
251 fftw_time -- the data type used to store a time
252
253 extern fftw_time fftw_get_time(void);
254 -- a function returning the current time. (We have
255 implemented this as a macro in most cases.)
256
257 extern fftw_time fftw_time_diff(fftw_time t1, fftw_time t2);
258 -- returns the time difference (t1 - t2).
259 If t1 < t2, it may simply return zero (although this
260 is not required). (We have implemented this as a macro
261 in most cases.)
262
263 extern double fftw_time_to_sec(fftw_time t);
264 -- returns the time t expressed in seconds, as a double.
265 (Implemented as a macro in most cases.)
266
267 FFTW_TIME_MIN -- a double-precision macro holding the minimum
268 time interval (in seconds) for accurate time measurements.
269 This should probably be at least 100 times the precision of
270 your clock (we use even longer intervals, to be conservative).
271 This will determine how long the planner takes to measure
272 the speeds of different possible plans.
273
274 Bracket all of your definitions with an appropriate #ifdef so that
275 they will be enabled on your machine. If you do add your own
276 high-precision timer code, let us know (at fftw@fftw.org).
277
278 Only declarations should go in this file. Any function definitions
279 that you need should go into timer.c.
280 */
281
282 /*
283 * define a symbol so that we know that we have the fftw_time_diff
284 * function/macro (it did not exist prior to FFTW 1.2)
285 */
286 #define FFTW_HAS_TIME_DIFF
287
288 /**********************************************
289 * SOLARIS
290 **********************************************/
291 #if defined(HAVE_GETHRTIME) && defined(HAVE_HRTIME_T)
292
293 /* we use the nanosecond virtual timer */
294 #ifdef HAVE_SYS_TIME_H
295 #include <sys/time.h>
296 #endif
297
298 typedef hrtime_t fftw_time;
299
300 #define fftw_get_time() gethrtime()
301 #define fftw_time_diff(t1,t2) ((t1) - (t2))
302 #define fftw_time_to_sec(t) ((double) t / 1.0e9)
303
304 /*
305 * a measurement is valid if it runs for at least
306 * FFTW_TIME_MIN seconds.
307 */
308 #define FFTW_TIME_MIN (1.0e-4) /* for Solaris nanosecond timer */
309 #define FFTW_TIME_REPEAT 8
310
311 /**********************************************
312 * Pentium time stamp counter
313 **********************************************/
314 #elif defined(__GNUC__) && defined(__i386__) && defined(FFTW_ENABLE_PENTIUM_TIMER)
315
316 /*
317 * Use internal Pentium register (time stamp counter). Resolution
318 * is 1/FFTW_CYCLES_PER_SEC seconds (e.g. 5 ns for Pentium 200 MHz).
319 * (This code was contributed by Wolfgang Reimer)
320 */
321
322 #ifndef FFTW_CYCLES_PER_SEC
323 #error "Must define FFTW_CYCLES_PER_SEC in fftw/config.h to use the Pentium cycle counter"
324 #endif
325
326 typedef unsigned long long fftw_time;
327
328 static __inline__ fftw_time read_tsc()
329 {
330 fftw_time ret;
331
332 __asm__ __volatile__("rdtsc": "=A" (ret));
333 /* no input, nothing else clobbered */
334 return ret;
335 }
336
337 #define fftw_get_time() read_tsc()
338 #define fftw_time_diff(t1,t2) ((t1) - (t2))
339 #define fftw_time_to_sec(t) (((double) (t)) / FFTW_CYCLES_PER_SEC)
340 #define FFTW_TIME_MIN (1.0e-4) /* for Pentium TSC register */
341
342 /************* generic systems having gettimeofday ************/
343 #elif defined(HAVE_GETTIMEOFDAY) || defined(HAVE_BSDGETTIMEOFDAY)
344 #ifdef HAVE_SYS_TIME_H
345 #include <sys/time.h>
346 #endif
347 #ifdef HAVE_UNISTD_H
348 #include <unistd.h>
349 #endif
350 #define FFTW_USE_GETTIMEOFDAY
351
352 typedef struct timeval fftw_time;
353
354 extern fftw_time fftw_gettimeofday_get_time(void);
355 extern fftw_time fftw_gettimeofday_time_diff(fftw_time t1, fftw_time t2);
356 #define fftw_get_time() fftw_gettimeofday_get_time()
357 #define fftw_time_diff(t1, t2) fftw_gettimeofday_time_diff(t1, t2)
358 #define fftw_time_to_sec(t) ((double)(t).tv_sec + (double)(t).tv_usec * 1.0E-6)
359
360 #ifndef FFTW_TIME_MIN
361 /* this should be fine on any system claiming a microsecond timer */
362 #define FFTW_TIME_MIN (1.0e-2)
363 #endif
364
365 /**********************************************
366 * MACINTOSH
367 **********************************************/
368 #elif defined(HAVE_MAC_TIMER)
369
370 /*
371 * By default, use the microsecond-timer in the Mac Time Manager.
372 * Alternatively, by changing the following #if 1 to #if 0, you
373 * can use the nanosecond timer available *only* on PCI PowerMacs.
374 * WARNING: the nanosecond timer was just a little experiment;
375 * I haven't gotten it to work reliably. Tips/patches are welcome.
376 */
377 #ifndef HAVE_MAC_PCI_TIMER /* use time manager */
378
379 /*
380 * Use Macintosh Time Manager routines (maximum resolution is about 20
381 * microseconds).
382 */
383 typedef struct fftw_time_struct {
384 unsigned long hi, lo;
385 } fftw_time;
386
387 extern fftw_time get_Mac_microseconds(void);
388
389 #define fftw_get_time() get_Mac_microseconds()
390
391 /* define as a function instead of a macro: */
392 extern fftw_time fftw_time_diff(fftw_time t1, fftw_time t2);
393
394 #define fftw_time_to_sec(t) ((t).lo * 1.0e-6 + 4294967295.0e-6 * (t).hi)
395
396 /* very conservative, since timer should be accurate to 20e-6: */
397 /* (although this seems not to be the case in practice) */
398 #define FFTW_TIME_MIN (5.0e-2) /* for MacOS Time Manager timer */
399
400 #else /* use nanosecond timer */
401
402 /* Use the nanosecond timer available on PCI PowerMacs. */
403
404 #include <DriverServices.h>
405
406 typedef AbsoluteTime fftw_time;
407 #define fftw_get_time() UpTime()
408 #define fftw_time_diff(t1,t2) SubAbsoluteFromAbsolute(t1,t2)
409 #define fftw_time_to_sec(t) (AbsoluteToNanoseconds(t).lo * 1.0e-9)
410
411 /* Extremely conservative minimum time: */
412 /* for MacOS PCI PowerMac nanosecond timer */
413 #define FFTW_TIME_MIN (5.0e-3)
414
415 #endif /* use nanosecond timer */
416
417 /**********************************************
418 * WINDOWS
419 **********************************************/
420 #elif defined(HAVE_WIN32_TIMER)
421
422 #include <time.h>
423
424 typedef unsigned long fftw_time;
425 extern unsigned long GetPerfTime(void);
426 extern double GetPerfSec(double ticks);
427
428 #define fftw_get_time() GetPerfTime()
429 #define fftw_time_diff(t1,t2) ((t1) - (t2))
430 #define fftw_time_to_sec(t) GetPerfSec(t)
431
432 #define FFTW_TIME_MIN (5.0e-2) /* for Win32 timer */
433
434 /**********************************************
435 * CRAY
436 **********************************************/
437 #elif defined(_CRAYMPP) /* Cray MPP system */
438
439 double SECONDR(void); /*
440 * I think you have to link with -lsci to
441 * get this
442 */
443
444 typedef double fftw_time;
445 #define fftw_get_time() SECONDR()
446 #define fftw_time_diff(t1,t2) ((t1) - (t2))
447 #define fftw_time_to_sec(t) (t)
448
449 #define FFTW_TIME_MIN (1.0e-1) /* for Cray MPP SECONDR timer */
450
451 /**********************************************
452 * VANILLA UNIX/ISO C SYSTEMS
453 **********************************************/
454 /* last resort: use good old Unix clock() */
455 #else
456
457 #include <time.h>
458
459 typedef clock_t fftw_time;
460
461 #ifndef CLOCKS_PER_SEC
462 #ifdef sun
463 /* stupid sunos4 prototypes */
464 #define CLOCKS_PER_SEC 1000000
465 extern long clock(void);
466 #else /* not sun, we don't know CLOCKS_PER_SEC */
467 #error Please define CLOCKS_PER_SEC
468 #endif
469 #endif
470
471 #define fftw_get_time() clock()
472 #define fftw_time_diff(t1,t2) ((t1) - (t2))
473 #define fftw_time_to_sec(t) (((double) (t)) / CLOCKS_PER_SEC)
474
475 /*
476 * ***VERY*** conservative constant: this says that a
477 * measurement must run for 200ms in order to be valid.
478 * You had better check the manual of your machine
479 * to discover if it can do better than this
480 */
481 #define FFTW_TIME_MIN (2.0e-1) /* for default clock() timer */
482
483 #endif /* UNIX clock() */
484
485 /* take FFTW_TIME_REPEAT measurements... */
486 #ifndef FFTW_TIME_REPEAT
487 #define FFTW_TIME_REPEAT 4
488 #endif
489
490 /* but do not run for more than TIME_LIMIT seconds while measuring one FFT */
491 #ifndef FFTW_TIME_LIMIT
492 #define FFTW_TIME_LIMIT 2.0
493 #endif
494
495 #ifdef __cplusplus
496 } /* extern "C" */
497
498 #endif /* __cplusplus */
499
500 #endif /* FFTW_INT_H */
fftw_codelet_desc
Definition: fftw.h:126
fftw_create_twiddle
fftw_twiddle * fftw_create_twiddle(int n, const fftw_codelet_desc *d)
Definition: twiddle.c:175
fftwnd_create_plans_specific
fftw_plan * fftwnd_create_plans_specific(fftw_plan *plans, int rank, const int *n, const int *n_after, fftw_direction dir, int flags, fftw_complex *in, int istride, fftw_complex *out, int ostride)
Definition: fftwnd.c:249
fftw_factor
int fftw_factor(int n)
Definition: putils.c:468
fftwnd_aux
void fftwnd_aux(fftwnd_plan p, int cur_dim, fftw_complex *in, int istride, fftw_complex *out, int ostride, fftw_complex *work)
Definition: fftwnd.c:652
fftw_plan_struct
Definition: fftw.h:271
config_s
Definition: deflate.c:117
fftw_twiddle_struct
Definition: fftw.h:170
fftw_make_node_twiddle
fftw_plan_node * fftw_make_node_twiddle(int n, const fftw_codelet_desc *config, fftw_plan_node *recurse, int flags)
Definition: putils.c:92
fftw_lookup
fftw_plan fftw_lookup(fftw_plan *table, int n, int flags, int vector_size)
Definition: putils.c:379
fftw_complex
Definition: fftw.h:57
fftw_use_node
void fftw_use_node(fftw_plan_node *p)
Definition: putils.c:52
fftw_strided_copy
void fftw_strided_copy(int, fftw_complex *, int, fftw_complex *)
Definition: executor.c:35
fftw_make_node_hc2real
fftw_plan_node * fftw_make_node_hc2real(int size, const fftw_codelet_desc *config)
Definition: putils.c:80
fftwnd_create_plans_generic
fftw_plan * fftwnd_create_plans_generic(fftw_plan *plans, int rank, const int *n, fftw_direction dir, int flags)
Definition: fftwnd.c:175
fftw_use_plan
void fftw_use_plan(fftw_plan p)
Definition: putils.c:348
fftw.h
fftw_pick_better
fftw_plan fftw_pick_better(fftw_plan p1, fftw_plan p2)
Definition: putils.c:450
fftw_make_node
fftw_plan_node * fftw_make_node(void)
Definition: putils.c:43
fftw_generic_codelet
void( fftw_generic_codelet)(fftw_complex *, const fftw_complex *, int, int, int, int)
Definition: fftw.h:98
fftw_plan_hook_ptr
void(* fftw_plan_hook_ptr)(fftw_plan plan)
Definition: fftw-int.h:138
fftw_make_node_rgeneric
fftw_plan_node * fftw_make_node_rgeneric(int n, int size, fftw_direction dir, fftw_rgeneric_codelet *codelet, fftw_plan_node *recurse, int flags)
Definition: putils.c:154
fftw_rader_data_struct
Definition: fftw.h:178
fftw_make_node_hc2hc
fftw_plan_node * fftw_make_node_hc2hc(int n, fftw_direction dir, const fftw_codelet_desc *config, fftw_plan_node *recurse, int flags)
Definition: putils.c:112
RFFTW_WISDOM
Definition: fftw-int.h:70
fftw_gettimeofday_get_time
fftw_time fftw_gettimeofday_get_time(void)
Definition: timer.c:143
fftw_make_node_generic
fftw_plan_node * fftw_make_node_generic(int n, int size, fftw_generic_codelet *codelet, fftw_plan_node *recurse, int flags)
Definition: putils.c:133
fftw_node_type
fftw_node_type
Definition: fftw.h:120
fftw_plan_hook
fftw_plan_hook_ptr fftw_plan_hook
Definition: planner.c:33
fftw_time
struct timeval fftw_time
Definition: fftw-int.h:352
fftw_make_plan
fftw_plan fftw_make_plan(int n, fftw_direction dir, fftw_plan_node *root, int flags, enum fftw_node_type wisdom_type, int wisdom_signature, fftw_recurse_kind recurse_kind, int vector_size)
Definition: putils.c:266
fftw_insert
void fftw_insert(fftw_plan *table, fftw_plan this_plan)
Definition: putils.c:372
FFTW_WISDOM
Definition: fftw-int.h:70
fftw_recurse_kind
fftw_recurse_kind
Definition: fftw.h:266
fftw_executor_simple
void fftw_executor_simple(int, const fftw_complex *, fftw_complex *, fftw_plan_node *, int, int, fftw_recurse_kind recurse_kind)
Definition: executor.c:212
config.h
fftwnd_work_size
int fftwnd_work_size(int rank, const int *n, int flags, int ncopies)
Definition: fftwnd.c:238
fftw_wisdom_category
fftw_wisdom_category
Definition: fftw-int.h:69
fftw_wisdom_add
void fftw_wisdom_add(int n, int flags, fftw_direction dir, enum fftw_wisdom_category cat, int istride, int ostride, enum fftw_node_type type, int signature, fftw_recurse_kind recurse_kind)
Definition: wisdom.c:85
fftw_estimate_node
double fftw_estimate_node(fftw_plan_node *p)
Definition: putils.c:400
fftwnd_aux_howmany
void fftwnd_aux_howmany(fftwnd_plan p, int cur_dim, int howmany, fftw_complex *in, int istride, int idist, fftw_complex *out, int ostride, int odist, fftw_complex *work)
Definition: fftwnd.c:698
fftw_make_node_rader
fftw_plan_node * fftw_make_node_rader(int n, int size, fftw_direction dir, fftw_plan_node *recurse, int flags)
Definition: rader.c:345
fftwnd_create_plan_aux
fftwnd_plan fftwnd_create_plan_aux(int rank, const int *n, fftw_direction dir, int flags)
Definition: fftwnd.c:108
fftw_time_diff
#define fftw_time_diff(t1, t2)
Definition: fftw-int.h:357
fftw_rader_top
fftw_rader_data * fftw_rader_top
Definition: putils.c:186
fftwnd_data
Definition: fftw.h:355
fftw_wisdom_lookup
int fftw_wisdom_lookup(int n, int flags, fftw_direction dir, enum fftw_wisdom_category category, int istride, int ostride, enum fftw_node_type *type, int *signature, fftw_recurse_kind *recurse_kind, int replace_p)
Definition: wisdom.c:46
FFTW_TRIG_REAL
double FFTW_TRIG_REAL
Definition: fftw-int.h:187
fftw_make_node_notw
fftw_plan_node * fftw_make_node_notw(int size, const fftw_codelet_desc *config)
Definition: putils.c:57
fftw_destroy_plan_internal
void fftw_destroy_plan_internal(fftw_plan p)
Definition: putils.c:353
fftwnd_new_plan_array
fftw_plan * fftwnd_new_plan_array(int rank)
Definition: fftwnd.c:157
fftw_rgeneric_codelet
void( fftw_rgeneric_codelet)(fftw_real *, const fftw_complex *, int, int, int, int)
Definition: fftw.h:110
fftw_make_node_real2hc
fftw_plan_node * fftw_make_node_real2hc(int size, const fftw_codelet_desc *config)
Definition: putils.c:68
fftw_complete_twiddle
void fftw_complete_twiddle(fftw_plan_node *p, int n)
Definition: putils.c:296
DL_IMPORT
DL_IMPORT(fftw_plan_hook_ptr) fftw_plan_hook
fftw_make_empty_table
void fftw_make_empty_table(fftw_plan *table)
Definition: putils.c:367
fftw_plan_node_struct
Definition: fftw.h:192
fftw_gettimeofday_time_diff
fftw_time fftw_gettimeofday_time_diff(fftw_time t1, fftw_time t2)
Definition: timer.c:150
fftw_direction
fftw_direction
Definition: fftw.h:63
fftw_destroy_twiddle
void fftw_destroy_twiddle(fftw_twiddle *tw)
Definition: twiddle.c:201
fftw_destroy_table
void fftw_destroy_table(fftw_plan *table)
Definition: putils.c:390