NFFT  3.3.1
nfft3.h
Go to the documentation of this file.
00001 /*
00002  * Copyright (c) 2002, 2016 Jens Keiner, Stefan Kunis, Daniel Potts
00003  *
00004  * This program is free software; you can redistribute it and/or modify it under
00005  * the terms of the GNU General Public License as published by the Free Software
00006  * Foundation; either version 2 of the License, or (at your option) any later
00007  * version.
00008  *
00009  * This program is distributed in the hope that it will be useful, but WITHOUT
00010  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00011  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
00012  * details.
00013  *
00014  * You should have received a copy of the GNU General Public License along with
00015  * this program; if not, write to the Free Software Foundation, Inc., 51
00016  * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
00017  */
00018 
00019 #ifndef __NFFT3_H__
00020 #define __NFFT3_H__
00021 
00022 /* fftw_complex */
00023 #include <fftw3.h>
00024 
00025 #ifdef __cplusplus
00026 extern "C"
00027 {
00028 #endif /* __cplusplus */
00029 
00030 #define NFFT_CONCAT(prefix, name) prefix ## name
00031 
00032 /* IMPORTANT: for Windows compilers, you should add a line
00033  *   #define FFTW_DLL
00034  * here and in kernel/infft.h if you are compiling/using NFFT as a DLL, in order
00035  * to do the proper importing/exporting, or alternatively compile with
00036  * -DNFFT_DLL or the equivalent command-line flag. This is not necessary under
00037  * MinGW/Cygwin, where libtool does the imports/exports automatically. */
00038 #if defined(NFFT_DLL) && (defined(_WIN32) || defined(__WIN32__))
00039   /* annoying Windows syntax for shared-library declarations */
00040 #  if defined(COMPILING_NFFT) /* defined in api.h when compiling NFFT */
00041 #    define NFFT_EXTERN extern __declspec(dllexport)
00042 #  else /* user is calling NFFT; import symbol */
00043 #    define NFFT_EXTERN extern __declspec(dllimport)
00044 #  endif
00045 #else
00046 #  define NFFT_EXTERN extern
00047 #endif
00048 
00049 /* Integral type large enough to contain a stride (what ``int'' should have been
00050  * in the first place) */
00051 typedef ptrdiff_t NFFT_INT;
00052 
00053 /* Members inherited by all plans. */
00054 #define MACRO_MV_PLAN(RC) \
00055   NFFT_INT N_total; \
00056   NFFT_INT M_total; \
00057   RC *f_hat; \
00058   RC *f; \
00059   void (*mv_trafo)(void*); \
00060   void (*mv_adjoint)(void*); 
00062 /* nfft */
00063 
00064 /* Name mangling macros. */
00065 #define NFFT_MANGLE_DOUBLE(name) NFFT_CONCAT(nfft_, name)
00066 #define NFFT_MANGLE_FLOAT(name) NFFT_CONCAT(nfftf_, name)
00067 #define NFFT_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(nfftl_, name)
00068 
00069 #define NFFT_DEFINE_MALLOC_API(X) \
00070 /* our own memory allocation and exit functions */ \
00071 NFFT_EXTERN void *X(malloc)(size_t n); \
00072 NFFT_EXTERN void X(free)(void *p); \
00073 NFFT_EXTERN void X(die)(const char *s); \
00074 \
00075 /* You can replace the hooks with your own functions, if necessary. We */ \
00076 /* need this for the Matlab interface. */ \
00077 typedef void *(*X(malloc_type_function)) (size_t n); \
00078 typedef void  (*X(free_type_function)) (void *p); \
00079 typedef void  (*X(die_type_function)) (const char *errString); \
00080 NFFT_EXTERN X(malloc_type_function) X(malloc_hook); \
00081 NFFT_EXTERN X(free_type_function) X(free_hook); \
00082 NFFT_EXTERN X(die_type_function) X(die_hook);
00083 
00084 /* Nfft module API. */
00085 NFFT_DEFINE_MALLOC_API(NFFT_MANGLE_FLOAT)
00086 NFFT_DEFINE_MALLOC_API(NFFT_MANGLE_DOUBLE)
00087 NFFT_DEFINE_MALLOC_API(NFFT_MANGLE_LONG_DOUBLE)
00088 
00089 /* Macro to define prototypes for all NFFT API functions.
00090  * We expand this macro for each supported precision.
00091  *   X: NFFT name-mangling macro
00092  *   Y: FFTW name-mangling macro
00093  *   R: Real float type
00094  *   C: Complex float type
00095  */
00096 #define NFFT_DEFINE_API(X,Y,R,C) \
00097 \
00098 typedef struct \
00099 { \
00100   MACRO_MV_PLAN(C) \
00101 } X(mv_plan_complex); \
00102 \
00103 typedef struct \
00104 { \
00105   MACRO_MV_PLAN(R) \
00106 } X(mv_plan_double); \
00107 \
00108  \
00109 typedef struct\
00110 {\
00111   MACRO_MV_PLAN(C)\
00112 \
00113   NFFT_INT d; \
00114   NFFT_INT *N; \
00115   R *sigma; \
00116   NFFT_INT *n; \
00118   NFFT_INT n_total; \
00119   NFFT_INT m; \
00125   R *b; \
00126   NFFT_INT K; \
00128 \
00129   unsigned flags; \
00133 \
00134   unsigned fftw_flags; \
00136 \
00137   R *x; \
00138 \
00139   R MEASURE_TIME_t[3]; \
00141 \
00142   /* internal use only */\
00143   Y(plan) my_fftw_plan1; \
00144   Y(plan) my_fftw_plan2; \
00145 \
00146   R **c_phi_inv; \
00148   R *psi; \
00150   NFFT_INT *psi_index_g; \
00151   NFFT_INT *psi_index_f; \
00152 \
00153   C *g; \
00154   C *g_hat; \
00155   C *g1; \
00156   C *g2; \
00157 \
00158   R *spline_coeffs; \
00159 \
00160   NFFT_INT *index_x; \
00161 } X(plan); \
00162 \
00163 NFFT_EXTERN void X(trafo_direct)(const X(plan) *ths);\
00164 NFFT_EXTERN void X(adjoint_direct)(const X(plan) *ths);\
00165 NFFT_EXTERN void X(trafo)(X(plan) *ths);\
00166 NFFT_EXTERN void X(trafo_1d)(X(plan) *ths);\
00167 NFFT_EXTERN void X(trafo_2d)(X(plan) *ths);\
00168 NFFT_EXTERN void X(trafo_3d)(X(plan) *ths);\
00169 NFFT_EXTERN void X(adjoint)(X(plan) *ths);\
00170 NFFT_EXTERN void X(adjoint_1d)(X(plan) *ths);\
00171 NFFT_EXTERN void X(adjoint_2d)(X(plan) *ths);\
00172 NFFT_EXTERN void X(adjoint_3d)(X(plan) *ths);\
00173 NFFT_EXTERN void X(init_1d)(X(plan) *ths, int N1, int M);\
00174 NFFT_EXTERN void X(init_2d)(X(plan) *ths, int N1, int N2, int M);\
00175 NFFT_EXTERN void X(init_3d)(X(plan) *ths, int N1, int N2, int N3, int M);\
00176 NFFT_EXTERN void X(init)(X(plan) *ths, int d, int *N, int M);\
00177 NFFT_EXTERN void X(init_guru)(X(plan) *ths, int d, int *N, int M, int *n, \
00178   int m, unsigned flags, unsigned fftw_flags);\
00179 NFFT_EXTERN void X(init_lin)(X(plan) *ths, int d, int *N, int M, int *n, \
00180   int m, int K, unsigned flags, unsigned fftw_flags); \
00181 NFFT_EXTERN void X(precompute_one_psi)(X(plan) *ths);\
00182 NFFT_EXTERN void X(precompute_psi)(X(plan) *ths);\
00183 NFFT_EXTERN void X(precompute_full_psi)(X(plan) *ths);\
00184 NFFT_EXTERN void X(precompute_fg_psi)(X(plan) *ths); \
00185 NFFT_EXTERN void X(precompute_lin_psi)(X(plan) *ths);\
00186 NFFT_EXTERN const char* X(check)(X(plan) *ths);\
00187 NFFT_EXTERN void X(finalize)(X(plan) *ths);
00188 
00189 /* Nfft module API. */
00190 NFFT_DEFINE_API(NFFT_MANGLE_FLOAT,FFTW_MANGLE_FLOAT,float,fftwf_complex)
00191 NFFT_DEFINE_API(NFFT_MANGLE_DOUBLE,FFTW_MANGLE_DOUBLE,double,fftw_complex)
00192 NFFT_DEFINE_API(NFFT_MANGLE_LONG_DOUBLE,FFTW_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
00193 
00194 /* Flags for init routines. */
00195 #define PRE_PHI_HUT                (1U<<0)
00196 #define FG_PSI                     (1U<<1)
00197 #define PRE_LIN_PSI                (1U<<2)
00198 #define PRE_FG_PSI                 (1U<<3)
00199 #define PRE_PSI                    (1U<<4)
00200 #define PRE_FULL_PSI               (1U<<5)
00201 #define MALLOC_X                   (1U<<6)
00202 #define MALLOC_F_HAT               (1U<<7)
00203 #define MALLOC_F                   (1U<<8)
00204 #define FFT_OUT_OF_PLACE           (1U<<9)
00205 #define FFTW_INIT                  (1U<<10)
00206 #define NFFT_SORT_NODES            (1U<<11)
00207 #define NFFT_OMP_BLOCKWISE_ADJOINT (1U<<12)
00208 #define PRE_ONE_PSI (PRE_LIN_PSI| PRE_FG_PSI| PRE_PSI| PRE_FULL_PSI)
00209 
00210 /* nfct */
00211 
00212 /* name mangling macros */
00213 #define NFCT_MANGLE_DOUBLE(name) NFFT_CONCAT(nfct_, name)
00214 #define NFCT_MANGLE_FLOAT(name) NFFT_CONCAT(nfctf_, name)
00215 #define NFCT_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(nfctl_, name)
00216 
00217 /* huge second-order macro that defines prototypes for all nfct API functions.
00218  * We expand this macro for each supported precision.
00219  *   X: nfct name-mangling macro
00220  *   Y: fftw name-mangling macro
00221  *   R: real data type
00222  *   C: complex data type
00223  */
00224 #define NFCT_DEFINE_API(X,Y,R,C) \
00225  \
00226 typedef struct\
00227 {\
00228   /* api */\
00229   MACRO_MV_PLAN(R)\
00230 \
00231   NFFT_INT d; \
00232   NFFT_INT *N; \
00233   NFFT_INT *n; \
00234   NFFT_INT n_total; \
00235   R *sigma; \
00236   NFFT_INT m; \
00237 \
00238   R *b; \
00239   NFFT_INT K; \
00241 \
00242   unsigned flags; \
00243   unsigned fftw_flags; \
00244 \
00245   R *x; \
00246 \
00247   double MEASURE_TIME_t[3]; \
00248 \
00249   /* internal use only */\
00250   Y(plan)  my_fftw_r2r_plan; \
00251   Y(r2r_kind) *r2r_kind; \
00252 \
00253   R **c_phi_inv; \
00254   R *psi; \
00255   NFFT_INT size_psi; \
00256   NFFT_INT *psi_index_g; \
00257   NFFT_INT *psi_index_f; \
00258 \
00259   R *g;\
00260   R *g_hat;\
00261   R *g1; \
00262   R *g2; \
00263 \
00264   R *spline_coeffs; \
00265 } X(plan);\
00266 \
00267 NFFT_EXTERN void X(init_1d)(X(plan) *ths_plan, int N0, int M_total); \
00268 NFFT_EXTERN void X(init_2d)(X(plan) *ths_plan, int N0, int N1, int M_total); \
00269 NFFT_EXTERN void X(init_3d)(X(plan) *ths_plan, int N0, int N1, int N2, int M_total); \
00270 NFFT_EXTERN void X(init)(X(plan) *ths_plan, int d, int *N, int M_total); \
00271 NFFT_EXTERN void X(init_guru)(X(plan) *ths_plan, int d, int *N, int M_total, int *n, \
00272   int m, unsigned flags, unsigned fftw_flags); \
00273 NFFT_EXTERN void X(precompute_one_psi)(X(plan) *ths);\
00274 NFFT_EXTERN void X(precompute_psi)(X(plan) *ths);\
00275 NFFT_EXTERN void X(precompute_full_psi)(X(plan) *ths);\
00276 NFFT_EXTERN void X(precompute_fg_psi)(X(plan) *ths); \
00277 NFFT_EXTERN void X(precompute_lin_psi)(X(plan) *ths);\
00278 NFFT_EXTERN void X(trafo)(X(plan) *ths_plan); \
00279 NFFT_EXTERN void X(trafo_direct)(const X(plan) *ths_plan); \
00280 NFFT_EXTERN void X(adjoint)(X(plan) *ths_plan); \
00281 NFFT_EXTERN void X(adjoint_direct)(const X(plan) *ths_plan); \
00282 NFFT_EXTERN const char* X(check)(X(plan) *ths);\
00283 NFFT_EXTERN void X(finalize)(X(plan) *ths_plan); \
00284 
00285 /* nfct api */
00286 NFCT_DEFINE_API(NFCT_MANGLE_FLOAT,FFTW_MANGLE_FLOAT,float,fftwf_complex)
00287 NFCT_DEFINE_API(NFCT_MANGLE_DOUBLE,FFTW_MANGLE_DOUBLE,double,fftw_complex)
00288 NFCT_DEFINE_API(NFCT_MANGLE_LONG_DOUBLE,FFTW_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
00289 
00290 /* nfst */
00291 
00292 /* name mangling macros */
00293 #define NFST_MANGLE_DOUBLE(name) NFFT_CONCAT(nfst_, name)
00294 #define NFST_MANGLE_FLOAT(name) NFFT_CONCAT(nfstf_, name)
00295 #define NFST_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(nfstl_, name)
00296 
00297 /* huge second-order macro that defines prototypes for all nfct API functions.
00298  * We expand this macro for each supported precision.
00299  *   X: nfst name-mangling macro
00300  *   Y: fftw name-mangling macro
00301  *   R: real data type
00302  *   C: complex data type
00303  */
00304 #define NFST_DEFINE_API(X,Y,R,C) \
00305  \
00306 typedef struct\
00307 {\
00308   /* api */\
00309   MACRO_MV_PLAN(R)\
00310 \
00311   NFFT_INT d; \
00312   NFFT_INT *N; \
00313   NFFT_INT *n; \
00314   NFFT_INT n_total; \
00315   R *sigma; \
00316   NFFT_INT m; \
00317 \
00318   R *b; \
00319   NFFT_INT K; \
00321 \
00322   unsigned flags; \
00323   unsigned fftw_flags; \
00324 \
00325   R *x; \
00326 \
00327   double MEASURE_TIME_t[3]; \
00328 \
00329   /* internal use only */\
00330   Y(plan)  my_fftw_r2r_plan; \
00331   Y(r2r_kind) *r2r_kind; \
00332 \
00333   R **c_phi_inv; \
00334   R *psi; \
00335   NFFT_INT size_psi; \
00336   NFFT_INT *psi_index_g; \
00337   NFFT_INT *psi_index_f; \
00338 \
00339   R *g;\
00340   R *g_hat;\
00341   R *g1; \
00342   R *g2; \
00343 \
00344   R *spline_coeffs; \
00345 \
00346   R X(full_psi_eps);\
00347 } X(plan);\
00348 \
00349 NFFT_EXTERN void X(init_1d)(X(plan) *ths_plan, int N0, int M_total); \
00350 NFFT_EXTERN void X(init_2d)(X(plan) *ths_plan, int N0, int N1, int M_total); \
00351 NFFT_EXTERN void X(init_3d)(X(plan) *ths_plan, int N0, int N1, int N2, int M_total); \
00352 NFFT_EXTERN void X(init)(X(plan) *ths_plan, int d, int *N, int M_total); \
00353 NFFT_EXTERN void X(init_guru)(X(plan) *ths_plan, int d, int *N, int M_total, int *n, \
00354   int m, unsigned flags, unsigned fftw_flags); \
00355 NFFT_EXTERN void X(precompute_one_psi)(X(plan) *ths);\
00356 NFFT_EXTERN void X(precompute_psi)(X(plan) *ths);\
00357 NFFT_EXTERN void X(precompute_full_psi)(X(plan) *ths);\
00358 NFFT_EXTERN void X(precompute_fg_psi)(X(plan) *ths); \
00359 NFFT_EXTERN void X(precompute_lin_psi)(X(plan) *ths);\
00360 NFFT_EXTERN void X(trafo)(X(plan) *ths_plan); \
00361 NFFT_EXTERN void X(trafo_direct)(const X(plan) *ths_plan); \
00362 NFFT_EXTERN void X(adjoint)(X(plan) *ths_plan); \
00363 NFFT_EXTERN void X(adjoint_direct)(const X(plan) *ths_plan); \
00364 NFFT_EXTERN const char* X(check)(X(plan) *ths);\
00365 NFFT_EXTERN void X(finalize)(X(plan) *ths_plan); \
00366 
00367 /* nfst api */
00368 NFST_DEFINE_API(NFST_MANGLE_FLOAT,FFTW_MANGLE_FLOAT,float,fftwf_complex)
00369 NFST_DEFINE_API(NFST_MANGLE_DOUBLE,FFTW_MANGLE_DOUBLE,double,fftw_complex)
00370 NFST_DEFINE_API(NFST_MANGLE_LONG_DOUBLE,FFTW_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
00371 
00372 /* nnfft */
00373 
00374 /* name mangling macros */
00375 #define NNFFT_MANGLE_DOUBLE(name) NFFT_CONCAT(nnfft_, name)
00376 #define NNFFT_MANGLE_FLOAT(name) NFFT_CONCAT(nnfftf_, name)
00377 #define NNFFT_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(nnfftl_, name)
00378 
00379 /* huge second-order macro that defines prototypes for all nfst API functions.
00380  * We expand this macro for each supported precision.
00381  *   X: nnfft name-mangling macro
00382  *   Y: fftw name-mangling macro
00383  *   Z: nfft name mangling macro
00384  *   R: real data type
00385  *   C: complex data type
00386  */
00387 #define NNFFT_DEFINE_API(X,Y,Z,R,C) \
00388  \
00389 typedef struct\
00390 {\
00391   /* api */\
00392   MACRO_MV_PLAN(C)\
00393 \
00394   int d; \
00395   R *sigma; \
00396   R *a; \
00397   int *N; \
00398   int *N1; \
00399   int *aN1; \
00400   int m; \
00401   R *b; \
00402   int K; \
00403   int aN1_total; \
00404   Z(plan) *direct_plan; \
00405   unsigned nnfft_flags; \
00406   int *n; \
00407   R *x; \
00408   R *v; \
00409   R *c_phi_inv; \
00410   R *psi; \
00411   int size_psi; \
00412   int *psi_index_g; \
00413   int *psi_index_f; \
00414   C *F;\
00415   R *spline_coeffs; \
00416 } X(plan);\
00417 \
00418 NFFT_EXTERN void X(init)(X(plan) *ths_plan, int d, int N_total, int M_total, int *N); \
00419 NFFT_EXTERN void X(init_1d)(X(plan) *ths_plan, int N, int M_total); \
00420 NFFT_EXTERN void X(init_guru)(X(plan) *ths_plan, int d, int N_total, int M_total, \
00421   int *N, int *N1, int m, unsigned nnfft_flags); \
00422 NFFT_EXTERN void X(trafo_direct)(X(plan) *ths_plan); \
00423 NFFT_EXTERN void X(adjoint_direct)(X(plan) *ths_plan); \
00424 NFFT_EXTERN void X(trafo)(X(plan) *ths_plan); \
00425 NFFT_EXTERN void X(adjoint)(X(plan) *ths_plan); \
00426 NFFT_EXTERN void X(precompute_lin_psi)(X(plan) *ths_plan); \
00427 NFFT_EXTERN void X(precompute_psi)(X(plan) *ths_plan); \
00428 NFFT_EXTERN void X(precompute_full_psi)(X(plan) *ths_plan); \
00429 NFFT_EXTERN void X(precompute_phi_hut)(X(plan) *ths_plan); \
00430 NFFT_EXTERN void X(precompute_one_psi)(X(plan) *ths);\
00431 NFFT_EXTERN void X(finalize)(X(plan) *ths_plan);
00432 
00433 /* nnfft api */
00434 NNFFT_DEFINE_API(NNFFT_MANGLE_FLOAT,FFTW_MANGLE_FLOAT,NFFT_MANGLE_FLOAT,float,fftwf_complex)
00435 NNFFT_DEFINE_API(NNFFT_MANGLE_DOUBLE,FFTW_MANGLE_DOUBLE,NFFT_MANGLE_DOUBLE,double,fftw_complex)
00436 NNFFT_DEFINE_API(NNFFT_MANGLE_LONG_DOUBLE,FFTW_MANGLE_LONG_DOUBLE,NFFT_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
00437 
00438 /* additional init flags */
00439 #define MALLOC_V         (1U<< 11)
00440 
00441 /* nsfft */
00442 
00443 #define NSFFT_MANGLE_DOUBLE(name) NFFT_CONCAT(nsfft_, name)
00444 #define NSFFT_MANGLE_FLOAT(name) NFFT_CONCAT(nsfftf_, name)
00445 #define NSFFT_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(nsfftl_, name)
00446 
00447 /* huge second-order macro that defines prototypes for all nnfft API functions.
00448  * We expand this macro for each supported precision.
00449  *   X: nnfft name-mangling macro
00450  *   Y: fftw name-mangling macro
00451  *   Z: nfft name mangling macro
00452  *   R: real data type
00453  *   C: complex data type
00454  */
00455 #define NSFFT_DEFINE_API(X,Y,Z,R,C) \
00456  \
00457 typedef struct\
00458 {\
00459   MACRO_MV_PLAN(C)\
00460 \
00461   int d; \
00462   int J; \
00465   int sigma; \
00466   unsigned flags; \
00467   int *index_sparse_to_full; \
00468   int r_act_nfft_plan; \
00469   Z(plan) *act_nfft_plan; \
00470   Z(plan) *center_nfft_plan; \
00471   Y(plan) *set_fftw_plan1; \
00472   Y(plan) *set_fftw_plan2; \
00473   Z(plan) *set_nfft_plan_1d; \
00474   Z(plan) *set_nfft_plan_2d; \
00475   R *x_transposed; \
00476   R *x_102,*x_201,*x_120,*x_021; \
00477 } X(plan);\
00478 \
00479 NFFT_EXTERN void X(trafo_direct)(X(plan) *ths); \
00480 NFFT_EXTERN void X(adjoint_direct)(X(plan) *ths); \
00481 NFFT_EXTERN void X(trafo)(X(plan) *ths); \
00482 NFFT_EXTERN void X(adjoint)(X(plan) *ths); \
00483 NFFT_EXTERN void X(cp)(X(plan) *ths, Z(plan) *ths_nfft); \
00484 NFFT_EXTERN void X(init_random_nodes_coeffs)(X(plan) *ths); \
00485 NFFT_EXTERN void X(init)(X(plan) *ths, int d, int J, int M, int m, unsigned flags); \
00486 NFFT_EXTERN void X(finalize)(X(plan) *ths);
00487 
00488 /* nsfft api */
00489 NSFFT_DEFINE_API(NSFFT_MANGLE_FLOAT,FFTW_MANGLE_FLOAT,NFFT_MANGLE_FLOAT,float,fftwf_complex)
00490 NSFFT_DEFINE_API(NSFFT_MANGLE_DOUBLE,FFTW_MANGLE_DOUBLE,NFFT_MANGLE_DOUBLE,double,fftw_complex)
00491 NSFFT_DEFINE_API(NSFFT_MANGLE_LONG_DOUBLE,FFTW_MANGLE_LONG_DOUBLE,NFFT_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
00492 
00493 /* additional init flags */
00494 #define NSDFT            (1U<< 12)
00495 
00496 /* mri */
00497 
00498 /* name mangling macros */
00499 #define MRI_MANGLE_DOUBLE(name) NFFT_CONCAT(mri_, name)
00500 #define MRI_MANGLE_FLOAT(name) NFFT_CONCAT(mrif_, name)
00501 #define MRI_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(mril_, name)
00502 
00503 /* huge second-order macro that defines prototypes for all mri API functions.
00504  * We expand this macro for each supported precision.
00505  *   X: mri name-mangling macro
00506  *   Z: nfft name mangling macro
00507  *   R: real data type
00508  *   C: complex data type
00509  */
00510 #define MRI_DEFINE_API(X,Z,R,C) \
00511 typedef struct\
00512 {\
00513   MACRO_MV_PLAN(C)\
00514   Z(plan) plan;\
00515   int N3;\
00516   R sigma3;\
00517   R *t;\
00518   R *w;\
00519 } X(inh_2d1d_plan);\
00520 \
00521 typedef struct\
00522 {\
00523   MACRO_MV_PLAN(C)\
00524   Z(plan) plan;\
00525   int N3;\
00526   R sigma3;\
00527   R *t;\
00528   R *w;\
00529 } X(inh_3d_plan);\
00530 \
00531 void X(inh_2d1d_trafo)(X(inh_2d1d_plan) *ths); \
00532 void X(inh_2d1d_adjoint)(X(inh_2d1d_plan) *ths); \
00533 void X(inh_2d1d_init_guru)(X(inh_2d1d_plan) *ths, int *N, int M, int *n, \
00534   int m, R sigma, unsigned nfft_flags, unsigned fftw_flags); \
00535 void X(inh_2d1d_finalize)(X(inh_2d1d_plan) *ths); \
00536 void X(inh_3d_trafo)(X(inh_3d_plan) *ths); \
00537 void X(inh_3d_adjoint)(X(inh_3d_plan) *ths); \
00538 void X(inh_3d_init_guru)(X(inh_3d_plan) *ths, int *N, int M, int *n, \
00539   int m, R sigma, unsigned nfft_flags, unsigned fftw_flags); \
00540 void X(inh_3d_finalize)(X(inh_3d_plan) *ths);
00541 
00542   /* mri api */
00543 MRI_DEFINE_API(MRI_MANGLE_FLOAT,NFFT_MANGLE_FLOAT,float,fftwf_complex)
00544 MRI_DEFINE_API(MRI_MANGLE_DOUBLE,NFFT_MANGLE_DOUBLE,double,fftw_complex)
00545 MRI_DEFINE_API(MRI_MANGLE_LONG_DOUBLE,NFFT_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
00546 
00547 /* nfsft */
00548 
00549 /* name mangling macros */
00550 #define NFSFT_MANGLE_DOUBLE(name) NFFT_CONCAT(nfsft_, name)
00551 #define NFSFT_MANGLE_FLOAT(name) NFFT_CONCAT(nfsftf_, name)
00552 #define NFSFT_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(nfsftl_, name)
00553 
00554 /* huge second-order macro that defines prototypes for all nfsft API functions.
00555  * We expand this macro for each supported precision.
00556  *   X: nfsft name-mangling macro
00557  *   Z: nfft name mangling macro
00558  *   R: real data type
00559  *   C: complex data type
00560  */
00561 #define NFSFT_DEFINE_API(X,Z,R,C) \
00562  \
00563 typedef struct\
00564 {\
00565   MACRO_MV_PLAN(C)\
00566   int N; \
00567   R *x; \
00570   /* internal use only */\
00571   int t; \
00572   unsigned int flags; \
00573   Z(plan) plan_nfft; \
00574   C *f_hat_intern; \
00576   double MEASURE_TIME_t[3]; \
00578 } X(plan);\
00579 \
00580 NFFT_EXTERN void X(init)(X(plan) *plan, int N, int M); \
00581 NFFT_EXTERN void X(init_advanced)(X(plan)* plan, int N, int M, unsigned int \
00582   nfsft_flags); \
00583 NFFT_EXTERN void X(init_guru)(X(plan) *plan, int N, int M, \
00584   unsigned int nfsft_flags, unsigned int nfft_flags, int nfft_cutoff); \
00585 NFFT_EXTERN void X(precompute)(int N, R kappa, unsigned int nfsft_flags, \
00586   unsigned int fpt_flags); \
00587 NFFT_EXTERN void X(forget)(void); \
00588 NFFT_EXTERN void X(trafo_direct)(X(plan)* plan); \
00589 NFFT_EXTERN void X(adjoint_direct)(X(plan)* plan); \
00590 NFFT_EXTERN void X(trafo)(X(plan)* plan); \
00591 NFFT_EXTERN void X(adjoint)(X(plan)* plan); \
00592 NFFT_EXTERN void X(finalize)(X(plan) *plan); \
00593 NFFT_EXTERN void X(precompute_x)(X(plan) *plan);
00594 
00595 /* nfsft api */
00596 NFSFT_DEFINE_API(NFSFT_MANGLE_FLOAT,NFFT_MANGLE_FLOAT,float,fftwf_complex)
00597 NFSFT_DEFINE_API(NFSFT_MANGLE_DOUBLE,NFFT_MANGLE_DOUBLE,double,fftw_complex)
00598 NFSFT_DEFINE_API(NFSFT_MANGLE_LONG_DOUBLE,NFFT_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
00599 
00600 /* init flags */
00601 #define NFSFT_NORMALIZED     (1U << 0)
00602 #define NFSFT_USE_NDFT       (1U << 1)
00603 #define NFSFT_USE_DPT        (1U << 2)
00604 #define NFSFT_MALLOC_X       (1U << 3)
00605 #define NFSFT_MALLOC_F_HAT   (1U << 5)
00606 #define NFSFT_MALLOC_F       (1U << 6)
00607 #define NFSFT_PRESERVE_F_HAT (1U << 7)
00608 #define NFSFT_PRESERVE_X     (1U << 8)
00609 #define NFSFT_PRESERVE_F     (1U << 9)
00610 #define NFSFT_DESTROY_F_HAT  (1U << 10)
00611 #define NFSFT_DESTROY_X      (1U << 11)
00612 #define NFSFT_DESTROY_F      (1U << 12)
00613 
00614 /* precompute flags */
00615 #define NFSFT_NO_DIRECT_ALGORITHM (1U << 13)
00616 #define NFSFT_NO_FAST_ALGORITHM   (1U << 14)
00617 #define NFSFT_ZERO_F_HAT          (1U << 16)
00618 
00619 /* helper macros */
00620 #define NFSFT_INDEX(k,n,plan) ((2*(plan)->N+2)*((plan)->N-n+1)+(plan)->N+k+1)
00621 #define NFSFT_F_HAT_SIZE(N) ((2*N+2)*(2*N+2))
00622 
00623 /* fpt */
00624 
00625 /* name mangling macros */
00626 #define FPT_MANGLE_DOUBLE(name) NFFT_CONCAT(fpt_, name)
00627 #define FPT_MANGLE_FLOAT(name) NFFT_CONCAT(fptf_, name)
00628 #define FPT_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(fptl_, name)
00629 
00630 /* huge second-order macro that defines prototypes for all fpt API functions.
00631  * We expand this macro for each supported precision.
00632  *   X: fpt name-mangling macro
00633  *   R: real data type
00634  *   C: complex data type
00635  */
00636 #define FPT_DEFINE_API(X,Y,R,C) \
00637 typedef struct X(set_s_) *X(set); \
00639 \
00640 NFFT_EXTERN X(set) X(init)(const int M, const int t, const unsigned int flags); \
00641 NFFT_EXTERN void X(precompute)(X(set) set, const int m, R *alpha, R *beta, \
00642   R *gam, int k_start, const R threshold); \
00643 NFFT_EXTERN void X(trafo_direct)(X(set) set, const int m, const C *x, C *y, \
00644   const int k_end, const unsigned int flags); \
00645 NFFT_EXTERN void X(trafo)(X(set) set, const int m, const C *x, C *y, \
00646   const int k_end, const unsigned int flags); \
00647 NFFT_EXTERN void X(transposed_direct)(X(set) set, const int m, C *x, \
00648   C *y, const int k_end, const unsigned int flags); \
00649 NFFT_EXTERN void X(transposed)(X(set) set, const int m, C *x, \
00650   C *y, const int k_end, const unsigned int flags); \
00651 NFFT_EXTERN void X(finalize)(X(set) set);
00652 
00653 /* fpt api */
00654 FPT_DEFINE_API(FPT_MANGLE_FLOAT,FFTW_MANGLE_FLOAT,float,fftwf_complex)
00655 FPT_DEFINE_API(FPT_MANGLE_DOUBLE,FFTW_MANGLE_DOUBLE,double,fftw_complex)
00656 FPT_DEFINE_API(FPT_MANGLE_LONG_DOUBLE,FFTW_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
00657 
00658 /* init flags */
00659 #define FPT_NO_STABILIZATION    (1U << 0)
00660 #define FPT_NO_FAST_ALGORITHM   (1U << 2)
00661 #define FPT_NO_DIRECT_ALGORITHM (1U << 3)
00662 #define FPT_PERSISTENT_DATA     (1U << 4)
00663 
00664 /* transform flags */
00665 #define FPT_FUNCTION_VALUES     (1U << 5)
00666 #define FPT_AL_SYMMETRY         (1U << 6)
00667 
00668 /* nfsoft*/
00669 
00670 /* name mangling macros */
00671 #define NFSOFT_MANGLE_DOUBLE(name) NFFT_CONCAT(nfsoft_, name)
00672 #define NFSOFT_MANGLE_FLOAT(name) NFFT_CONCAT(nfsoftf_, name)
00673 #define NFSOFT_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(nfsoftl_, name)
00674 
00675 /* huge second-order macro that defines prototypes for all nfsoft API functions.
00676  * We expand this macro for each supported precision.
00677  *   X: nfsoft name-mangling macro
00678  *   Y: nfft name-mangling macro
00679  *   Z: fpt name-mangling macro
00680  *   R: real data type
00681  *   C: complex data type
00682  */
00683 #define NFSOFT_DEFINE_API(X,Y,Z,R,C) \
00684 typedef struct X(plan_)\
00685 {\
00686   MACRO_MV_PLAN(C) \
00687   R *x; \
00688   C *wig_coeffs; \
00690   C *cheby; \
00692   C *aux; \
00693   /* internal use only */\
00694   int t; \
00695   unsigned int flags; \
00696   Y(plan) p_nfft; \
00697   Z(set) internal_fpt_set; \
00698   int fpt_kappa; \
00699 } X(plan);\
00700 \
00701 NFFT_EXTERN void X(precompute)(X(plan) *plan); \
00702 NFFT_EXTERN Z(set) X(SO3_single_fpt_init)(int l, int k, int m, unsigned int flags, int kappa); \
00703 NFFT_EXTERN void X(SO3_fpt)(C *coeffs, Z(set) set, int l, int k, int m, unsigned int nfsoft_flags); \
00704 NFFT_EXTERN void X(SO3_fpt_transposed)(C *coeffs, Z(set) set,int l, int k, int m,unsigned int nfsoft_flags); \
00705 NFFT_EXTERN void X(init)(X(plan) *plan, int N, int M); \
00706 NFFT_EXTERN void X(init_advanced)(X(plan) *plan, int N, int M,unsigned int nfsoft_flags); \
00707 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); \
00708 NFFT_EXTERN void X(trafo)(X(plan) *plan_nfsoft); \
00709 NFFT_EXTERN void X(adjoint)(X(plan) *plan_nfsoft); \
00710 NFFT_EXTERN void X(finalize)(X(plan) *plan); \
00711 NFFT_EXTERN int X(posN)(int n,int m, int B);
00712 
00713 /* nfsoft api */
00714 NFSOFT_DEFINE_API(NFSOFT_MANGLE_FLOAT,NFFT_MANGLE_FLOAT,FPT_MANGLE_FLOAT,float,fftwf_complex)
00715 NFSOFT_DEFINE_API(NFSOFT_MANGLE_DOUBLE,NFFT_MANGLE_DOUBLE,FPT_MANGLE_DOUBLE,double,fftw_complex)
00716 NFSOFT_DEFINE_API(NFSOFT_MANGLE_LONG_DOUBLE,NFFT_MANGLE_LONG_DOUBLE,FPT_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
00717 
00718 /* init flags */
00719 #define NFSOFT_NORMALIZED     (1U << 0)
00720 #define NFSOFT_USE_NDFT       (1U << 1)
00721 #define NFSOFT_USE_DPT        (1U << 2)
00722 #define NFSOFT_MALLOC_X       (1U << 3)
00723 #define NFSOFT_REPRESENT      (1U << 4)
00724 #define NFSOFT_MALLOC_F_HAT   (1U << 5)
00725 #define NFSOFT_MALLOC_F       (1U << 6)
00726 #define NFSOFT_PRESERVE_F_HAT (1U << 7)
00727 #define NFSOFT_PRESERVE_X     (1U << 8)
00728 #define NFSOFT_PRESERVE_F     (1U << 9)
00729 #define NFSOFT_DESTROY_F_HAT  (1U << 10)
00730 #define NFSOFT_DESTROY_X      (1U << 11)
00731 #define NFSOFT_DESTROY_F      (1U << 12)
00732 
00733 /* precompute flags */
00734 #define NFSOFT_NO_STABILIZATION (1U << 13)
00735 #define NFSOFT_CHOOSE_DPT       (1U << 14)
00736 #define NFSOFT_SOFT             (1U << 15)
00737 #define NFSOFT_ZERO_F_HAT       (1U << 16)
00738 
00739 /* helper macros */
00740 #define NFSOFT_INDEX(m,n,l,B) (((l)+((B)+1))+(2*(B)+2)*(((n)+((B)+1))+(2*(B)+2)*((m)+((B)+1))))
00741 #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)))
00742 #define NFSOFT_F_HAT_SIZE(B) (((B)+1)*(4*((B)+1)*((B)+1)-1)/3)
00743 
00744 /* solver */
00745 
00746 /* name mangling macros */
00747 #define SOLVER_MANGLE_DOUBLE(name) NFFT_CONCAT(solver_, name)
00748 #define SOLVER_MANGLE_FLOAT(name) NFFT_CONCAT(solverf_, name)
00749 #define SOLVER_MANGLE_LONG_DOUBLE(name) NFFT_CONCAT(solverl_, name)
00750 
00751 /* huge second-order macro that defines prototypes for all nfsoft API functions.
00752  * We expand this macro for each supported precision.
00753  *   X: nfsoft name-mangling macro
00754  *   Y: nfft name-mangling macro
00755  *   R: real data type
00756  *   C: complex data type
00757  */
00758 #define SOLVER_DEFINE_API(X,Y,R,C)\
00759  \
00760 typedef struct\
00761 {\
00762   Y(mv_plan_complex) *mv; \
00763   unsigned flags; \
00764   R *w; \
00765   R *w_hat; \
00766   C *y; \
00767   C *f_hat_iter; \
00768   C *r_iter; \
00769   C *z_hat_iter; \
00770   C *p_hat_iter; \
00771   C *v_iter; \
00772   R alpha_iter; \
00773   R beta_iter; \
00774   R dot_r_iter; \
00775   R dot_r_iter_old; \
00776   R dot_z_hat_iter; \
00777   R dot_z_hat_iter_old; \
00778   R dot_p_hat_iter; \
00779   R dot_v_iter; \
00780 } X(plan_complex);\
00781 \
00782 NFFT_EXTERN void X(init_advanced_complex)(X(plan_complex)* ths, Y(mv_plan_complex) *mv, unsigned flags);\
00783 NFFT_EXTERN void X(init_complex)(X(plan_complex)* ths, Y(mv_plan_complex) *mv);\
00784 NFFT_EXTERN void X(before_loop_complex)(X(plan_complex)* ths);\
00785 NFFT_EXTERN void X(loop_one_step_complex)(X(plan_complex) *ths);\
00786 NFFT_EXTERN void X(finalize_complex)(X(plan_complex) *ths);\
00787 \
00788  \
00789 typedef struct\
00790 {\
00791   Y(mv_plan_double) *mv; \
00792   unsigned flags; \
00793   R *w; \
00794   R *w_hat; \
00795   R *y; \
00796   R *f_hat_iter; \
00797   R *r_iter; \
00798   R *z_hat_iter; \
00799   R *p_hat_iter; \
00800   R *v_iter; \
00801   R alpha_iter; \
00802   R beta_iter; \
00803   R dot_r_iter; \
00804   R dot_r_iter_old; \
00805   R dot_z_hat_iter; \
00806   R dot_z_hat_iter_old; \
00807   R dot_p_hat_iter; \
00808   R dot_v_iter; \
00809 } X(plan_double);\
00810 \
00811 NFFT_EXTERN void X(init_advanced_double)(X(plan_double)* ths, Y(mv_plan_double) *mv, unsigned flags);\
00812 NFFT_EXTERN void X(init_double)(X(plan_double)* ths, Y(mv_plan_double) *mv);\
00813 NFFT_EXTERN void X(before_loop_double)(X(plan_double)* ths);\
00814 NFFT_EXTERN void X(loop_one_step_double)(X(plan_double) *ths);\
00815 NFFT_EXTERN void X(finalize_double)(X(plan_double) *ths);
00816 
00817 /* solver api */
00818 SOLVER_DEFINE_API(SOLVER_MANGLE_FLOAT,NFFT_MANGLE_FLOAT,float,fftwf_complex)
00819 SOLVER_DEFINE_API(SOLVER_MANGLE_DOUBLE,NFFT_MANGLE_DOUBLE,double,fftw_complex)
00820 SOLVER_DEFINE_API(SOLVER_MANGLE_LONG_DOUBLE,NFFT_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
00821 
00822 /* init flags */
00823 #define LANDWEBER             (1U<< 0)
00824 #define STEEPEST_DESCENT      (1U<< 1)
00825 #define CGNR                  (1U<< 2)
00826 #define CGNE                  (1U<< 3)
00827 #define NORMS_FOR_LANDWEBER   (1U<< 4)
00828 #define PRECOMPUTE_WEIGHT     (1U<< 5)
00829 #define PRECOMPUTE_DAMP       (1U<< 6)
00830 
00831 /* util */
00832 
00833 /* huge second-order macro that defines prototypes for all utility API functions.
00834  * We expand this macro for each supported precision.
00835  *   Y: nfft name-mangling macro
00836  *   R: real data type
00837  *   C: complex data type
00838  */
00839 #define NFFT_DEFINE_UTIL_API(Y,R,C) \
00840 /* rand.c */ \
00841 R Y(drand48)(void); \
00842 void Y(srand48)(long int seed); \
00843 \
00844  \
00846 void Y(vrand_unit_complex)(C *x, const NFFT_INT n); \
00847 \
00848  \
00850 void Y(vrand_shifted_unit_double)(R *x, const NFFT_INT n); \
00851 \
00852 void Y(vrand_real)(R *x, const NFFT_INT n, const R a, const R b); \
00853 \
00854 /* print.c */ \
00855  \
00856 void Y(vpr_double)(R *x, const NFFT_INT n, const char *text); \
00857 \
00858  \
00859 void Y(vpr_complex)(C *x, const NFFT_INT n, const char *text); \
00860 /* thread.c */ \
00861 NFFT_INT Y(get_num_threads)(void); \
00862 /* time.c */ \
00863 R Y(clock_gettime_seconds)(void); \
00864 /* error.c: */ \
00865 R Y(error_l_infty_complex)(const C *x, const C *y, const NFFT_INT n); \
00866 R Y(error_l_infty_1_complex)(const C *x, const C *y, const NFFT_INT n, \
00867   const C *z, const NFFT_INT m); \
00868 /* int.c: */ \
00869 NFFT_INT Y(exp2i)(const NFFT_INT a); \
00870 NFFT_INT Y(next_power_of_2)(const NFFT_INT N); \
00871 /* vector1.c */ \
00872  \
00873 R Y(dot_complex)(C *x, NFFT_INT n); \
00874 /* vector3.c */ \
00875  \
00876 void Y(upd_axpy_complex)(C *x, R a, C *y, NFFT_INT n); \
00877  \
00878 void Y(fftshift_complex)(C *x, NFFT_INT d, NFFT_INT* N); \
00879 void Y(fftshift_complex_int)(C *x, int d, int* N); \
00880 void Y(get_version)(unsigned *major, unsigned *minor, unsigned *patch);
00881 
00882 NFFT_DEFINE_UTIL_API(NFFT_MANGLE_FLOAT,float,fftwf_complex)
00883 NFFT_DEFINE_UTIL_API(NFFT_MANGLE_DOUBLE,double,fftw_complex)
00884 NFFT_DEFINE_UTIL_API(NFFT_MANGLE_LONG_DOUBLE,long double,fftwl_complex)
00885 
00886 #ifdef __cplusplus
00887 }  /* extern "C" */
00888 #endif /* __cplusplus */
00889 
00890 #endif /* defined(__NFFT3_H__) */