35 #define MACRO_nndft_init_result_trafo memset(f,0,ths->M_total*sizeof(double _Complex)); 
   36 #define MACRO_nndft_init_result_conjugated MACRO_nndft_init_result_trafo 
   37 #define MACRO_nndft_init_result_adjoint memset(f_hat,0,ths->N_total*sizeof(double _Complex)); 
   38 #define MACRO_nndft_init_result_transposed MACRO_nndft_init_result_adjoint 
   40 #define MACRO_nndft_sign_trafo      (-2.0*PI) 
   41 #define MACRO_nndft_sign_conjugated (+2.0*PI) 
   42 #define MACRO_nndft_sign_adjoint    (+2.0*PI) 
   43 #define MACRO_nndft_sign_transposed (-2.0*PI) 
   45 #define MACRO_nndft_compute_trafo (*fj) += (*f_hat_k)*cexp(+ _Complex_I*omega); 
   47 #define MACRO_nndft_compute_conjugated MACRO_nndft_compute_trafo 
   49 #define MACRO_nndft_compute_adjoint (*f_hat_k) += (*fj)*cexp(+ _Complex_I*omega); 
   51 #define MACRO_nndft_compute_transposed MACRO_nndft_compute_adjoint 
   53 #define MACRO_nndft(which_one)                                                \ 
   54 void nnfft_ ## which_one ## _direct (nnfft_plan *ths)                                    \ 
   59   double _Complex *f_hat, *f;          \ 
   60   double _Complex *f_hat_k;            \ 
   61   double _Complex *fj;                 \ 
   64   f_hat=ths->f_hat; f=ths->f;                                                 \ 
   66   MACRO_nndft_init_result_ ## which_one                                       \ 
   68   for(j=0, fj=f; j<ths->M_total; j++, fj++)                                   \ 
   70     for(l=0, f_hat_k=f_hat; l<ths->N_total; l++, f_hat_k++)                   \ 
   73       for(t = 0; t<ths->d; t++)                                               \ 
   74         omega+=ths->v[l*ths->d+t] * ths->x[j*ths->d+t] * ths->N[t];           \ 
   76       omega*= MACRO_nndft_sign_ ## which_one;                                 \ 
   78       MACRO_nndft_compute_ ## which_one                                       \ 
   89 static 
