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

Generated on Fri Oct 12 2012 by Doxygen 1.8.0-20120409