NFFT Logo 3.2.3
nfft3.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2002, 2012 Jens Keiner, Stefan Kunis, Daniel Potts
3  *
4  * This program is free software; you can redistribute it and/or modify it under
5  * the terms of the GNU General Public License as published by the Free Software
6  * Foundation; either version 2 of the License, or (at your option) any later
7  * version.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
12  * details.
13  *
14  * You should have received a copy of the GNU General Public License along with
15  * this program; if not, write to the Free Software Foundation, Inc., 51
16  * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  */
18 
19 /* $Id: nfft3.h 3896 2012-10-10 12:19:26Z tovo $ */
20 
21 #ifndef __NFFT3_H__
22 #define __NFFT3_H__
23 
24 /* module configuration */
25 #include "nfft3conf.h"
26 
27 /* fftw_complex */
28 #include <fftw3.h>
29 
30 #ifdef __cplusplus
31 extern "C"
32 {
33 #endif /* __cplusplus */
34 
35 #define NFFT_CONCAT(prefix, name) prefix ## name
36 
37 /* IMPORTANT: for Windows compilers, you should add a line
38  * #define FFTW_DLL
39  * here and in kernel/infft.h if you are compiling/using NFFT as a DLL, in order
40  * to do the proper importing/exporting, or alternatively compile with
41  * -DNFFT_DLL or the equivalent command-line flag. This is not necessary under
42  * MinGW/Cygwin, where libtool does the imports/exports automatically. */
43 #if defined(NFFT_DLL) && (defined(_WIN32) || defined(__WIN32__))
44  /* annoying Windows syntax for shared-library declarations */
45 # if defined(COMPILING_NFFT) /* defined in api.h when compiling NFFT */
46 # define NFFT_EXTERN extern __declspec(dllexport)
47 # else /* user is calling NFFT; import symbol */
48 # define NFFT_EXTERN extern __declspec(dllimport)
49 # endif
50 #else
51 # define NFFT_EXTERN extern
52 #endif
53 
54 /* our own memory allocation and exit functions */
55 NFFT_EXTERN void *nfft_malloc(size_t n);
56 NFFT_EXTERN void nfft_free(void *p);
57 NFFT_EXTERN void nfft_die(char *s);
58 
59 /* You can replace the hooks with your own, functions if necessary. We need this
60  * for the Matlab interfaces etc. */
61 typedef void *(*nfft_malloc_type_function) (size_t n);
62 typedef void (*nfft_free_type_function) (void *p);
63 typedef void (*nfft_die_type_function) (const char *errString);
64 NFFT_EXTERN nfft_malloc_type_function nfft_malloc_hook;
65 NFFT_EXTERN nfft_free_type_function nfft_free_hook;
66 NFFT_EXTERN nfft_die_type_function nfft_die_hook;
67 
68 /* members inherited by all plans */
69 #define MACRO_MV_PLAN(RC) \
70  int N_total; \
71  int M_total; \
72  RC *f_hat; \
73  RC *f; \
74  void (*mv_trafo)(void*); \
75  void (*mv_adjoint)(void*);
77 /* nfft */
78 
79 /* name mangling macros */
80 #define NFFT_MANGLE_DOUBLE(name) NFFT_CONCAT(nfft_, name)
81 #define NFFT_MANGLE_FLOAT(name) NFFT_CONCAT(nfftf_, name)
82 #define NFFT_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(nfftl_, name)
83 
84 /* huge second-order macro that defines prototypes for all nfft API functions.
85  * We expand this macro for each supported precision.
86  * X: nfft name-mangling macro
87  * Y: fftw name-mangling macro
88  * R: real data type
89  * C: complex data type
90  */
91 #define NFFT_DEFINE_API(X,Y,R,C) \
92 \
93 typedef struct \
94 { \
95  MACRO_MV_PLAN(C) \
96 } X(mv_plan_complex); \
97 \
98 typedef struct \
99 { \
100  MACRO_MV_PLAN(R) \
101 } X(mv_plan_double); \
102 \
103 typedef struct\
104 {\
105  MACRO_MV_PLAN(C)\
106 \
107  int d; \
108  int *N; \
109  R *sigma; \
110  int *n; \
112  int n_total; \
113  int m; \
118  R *b; \
119  int K; \
121 \
122  unsigned nfft_flags; \
126 \
127  unsigned fftw_flags; \
129 \
130  R *x; \
131 \
132  double MEASURE_TIME_t[3]; \
134 \
135  /* internal use only */\
136  Y(plan) my_fftw_plan1; \
137  Y(plan) my_fftw_plan2; \
138 \
139  R **c_phi_inv; \
141  R *psi; \
143  int *psi_index_g; \
144  int *psi_index_f; \
145 \
146  C *g; \
147  C *g_hat; \
148  C *g1; \
149  C *g2; \
150 \
151  R *spline_coeffs; \
152 \
153  int *index_x; \
154 } X(plan); \
155 \
156 NFFT_EXTERN void X(trafo_direct)(X(plan) *ths);\
157 NFFT_EXTERN void X(adjoint_direct)(X(plan) *ths);\
158 NFFT_EXTERN void X(trafo)(X(plan) *ths);\
159 NFFT_EXTERN void X(trafo_1d)(X(plan) *ths);\
160 NFFT_EXTERN void X(trafo_2d)(X(plan) *ths);\
161 NFFT_EXTERN void X(trafo_3d)(X(plan) *ths);\
162 NFFT_EXTERN void X(adjoint)(X(plan) *ths);\
163 NFFT_EXTERN void X(adjoint_1d)(X(plan) *ths);\
164 NFFT_EXTERN void X(adjoint_2d)(X(plan) *ths);\
165 NFFT_EXTERN void X(adjoint_3d)(X(plan) *ths);\
166 NFFT_EXTERN void X(init_1d)(X(plan) *ths, int N1, int M);\
167 NFFT_EXTERN void X(init_2d)(X(plan) *ths, int N1, int N2, int M);\
168 NFFT_EXTERN void X(init_3d)(X(plan) *ths, int N1, int N2, int N3, int M);\
169 NFFT_EXTERN void X(init)(X(plan) *ths, int d, int *N, int M);\
170 NFFT_EXTERN void X(init_guru)(X(plan) *ths, int d, int *N, int M, int *n, \
171  int m, unsigned nfft_flags, unsigned fftw_flags);\
172 NFFT_EXTERN void X(precompute_one_psi)(X(plan) *ths);\
173 NFFT_EXTERN void X(precompute_full_psi)(X(plan) *ths);\
174 NFFT_EXTERN void X(precompute_psi)(X(plan) *ths);\
175 NFFT_EXTERN void X(precompute_lin_psi)(X(plan) *ths);\
176 NFFT_EXTERN const char* X(check)(X(plan) *ths);\
177 NFFT_EXTERN void X(finalize)(X(plan) *ths);
178 
179 /* nfft api */
180 NFFT_DEFINE_API(NFFT_MANGLE_FLOAT,FFTW_MANGLE_FLOAT,float,fftwf_complex)
181 NFFT_DEFINE_API(NFFT_MANGLE_DOUBLE,FFTW_MANGLE_DOUBLE,double,fftw_complex)
182 NFFT_DEFINE_API(NFFT_MANGLE_LONG_DOUBLE,FFTW_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
183 
184 /* flags for init */
185 #define PRE_PHI_HUT (1U<< 0)
186 #define FG_PSI (1U<< 1)
187 #define PRE_LIN_PSI (1U<< 2)
188 #define PRE_FG_PSI (1U<< 3)
189 #define PRE_PSI (1U<< 4)
190 #define PRE_FULL_PSI (1U<< 5)
191 #define MALLOC_X (1U<< 6)
192 #define MALLOC_F_HAT (1U<< 7)
193 #define MALLOC_F (1U<< 8)
194 #define FFT_OUT_OF_PLACE (1U<< 9)
195 #define FFTW_INIT (1U<< 10)
196 #define NFFT_SORT_NODES (1U<< 11)
197 #define NFFT_OMP_BLOCKWISE_ADJOINT (1U<<12)
198 #define PRE_ONE_PSI (PRE_LIN_PSI| PRE_FG_PSI| PRE_PSI| PRE_FULL_PSI)
199 
200 
201 /* nfct */
202 
203 /* name mangling macros */
204 #define NFCT_MANGLE_DOUBLE(name) NFFT_CONCAT(nfct_, name)
205 #define NFCT_MANGLE_FLOAT(name) NFFT_CONCAT(nfctf_, name)
206 #define NFCT_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(nfctl_, name)
207 
208 /* huge second-order macro that defines prototypes for all nfct API functions.
209  * We expand this macro for each supported precision.
210  * X: nfct name-mangling macro
211  * Y: fftw name-mangling macro
212  * R: real data type
213  * C: complex data type
214  */
215 #define NFCT_DEFINE_API(X,Y,R,C) \
216 typedef struct\
217 {\
218  /* api */\
219  MACRO_MV_PLAN(R)\
220 \
221  int d; \
222  int *N; \
223  int *n; \
224  R *sigma; \
225  int m; \
226 \
227  R nfct_full_psi_eps;\
228  R *b; \
229 \
230  unsigned nfct_flags; \
231  unsigned fftw_flags; \
232 \
233  R *x; \
234 \
235  double MEASURE_TIME_t[3]; \
236 \
237  /* internal use only */\
238  Y(plan) my_fftw_r2r_plan; \
239  Y(r2r_kind) *r2r_kind; \
240 \
241  R **c_phi_inv; \
242  R *psi; \
243  int size_psi; \
244  int *psi_index_g; \
245  int *psi_index_f; \
246 \
247  R *g;\
248  R *g_hat;\
249  R *g1; \
250  R *g2; \
251 \
252  R *spline_coeffs; \
253 } X(plan);\
254 \
255 NFFT_EXTERN void X(init_1d)(X(plan) *ths_plan, int N0, int M_total); \
256 NFFT_EXTERN void X(init_2d)(X(plan) *ths_plan, int N0, int N1, int M_total); \
257 NFFT_EXTERN void X(init_3d)(X(plan) *ths_plan, int N0, int N1, int N2, int M_total); \
258 NFFT_EXTERN void X(init)(X(plan) *ths_plan, int d, int *N, int M_total); \
259 NFFT_EXTERN void X(init_guru)(X(plan) *ths_plan, int d, int *N, int M_total, int *n, \
260  int m, unsigned nfct_flags, unsigned fftw_flags); \
261 NFFT_EXTERN void X(precompute_psi)(X(plan) *ths_plan); \
262 NFFT_EXTERN void X(trafo)(X(plan) *ths_plan); \
263 NFFT_EXTERN void X(trafo_direct)(X(plan) *ths_plan); \
264 NFFT_EXTERN void X(adjoint)(X(plan) *ths_plan); \
265 NFFT_EXTERN void X(adjoint_direct)(X(plan) *ths_plan); \
266 NFFT_EXTERN void X(finalize)(X(plan) *ths_plan); \
267 NFFT_EXTERN R X(phi_hut)(X(plan) *ths_plan, int k, int d); \
268 NFFT_EXTERN R X(phi)(X(plan) *ths_plan, R x, int d);
269 
270 #if defined(HAVE_NFCT)
271 /* nfct api */
272 NFCT_DEFINE_API(NFCT_MANGLE_FLOAT,FFTW_MANGLE_FLOAT,float,fftwf_complex)
273 NFCT_DEFINE_API(NFCT_MANGLE_DOUBLE,FFTW_MANGLE_DOUBLE,double,fftw_complex)
274 NFCT_DEFINE_API(NFCT_MANGLE_LONG_DOUBLE,FFTW_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
275 #endif
276 
277 /* nfst */
278 
279 /* name mangling macros */
280 #define NFST_MANGLE_DOUBLE(name) NFFT_CONCAT(nfst_, name)
281 #define NFST_MANGLE_FLOAT(name) NFFT_CONCAT(nfstf_, name)
282 #define NFST_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(nfstl_, name)
283 
284 /* huge second-order macro that defines prototypes for all nfct API functions.
285  * We expand this macro for each supported precision.
286  * X: nfst name-mangling macro
287  * Y: fftw name-mangling macro
288  * R: real data type
289  * C: complex data type
290  */
291 #define NFST_DEFINE_API(X,Y,R,C) \
292 typedef struct\
293 {\
294  /* api */\
295  MACRO_MV_PLAN(R)\
296 \
297  int d; \
298  int *N; \
299  int *n; \
300  R *sigma; \
301  int m; \
302 \
303  R nfst_full_psi_eps;\
304  R *b; \
305 \
306  unsigned nfst_flags; \
307  unsigned fftw_flags; \
308 \
309  R *x; \
310 \
311  double MEASURE_TIME_t[3]; \
312 \
313  /* internal use only */\
314  Y(plan) my_fftw_r2r_plan; \
315  Y(r2r_kind) *r2r_kind; \
316 \
317  R **c_phi_inv; \
318  R *psi; \
319  int size_psi; \
320  int *psi_index_g; \
321  int *psi_index_f; \
322 \
323  R *g;\
324  R *g_hat;\
325  R *g1; \
326  R *g2; \
327 \
328  R *spline_coeffs; \
329 } X(plan);\
330 \
331 NFFT_EXTERN void X(init_1d)(X(plan) *ths_plan, int N0, int M_total); \
332 NFFT_EXTERN void X(init_2d)(X(plan) *ths_plan, int N0, int N1, int M_total); \
333 NFFT_EXTERN void X(init_3d)(X(plan) *ths_plan, int N0, int N1, int N2, int M_total); \
334 NFFT_EXTERN void X(init)(X(plan) *ths_plan, int d, int *N, int M_total); \
335 NFFT_EXTERN void X(init_m)(X(plan) *ths_plan, int d, int *N, int M_total, int m);\
336 NFFT_EXTERN void X(init_guru)(X(plan) *ths_plan, int d, int *N, int M_total, int *n, \
337  int m, unsigned nfst_flags, unsigned fftw_flags); \
338 NFFT_EXTERN void X(precompute_psi)(X(plan) *ths_plan); \
339 NFFT_EXTERN void X(trafo)(X(plan) *ths_plan); \
340 NFFT_EXTERN void X(trafo_direct)(X(plan) *ths_plan); \
341 NFFT_EXTERN void X(adjoint)(X(plan) *ths_plan); \
342 NFFT_EXTERN void X(adjoint_direct)(X(plan) *ths_plan); \
343 NFFT_EXTERN void X(finalize)(X(plan) *ths_plan); \
344 NFFT_EXTERN void X(full_psi)(X(plan) *ths_plan, R eps); \
345 NFFT_EXTERN R X(phi_hut)(X(plan) *ths_plan, int k, int d); \
346 NFFT_EXTERN R X(phi)(X(plan) *ths_plan, R x, int d); \
347 NFFT_EXTERN int X(fftw_2N)(int n); \
348 NFFT_EXTERN int X(fftw_2N_rev)(int n);
349 
350 #ifdef HAVE_NFST
351 /* nfst api */
352 NFST_DEFINE_API(NFST_MANGLE_FLOAT,FFTW_MANGLE_FLOAT,float,fftwf_complex)
353 NFST_DEFINE_API(NFST_MANGLE_DOUBLE,FFTW_MANGLE_DOUBLE,double,fftw_complex)
354 NFST_DEFINE_API(NFST_MANGLE_LONG_DOUBLE,FFTW_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
355 #endif
356 
357 /* nnfft */
358 
359 /* name mangling macros */
360 #define NNFFT_MANGLE_DOUBLE(name) NFFT_CONCAT(nnfft_, name)
361 #define NNFFT_MANGLE_FLOAT(name) NFFT_CONCAT(nnfftf_, name)
362 #define NNFFT_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(nnfftl_, name)
363 
364 /* huge second-order macro that defines prototypes for all nfst API functions.
365  * We expand this macro for each supported precision.
366  * X: nnfft name-mangling macro
367  * Y: fftw name-mangling macro
368  * Z: nfft name mangling macro
369  * R: real data type
370  * C: complex data type
371  */
372 #define NNFFT_DEFINE_API(X,Y,Z,R,C) \
373 typedef struct\
374 {\
375  /* api */\
376  MACRO_MV_PLAN(C)\
377 \
378  int d; \
379  R *sigma; \
380  R *a; \
381  int *N; \
382  int *N1; \
383  int *aN1; \
384  int m; \
385  R *b; \
386  int K; \
387  int aN1_total; \
388  Z(plan) *direct_plan; \
389  unsigned nnfft_flags; \
390  int *n; \
391  R *x; \
392  R *v; \
393  R *c_phi_inv; \
394  R *psi; \
395  int size_psi; \
396  int *psi_index_g; \
397  int *psi_index_f; \
398  C *F;\
399  R *spline_coeffs; \
400 } X(plan);\
401 \
402 NFFT_EXTERN void X(init)(X(plan) *ths_plan, int d, int N_total, int M_total, int *N); \
403 NFFT_EXTERN void X(init_guru)(X(plan) *ths_plan, int d, int N_total, int M_total, \
404  int *N, int *N1, int m, unsigned nnfft_flags); \
405 NFFT_EXTERN void X(trafo_direct)(X(plan) *ths_plan); \
406 NFFT_EXTERN void X(adjoint_direct)(X(plan) *ths_plan); \
407 NFFT_EXTERN void X(trafo)(X(plan) *ths_plan); \
408 NFFT_EXTERN void X(adjoint)(X(plan) *ths_plan); \
409 NFFT_EXTERN void X(precompute_lin_psi)(X(plan) *ths_plan); \
410 NFFT_EXTERN void X(precompute_psi)(X(plan) *ths_plan); \
411 NFFT_EXTERN void X(precompute_full_psi)(X(plan) *ths_plan); \
412 NFFT_EXTERN void X(precompute_phi_hut)(X(plan) *ths_plan); \
413 NFFT_EXTERN void X(finalize)(X(plan) *ths_plan);
414 
415 #ifdef HAVE_NNFFT
416 /* nnfft api */
417 NNFFT_DEFINE_API(NNFFT_MANGLE_FLOAT,FFTW_MANGLE_FLOAT,NFFT_MANGLE_FLOAT,float,fftwf_complex)
418 NNFFT_DEFINE_API(NNFFT_MANGLE_DOUBLE,FFTW_MANGLE_DOUBLE,NFFT_MANGLE_DOUBLE,double,fftw_complex)
419 NNFFT_DEFINE_API(NNFFT_MANGLE_LONG_DOUBLE,FFTW_MANGLE_LONG_DOUBLE,NFFT_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
420 #endif
421 
422 /* additional init flags */
423 #define MALLOC_V (1U<< 11)
424 
425 /* nsfft */
426 
427 #define NSFFT_MANGLE_DOUBLE(name) NFFT_CONCAT(nsfft_, name)
428 #define NSFFT_MANGLE_FLOAT(name) NFFT_CONCAT(nsfftf_, name)
429 #define NSFFT_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(nsfftl_, name)
430 
431 /* huge second-order macro that defines prototypes for all nnfft API functions.
432  * We expand this macro for each supported precision.
433  * X: nnfft name-mangling macro
434  * Y: fftw name-mangling macro
435  * Z: nfft name mangling macro
436  * R: real data type
437  * C: complex data type
438  */
439 #define NSFFT_DEFINE_API(X,Y,Z,R,C) \
440 typedef struct\
441 {\
442  MACRO_MV_PLAN(C)\
443 \
444  int d; \
445  int J; \
448  int sigma; \
449  unsigned flags; \
450  int *index_sparse_to_full; \
451  int r_act_nfft_plan; \
452  Z(plan) *act_nfft_plan; \
453  Z(plan) *center_nfft_plan; \
454  Y(plan) *set_fftw_plan1; \
455  Y(plan) *set_fftw_plan2; \
456  Z(plan) *set_nfft_plan_1d; \
457  Z(plan) *set_nfft_plan_2d; \
458  R *x_transposed; \
459  R *x_102,*x_201,*x_120,*x_021; \
460 } X(plan);\
461 \
462 NFFT_EXTERN void X(trafo_direct)(X(plan) *ths); \
463 NFFT_EXTERN void X(adjoint_direct)(X(plan) *ths); \
464 NFFT_EXTERN void X(trafo)(X(plan) *ths); \
465 NFFT_EXTERN void X(adjoint)(X(plan) *ths); \
466 NFFT_EXTERN void X(cp)(X(plan) *ths, Z(plan) *ths_nfft); \
467 NFFT_EXTERN void X(init_random_nodes_coeffs)(X(plan) *ths); \
468 NFFT_EXTERN void X(init)(X(plan) *ths, int d, int J, int M, int m, unsigned flags); \
469 NFFT_EXTERN void X(finalize)(X(plan) *ths);
470 
471 #ifdef HAVE_NSFFT
472 /* nsfft api */
473 NSFFT_DEFINE_API(NSFFT_MANGLE_FLOAT,FFTW_MANGLE_FLOAT,NFFT_MANGLE_FLOAT,float,fftwf_complex)
474 NSFFT_DEFINE_API(NSFFT_MANGLE_DOUBLE,FFTW_MANGLE_DOUBLE,NFFT_MANGLE_DOUBLE,double,fftw_complex)
475 NSFFT_DEFINE_API(NSFFT_MANGLE_LONG_DOUBLE,FFTW_MANGLE_LONG_DOUBLE,NFFT_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
476 #endif
477 
478 /* additional init flags */
479 #define NSDFT (1U<< 12)
480 
481 /* mri */
482 
483 /* name mangling macros */
484 #define MRI_MANGLE_DOUBLE(name) NFFT_CONCAT(mri_, name)
485 #define MRI_MANGLE_FLOAT(name) NFFT_CONCAT(mrif_, name)
486 #define MRI_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(mril_, name)
487 
488 /* huge second-order macro that defines prototypes for all mri API functions.
489  * We expand this macro for each supported precision.
490  * X: mri name-mangling macro
491  * Z: nfft name mangling macro
492  * R: real data type
493  * C: complex data type
494  */
495 #define MRI_DEFINE_API(X,Z,R,C) \
496 typedef struct\
497 {\
498  MACRO_MV_PLAN(C)\
499  Z(plan) plan;\
500  int N3;\
501  R sigma3;\
502  R *t;\
503  R *w;\
504 } X(inh_2d1d_plan);\
505 \
506 typedef struct\
507 {\
508  MACRO_MV_PLAN(C)\
509  Z(plan) plan;\
510  int N3;\
511  R sigma3;\
512  R *t;\
513  R *w;\
514 } X(inh_3d_plan);\
515 \
516 void X(inh_2d1d_trafo)(X(inh_2d1d_plan) *ths); \
517 void X(inh_2d1d_adjoint)(X(inh_2d1d_plan) *ths); \
518 void X(inh_2d1d_init_guru)(X(inh_2d1d_plan) *ths, int *N, int M, int *n, \
519  int m, R sigma, unsigned nfft_flags, unsigned fftw_flags); \
520 void X(inh_2d1d_finalize)(X(inh_2d1d_plan) *ths); \
521 void X(inh_3d_trafo)(X(inh_3d_plan) *ths); \
522 void X(inh_3d_adjoint)(X(inh_3d_plan) *ths); \
523 void X(inh_3d_init_guru)(X(inh_3d_plan) *ths, int *N, int M, int *n, \
524  int m, R sigma, unsigned nfft_flags, unsigned fftw_flags); \
525 void X(inh_3d_finalize)(X(inh_3d_plan) *ths);
526 
527 #ifdef HAVE_MRI
528  /* mri api */
529 MRI_DEFINE_API(MRI_MANGLE_FLOAT,NFFT_MANGLE_FLOAT,float,fftwf_complex)
530 MRI_DEFINE_API(MRI_MANGLE_DOUBLE,NFFT_MANGLE_DOUBLE,double,fftw_complex)
531 MRI_DEFINE_API(MRI_MANGLE_LONG_DOUBLE,NFFT_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
532 #endif
533 
534 /* nfsft */
535 
536 /* name mangling macros */
537 #define NFSFT_MANGLE_DOUBLE(name) NFFT_CONCAT(nfsft_, name)
538 #define NFSFT_MANGLE_FLOAT(name) NFFT_CONCAT(nfsftf_, name)
539 #define NFSFT_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(nfsftl_, name)
540 
541 /* huge second-order macro that defines prototypes for all nfsft API functions.
542  * We expand this macro for each supported precision.
543  * X: nfsft name-mangling macro
544  * Z: nfft name mangling macro
545  * R: real data type
546  * C: complex data type
547  */
548 #define NFSFT_DEFINE_API(X,Z,R,C) \
549 typedef struct\
550 {\
551  MACRO_MV_PLAN(C)\
552  int N; \
553  R *x; \
556  /* internal use only */\
557  int t; \
558  unsigned int flags; \
559  Z(plan) plan_nfft; \
560  C *f_hat_intern; \
562  double MEASURE_TIME_t[3]; \
564 } X(plan);\
565 \
566 NFFT_EXTERN void X(init)(X(plan) *plan, int N, int M); \
567 NFFT_EXTERN void X(init_advanced)(X(plan)* plan, int N, int M, unsigned int \
568  nfsft_flags); \
569 NFFT_EXTERN void X(init_guru)(X(plan) *plan, int N, int M, \
570  unsigned int nfsft_flags, unsigned int nfft_flags, int nfft_cutoff); \
571 NFFT_EXTERN void X(precompute)(int N, R kappa, unsigned int nfsft_flags, \
572  unsigned int fpt_flags); \
573 NFFT_EXTERN void X(forget)(void); \
574 NFFT_EXTERN void X(trafo_direct)(X(plan)* plan); \
575 NFFT_EXTERN void X(adjoint_direct)(X(plan)* plan); \
576 NFFT_EXTERN void X(trafo)(X(plan)* plan); \
577 NFFT_EXTERN void X(adjoint)(X(plan)* plan); \
578 NFFT_EXTERN void X(finalize)(X(plan) *plan); \
579 NFFT_EXTERN void X(precompute_x)(X(plan) *plan);
580 
581 #ifdef HAVE_NFSFT
582 /* nfsft api */
583 NFSFT_DEFINE_API(NFSFT_MANGLE_FLOAT,NFFT_MANGLE_FLOAT,float,fftwf_complex)
584 NFSFT_DEFINE_API(NFSFT_MANGLE_DOUBLE,NFFT_MANGLE_DOUBLE,double,fftw_complex)
585 NFSFT_DEFINE_API(NFSFT_MANGLE_LONG_DOUBLE,NFFT_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
586 #endif
587 
588 /* init flags */
589 #define NFSFT_NORMALIZED (1U << 0)
590 #define NFSFT_USE_NDFT (1U << 1)
591 #define NFSFT_USE_DPT (1U << 2)
592 #define NFSFT_MALLOC_X (1U << 3)
593 #define NFSFT_MALLOC_F_HAT (1U << 5)
594 #define NFSFT_MALLOC_F (1U << 6)
595 #define NFSFT_PRESERVE_F_HAT (1U << 7)
596 #define NFSFT_PRESERVE_X (1U << 8)
597 #define NFSFT_PRESERVE_F (1U << 9)
598 #define NFSFT_DESTROY_F_HAT (1U << 10)
599 #define NFSFT_DESTROY_X (1U << 11)
600 #define NFSFT_DESTROY_F (1U << 12)
601 
602 /* precompute flags */
603 #define NFSFT_NO_DIRECT_ALGORITHM (1U << 13)
604 #define NFSFT_NO_FAST_ALGORITHM (1U << 14)
605 #define NFSFT_ZERO_F_HAT (1U << 16)
606 
607 /* helper macros */
608 #define NFSFT_INDEX(k,n,plan) ((2*(plan)->N+2)*((plan)->N-n+1)+(plan)->N+k+1)
609 #define NFSFT_F_HAT_SIZE(N) ((2*N+2)*(2*N+2))
610 
611 /* fpt */
612 
613 /* name mangling macros */
614 #define FPT_MANGLE_DOUBLE(name) NFFT_CONCAT(fpt_, name)
615 #define FPT_MANGLE_FLOAT(name) NFFT_CONCAT(fptf_, name)
616 #define FPT_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(fptl_, name)
617 
618 /* huge second-order macro that defines prototypes for all fpt API functions.
619  * We expand this macro for each supported precision.
620  * X: fpt name-mangling macro
621  * R: real data type
622  * C: complex data type
623  */
624 #define FPT_DEFINE_API(X,Y,R,C) \
625 typedef struct X(set_s_) *X(set); \
627 \
628 NFFT_EXTERN X(set) X(init)(const int M, const int t, const unsigned int flags); \
629 NFFT_EXTERN void X(precompute)(X(set) set, const int m, R *alpha, R *beta, \
630  R *gam, int k_start, const R threshold); \
631 NFFT_EXTERN void X(trafo_direct)(X(set) set, const int m, const C *x, C *y, \
632  const int k_end, const unsigned int flags); \
633 NFFT_EXTERN void X(trafo)(X(set) set, const int m, const C *x, C *y, \
634  const int k_end, const unsigned int flags); \
635 NFFT_EXTERN void X(transposed_direct)(X(set) set, const int m, C *x, \
636  C *y, const int k_end, const unsigned int flags); \
637 NFFT_EXTERN void X(transposed)(X(set) set, const int m, C *x, \
638  C *y, const int k_end, const unsigned int flags); \
639 NFFT_EXTERN void X(finalize)(X(set) set);
640 
641 #ifdef HAVE_FPT
642 /* fpt api */
643 FPT_DEFINE_API(FPT_MANGLE_FLOAT,FFTW_MANGLE_FLOAT,float,fftwf_complex)
644 FPT_DEFINE_API(FPT_MANGLE_DOUBLE,FFTW_MANGLE_DOUBLE,double,fftw_complex)
645 FPT_DEFINE_API(FPT_MANGLE_LONG_DOUBLE,FFTW_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
646 
647 /* init flags */
648 #define FPT_NO_STABILIZATION (1U << 0)
649 #define FPT_NO_FAST_ALGORITHM (1U << 2)
650 #define FPT_NO_DIRECT_ALGORITHM (1U << 3)
651 #define FPT_PERSISTENT_DATA (1U << 4)
652 
653 /* transform flags */
654 #define FPT_FUNCTION_VALUES (1U << 5)
655 #define FPT_AL_SYMMETRY (1U << 6)
656 #endif
657 
658 /* nfsoft*/
659 
660 /* name mangling macros */
661 #define NFSOFT_MANGLE_DOUBLE(name) NFFT_CONCAT(nfsoft_, name)
662 #define NFSOFT_MANGLE_FLOAT(name) NFFT_CONCAT(nfsoftf_, name)
663 #define NFSOFT_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(nfsoftl_, name)
664 
665 /* huge second-order macro that defines prototypes for all nfsoft API functions.
666  * We expand this macro for each supported precision.
667  * X: nfsoft name-mangling macro
668  * Y: nfft name-mangling macro
669  * Z: fpt name-mangling macro
670  * R: real data type
671  * C: complex data type
672  */
673 #define NFSOFT_DEFINE_API(X,Y,Z,R,C) \
674 typedef struct X(plan_)\
675 {\
676  MACRO_MV_PLAN(C) \
677  R *x; \
678  C *wig_coeffs; \
680  C *cheby; \
682  C *aux; \
683  /* internal use only */\
684  int t; \
685  unsigned int flags; \
686  Y(plan) p_nfft; \
687  Z(set) internal_fpt_set; \
688  int fpt_kappa; \
689 } X(plan);\
690 \
691 NFFT_EXTERN void X(precompute)(X(plan) *plan); \
692 NFFT_EXTERN Z(set) X(SO3_single_fpt_init)(int l, int k, int m, unsigned int flags, int kappa); \
693 NFFT_EXTERN void X(SO3_fpt)(C *coeffs, Z(set) set, int l, int k, int m, unsigned int nfsoft_flags); \
694 NFFT_EXTERN void X(SO3_fpt_transposed)(C *coeffs, Z(set) set,int l, int k, int m,unsigned int nfsoft_flags); \
695 NFFT_EXTERN void X(init)(X(plan) *plan, int N, int M); \
696 NFFT_EXTERN void X(init_advanced)(X(plan) *plan, int N, int M,unsigned int nfsoft_flags); \
697 NFFT_EXTERN void X(init_guru)(X(plan) *plan, int N, int M,unsigned int nfsoft_flags,unsigned int nfft_flags,int nfft_cutoff,int fpt_kappa); \
698 NFFT_EXTERN void X(trafo)(X(plan) *plan_nfsoft); \
699 NFFT_EXTERN void X(adjoint)(X(plan) *plan_nfsoft); \
700 NFFT_EXTERN void X(finalize)(X(plan) *plan); \
701 NFFT_EXTERN int X(posN)(int n,int m, int B);
702 
703 #ifdef HAVE_NFSOFT
704 /* nfsoft api */
705 NFSOFT_DEFINE_API(NFSOFT_MANGLE_FLOAT,NFFT_MANGLE_FLOAT,FPT_MANGLE_FLOAT,float,fftwf_complex)
706 NFSOFT_DEFINE_API(NFSOFT_MANGLE_DOUBLE,NFFT_MANGLE_DOUBLE,FPT_MANGLE_DOUBLE,double,fftw_complex)
707 NFSOFT_DEFINE_API(NFSOFT_MANGLE_LONG_DOUBLE,NFFT_MANGLE_LONG_DOUBLE,FPT_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
708 
709 /* init flags */
710 #define NFSOFT_NORMALIZED (1U << 0)
711 #define NFSOFT_USE_NDFT (1U << 1)
712 #define NFSOFT_USE_DPT (1U << 2)
713 #define NFSOFT_MALLOC_X (1U << 3)
714 #define NFSOFT_REPRESENT (1U << 4)
715 #define NFSOFT_MALLOC_F_HAT (1U << 5)
716 #define NFSOFT_MALLOC_F (1U << 6)
717 #define NFSOFT_PRESERVE_F_HAT (1U << 7)
718 #define NFSOFT_PRESERVE_X (1U << 8)
719 #define NFSOFT_PRESERVE_F (1U << 9)
720 #define NFSOFT_DESTROY_F_HAT (1U << 10)
721 #define NFSOFT_DESTROY_X (1U << 11)
722 #define NFSOFT_DESTROY_F (1U << 12)
723 
724 /* precompute flags */
725 #define NFSOFT_NO_STABILIZATION (1U << 13)
726 #define NFSOFT_CHOOSE_DPT (1U << 14)
727 #define NFSOFT_SOFT (1U << 15)
728 #define NFSOFT_ZERO_F_HAT (1U << 16)
729 
730 /* helper macros */
731 #define NFSOFT_INDEX(m,n,l,B) (((l)+((B)+1))+(2*(B)+2)*(((n)+((B)+1))+(2*(B)+2)*((m)+((B)+1))))
732 #define NFSOFT_INDEX_TWO(m,n,l,B) ((B+1)*(B+1)+(B+1)*(B+1)*(m+B)-((m-1)*m*(2*m-1)+(B+1)*(B+2)*(2*B+3))/6)+(posN(n,m,B))+(l-MAX(ABS(m),ABS(n)))
733 #define NFSOFT_F_HAT_SIZE(B) (((B)+1)*(4*((B)+1)*((B)+1)-1)/3)
734 
735 #endif
736 
737 /*solver */
738 
739 /* name mangling macros */
740 #define SOLVER_MANGLE_DOUBLE(name) NFFT_CONCAT(solver_, name)
741 #define SOLVER_MANGLE_FLOAT(name) NFFT_CONCAT(solverf_, name)
742 #define SOLVER_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(solverl_, name)
743 
744 /* huge second-order macro that defines prototypes for all nfsoft API functions.
745  * We expand this macro for each supported precision.
746  * X: nfsoft name-mangling macro
747  * Y: nfft name-mangling macro
748  * R: real data type
749  * C: complex data type
750  */
751 #define SOLVER_DEFINE_API(X,Y,R,C)\
752 typedef struct\
753 {\
754  Y(mv_plan_complex) *mv; \
755  unsigned flags; \
756  R *w; \
757  R *w_hat; \
758  C *y; \
759  C *f_hat_iter; \
760  C *r_iter; \
761  C *z_hat_iter; \
762  C *p_hat_iter; \
763  C *v_iter; \
764  R alpha_iter; \
765  R beta_iter; \
766  R dot_r_iter; \
767  R dot_r_iter_old; \
768  R dot_z_hat_iter; \
769  R dot_z_hat_iter_old; \
770  R dot_p_hat_iter; \
771  R dot_v_iter; \
772 } X(plan_complex);\
773 \
774 NFFT_EXTERN void X(init_advanced_complex)(X(plan_complex)* ths, Y(mv_plan_complex) *mv, unsigned flags);\
775 NFFT_EXTERN void X(init_complex)(X(plan_complex)* ths, Y(mv_plan_complex) *mv);\
776 NFFT_EXTERN void X(before_loop_complex)(X(plan_complex)* ths);\
777 NFFT_EXTERN void X(loop_one_step_complex)(X(plan_complex) *ths);\
778 NFFT_EXTERN void X(finalize_complex)(X(plan_complex) *ths);\
779 \
780 typedef struct\
781 {\
782  Y(mv_plan_double) *mv; \
783  unsigned flags; \
784  R *w; \
785  R *w_hat; \
786  R *y; \
787  R *f_hat_iter; \
788  R *r_iter; \
789  R *z_hat_iter; \
790  R *p_hat_iter; \
791  R *v_iter; \
792  R alpha_iter; \
793  R beta_iter; \
794  R dot_r_iter; \
795  R dot_r_iter_old; \
796  R dot_z_hat_iter; \
797  R dot_z_hat_iter_old; \
798  R dot_p_hat_iter; \
799  R dot_v_iter; \
800 } X(plan_double);\
801 \
802 NFFT_EXTERN void X(init_advanced_double)(X(plan_double)* ths, Y(mv_plan_double) *mv, unsigned flags);\
803 NFFT_EXTERN void X(solver_init_double)(X(plan_double)* ths, Y(mv_plan_double) *mv);\
804 NFFT_EXTERN void X(solver_before_loop_double)(X(plan_double)* ths);\
805 NFFT_EXTERN void X(solver_loop_one_step_double)(X(plan_double) *ths);\
806 NFFT_EXTERN void X(solver_finalize_double)(X(plan_double) *ths);
807 
808 /* solver api */
809 SOLVER_DEFINE_API(SOLVER_MANGLE_FLOAT,NFFT_MANGLE_FLOAT,float,fftwf_complex)
810 SOLVER_DEFINE_API(SOLVER_MANGLE_DOUBLE,NFFT_MANGLE_DOUBLE,double,fftw_complex)
811 SOLVER_DEFINE_API(SOLVER_MANGLE_LONG_DOUBLE,NFFT_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
812 
813 /* init flags */
814 #define LANDWEBER (1U<< 0)
815 #define STEEPEST_DESCENT (1U<< 1)
816 #define CGNR (1U<< 2)
817 #define CGNE (1U<< 3)
818 #define NORMS_FOR_LANDWEBER (1U<< 4)
819 #define PRECOMPUTE_WEIGHT (1U<< 5)
820 #define PRECOMPUTE_DAMP (1U<< 6)
821 
822 #ifdef __cplusplus
823 } /* extern "C" */
824 #endif /* __cplusplus */
825 
826 #endif /* defined(__NFFT3_H__) */
Generated on Tue Apr 30 2013 by Doxygen 1.8.1