void nnfft_uo(
nnfft_plan *ths,
int j,
int *up,
int *op,
int act_dim)
 
   94   c = ths->v[j*ths->d+act_dim] * ths->n[act_dim];
 
  102   u = u - (ths->m); o = o + (ths->m);
 
  110 #define MACRO_nnfft_B_init_result_A memset(f,0,ths->N_total*sizeof(double _Complex)); 
  111 #define MACRO_nnfft_B_init_result_T memset(g,0,ths->aN1_total*sizeof(double _Complex)); 
  113 #define MACRO_nnfft_B_PRE_FULL_PSI_compute_A {                                \ 
  114   (*fj) += ths->psi[ix] * g[ths->psi_index_g[ix]];                            \ 
  117 #define MACRO_nnfft_B_PRE_FULL_PSI_compute_T {                                \ 
  118   g[ths->psi_index_g[ix]] += ths->psi[ix] * (*fj);                            \ 
  121 #define MACRO_nnfft_B_compute_A {                                             \ 
  122   (*fj) += phi_prod[ths->d] * g[ll_plain[ths->d]];                            \ 
  125 #define MACRO_nnfft_B_compute_T {                                             \ 
  126   g[ll_plain[ths->d]] += phi_prod[ths->d] * (*fj);                            \ 
  129 #define MACRO_with_PRE_LIN_PSI (ths->psi[(ths->K+1)*t2+y_u[t2]]*              \ 
  130                                 (y_u[t2]+1-y[t2]) +                           \ 
  131                                 ths->psi[(ths->K+1)*t2+y_u[t2]+1]*            \ 
  133 #define MACRO_with_PRE_PSI     ths->psi[(j*ths->d+t2)*(2*ths->m+2)+lj[t2]] 
  134 #define MACRO_without_PRE_PSI  PHI(-ths->v[j*ths->d+t2]+                      \ 
  135                                ((double)l[t2])/ths->N1[t2], t2) 
  137 #define MACRO_init_uo_l_lj_t {                                                \ 
  138   for(t = ths->d-1; t>=0; t--)                                                \ 
  140       nnfft_uo(ths,j,&u[t],&o[t],t);                                          \ 
  147 #define MACRO_update_with_PRE_PSI_LIN {                                       \ 
  148   for(t2=t; t2<ths->d; t2++)                                                  \ 
  150       y[t2] = fabs(((-ths->N1[t2]*ths->v[j*ths->d+t2]+(double)l[t2])          \ 
  151           * ((double)ths->K))/(ths->m+1));                                    \ 
  152       y_u[t2] = (int)y[t2];                                                   \ 
  156 #define MACRO_update_phi_prod_ll_plain(which_one) {                           \ 
  157   for(t2=t; t2<ths->d; t2++)                                                  \ 
  159       phi_prod[t2+1]=phi_prod[t2]* MACRO_ ## which_one;                       \ 
  160       ll_plain[t2+1]=ll_plain[t2]*ths->aN1[t2] +                              \ 
  161                      (l[t2]+ths->aN1[t2]*3/2)%ths->aN1[t2];                   \ 
  166 #define MACRO_count_uo_l_lj_t {                                               \ 
  167   for(t = ths->d-1; (t>0)&&(l[t]==o[t]); t--)                                 \ 
  177 #define MACRO_nnfft_B(which_one)                                              \ 
  178 static inline void nnfft_B_ ## which_one (nnfft_plan *ths)                    \ 
  181   int u[ths->d], o[ths->d];            \ 
  187   int ll_plain[ths->d+1];              \ 
  188   double phi_prod[ths->d+1];           \ 
  189   double _Complex *f, *g;              \ 
  190   double _Complex *fj;                 \ 
  194   f=ths->f_hat; g=ths->F;                                                     \ 
  196   MACRO_nnfft_B_init_result_ ## which_one                                     \ 
  198   if(ths->nnfft_flags & PRE_FULL_PSI)                                         \ 
  200       for(ix=0, j=0, fj=f; j<ths->N_total; j++,fj++)                          \ 
  201         for(l_L=0; l_L<ths->psi_index_f[j]; l_L++, ix++)                      \ 
  202           MACRO_nnfft_B_PRE_FULL_PSI_compute_ ## which_one;                   \ 
  209   for(t=0,lprod = 1; t<ths->d; t++)                                           \ 
  210     lprod *= (2*ths->m+2);                                                    \ 
  212   if(ths->nnfft_flags & PRE_PSI)                                              \ 
  214       for(j=0, fj=f; j<ths->N_total; j++, fj++)                               \ 
  216           MACRO_init_uo_l_lj_t;                                               \ 
  218           for(l_L=0; l_L<lprod; l_L++)                                        \ 
  220               MACRO_update_phi_prod_ll_plain(with_PRE_PSI);                   \ 
  222               MACRO_nnfft_B_compute_ ## which_one;                            \ 
  224               MACRO_count_uo_l_lj_t;                                          \ 
  230   if(ths->nnfft_flags & PRE_LIN_PSI)                                          \ 
  232       for(j=0, fj=f; j<ths->N_total; j++, fj++)                               \ 
  234           MACRO_init_uo_l_lj_t;                                               \ 
  236           for(l_L=0; l_L<lprod; l_L++)                                        \ 
  238               MACRO_update_with_PRE_PSI_LIN;                                  \ 
  240               MACRO_update_phi_prod_ll_plain(with_PRE_LIN_PSI);               \ 
  242               MACRO_nnfft_B_compute_ ## which_one;                            \ 
  244               MACRO_count_uo_l_lj_t;                                          \ 
  251   for(j=0, fj=f; j<ths->N_total; j++, fj++)                                   \ 
  254       MACRO_init_uo_l_lj_t;                                                   \ 
  256       for(l_L=0; l_L<lprod; l_L++)                                            \ 
  258           MACRO_update_phi_prod_ll_plain(without_PRE_PSI);                    \ 
  260           MACRO_nnfft_B_compute_ ## which_one;                                \ 
  262           MACRO_count_uo_l_lj_t;                                              \ 
  274   if(ths->nnfft_flags & PRE_PHI_HUT)
 
  276       for(j=0; j<ths->M_total; j++)
 
  277     ths->f[j] *= ths->c_phi_inv[j];
 
  281       for(j=0; j<ths->M_total; j++)
 
  285     for(t=0; t<ths->d; t++)
 
  286         tmp*= 1.0 /((PHI_HUT(ths->x[ths->d*j + t]*((
double)ths->N[t]),t)) );
 
  301     for(t=0;t<ths->
d;t++) {
 
  302       ths->
x[j*ths->
d+t]= ths->
x[j*ths->
d+t] / ((double)ths->
sigma[t]);
 
  312     for(t=0;t<ths->
d;t++) {
 
  313       ths->
x[j*ths->
d+t]= ths->
x[j*ths->
d+t] * ((double)ths->
sigma[t]);
 
  327     for(t=0;t<ths->
d;t++) {
 
  328       ths->
x[j*ths->
d+t]= ths->
x[j*ths->
d+t] / ((double)ths->
sigma[t]);
 
  338     for(t=0;t<ths->
d;t++) {
 
  339       ths->
x[j*ths->
d+t]= ths->
x[j*ths->
d+t] * ((double)ths->
sigma[t]);
 
  359       for(t=0; t<ths->
d; t++)
 
  360         tmp*= 1.0 /(PHI_HUT(ths->
x[ths->
d*j + t]*((
double)ths->
N[t]),t));
 
  376   for (t=0; t<ths->
d; t++)
 
  378       step=((double)(ths->
m+1))/(ths->
K*ths->
N1[t]);
 
  379       for(j=0;j<=ths->
K;j++)
 
  381           ths->
psi[(ths->
K+1)*t + j] = PHI(j*step,t);
 
  394   for (t=0; t<ths->
d; t++)
 
  397         nnfft_uo(ths,j,&u,&o,t);
 
  399         for(l=u, lj=0; l <= o; l++, lj++)
 
  400           ths->
psi[(j*ths->
d+t)*(2*ths->
m+2)+lj]=
 
  401             (PHI((-ths->
v[j*ths->
d+t]+((
double)l)/((
double)ths->
N1[t])),t));
 
  405     for(t=0;t<ths->
d;t++) {
 
  406       ths->
x[j*ths->
d+t]= ths->
x[j*ths->
d+t] / ((double)ths->
sigma[t]);
 
  413     for(t=0;t<ths->
d;t++) {
 
  414       ths->
x[j*ths->
d+t]= ths->
x[j*ths->
d+t] * ((double)ths->
sigma[t]);
 
  432   int ll_plain[ths->
d+1];              
 
  434   int u[ths->
d], o[ths->
d];           
 
  436   double phi_prod[ths->
d+1];
 
  441     for(t=0;t<ths->
d;t++) {
 
  442       ths->
x[j*ths->
d+t]= ths->
x[j*ths->
d+t] / ((double)ths->
sigma[t]);
 
  446   nnfft_precompute_psi(ths);
 
  451     for(t=0;t<ths->
d;t++) {
 
  452       ths->
x[j*ths->
d+t]= ths->
x[j*ths->
d+t] * ((double)ths->
sigma[t]);
 
  459   for(t=0,lprod = 1; t<ths->
d; t++)
 
  462   for(j=0,ix=0,ix_old=0; j<ths->N_total; j++)
 
  464       MACRO_init_uo_l_lj_t;
 
  466       for(l_L=0; l_L<lprod; l_L++, ix++)
 
  468           MACRO_update_phi_prod_ll_plain(without_PRE_PSI);
 
  471           ths->
psi[ix]=phi_prod[ths->
d];
 
  473           MACRO_count_uo_l_lj_t;
 
  482 static void nnfft_init_help(
nnfft_plan *ths, 
int m2, 
unsigned nfft_flags, 
unsigned fftw_flags)
 
  498   for(t = 0; t<ths->
d; t++) {
 
  499     ths->
a[t] = 1.0 + (2.0*((double)ths->
m))/((
double)ths->
N1[t]);
 
  500     ths->
aN1[t] = ths->
a[t] * ((double)ths->
N1[t]);
 
  502     if(ths->
aN1[t]%2 != 0)
 
  503       ths->
aN1[t] = ths->
aN1[t] +1;
 
  506     ths->
sigma[t] = ((double) ths->
N1[t] )/((double) ths->
N[t]);;
 
  509     N2[t] = ceil(ths->
sigma[t]*(ths->
aN1[t]));
 
  530     ths->
K=(1U<< 10)*(ths->
m+1);
 
  539       for(t=0,lprod = 1; t<ths->
d; t++)
 
  551      nfft_flags, fftw_flags);
 
  558   ths->
mv_adjoint = (void (*) (
void* ))nnfft_adjoint;
 
  561 void nnfft_init_guru(
nnfft_plan *ths, 
int d, 
int N_total, 
int M_total, 
int *N, 
int *N1,
 
  562          int m, 
unsigned nnfft_flags)
 
  574   fftw_flags= FFTW_ESTIMATE| FFTW_DESTROY_INPUT;
 
  575   nfft_flags= PRE_PHI_HUT| MALLOC_F_HAT| FFTW_INIT| FFT_OUT_OF_PLACE;
 
  578     nfft_flags = nfft_flags | PRE_PSI;
 
  581     nfft_flags = nfft_flags | PRE_FULL_PSI;
 
  584     nfft_flags = nfft_flags | PRE_LIN_PSI;
 
  593   nnfft_init_help(ths,m,nfft_flags,fftw_flags);
 
  596 void nnfft_init(
nnfft_plan *ths, 
int d, 
int N_total, 
int M_total, 
int *N)
 
  620     ths->
N1[t] = ceil(1.5*ths->
N[t]);
 
  623     if(ths->
N1[t]%2 != 0)
 
  624       ths->
N1[t] = ths->
N1[t] +1;
 
  627   ths->
nnfft_flags=PRE_PSI| PRE_PHI_HUT| MALLOC_X| MALLOC_V| MALLOC_F_HAT| MALLOC_F;
 
  628   nfft_flags= PRE_PSI| PRE_PHI_HUT| MALLOC_F_HAT| FFTW_INIT| FFT_OUT_OF_PLACE;
 
  630   fftw_flags= FFTW_ESTIMATE| FFTW_DESTROY_INPUT;
 
  632   nnfft_init_help(ths,ths->
m,nfft_flags,fftw_flags);