49 #ifdef MEASURE_TIME_FFTW 
   68   dst->my_fftw_plan1=src->my_fftw_plan1;
 
   69   dst->my_fftw_plan2=src->my_fftw_plan2;
 
   72 static void time_accuracy(
int d, 
int N, 
int M, 
int n, 
int m, 
unsigned test_ndft,
 
   73                    unsigned test_pre_full_psi)
 
   77   double _Complex *swapndft = NULL;
 
   88   printf(
"%d\t%d\t", d, N);
 
   98     swapndft=(
double _Complex*)
nfft_malloc(M*
sizeof(
double _Complex));
 
  100   nfft_init_guru(&p, d, NN, M, nn, m,
 
  101                  MALLOC_X| MALLOC_F_HAT| MALLOC_F|
 
  102      FFTW_INIT| FFT_OUT_OF_PLACE,
 
  103      FFTW_MEASURE| FFTW_DESTROY_INPUT);
 
  108   nfft_init_guru(&p_pre_phi_hut, d, NN, M, nn, m, PRE_PHI_HUT,0);
 
  109   flags_cp(&p_pre_phi_hut, &p);
 
  110   nfft_precompute_one_psi(&p_pre_phi_hut);
 
  114       nfft_init_guru(&p_fg_psi, d, NN, M, nn, m, FG_PSI,0);
 
  115       flags_cp(&p_fg_psi, &p);
 
  116       nfft_precompute_one_psi(&p_fg_psi);
 
  119   nfft_init_guru(&p_pre_lin_psi, d, NN, M, nn, m, PRE_LIN_PSI,0);
 
  120   flags_cp(&p_pre_lin_psi, &p);
 
  121   nfft_precompute_one_psi(&p_pre_lin_psi);
 
  125       nfft_init_guru(&p_pre_fg_psi, d, NN, M, nn, m, PRE_FG_PSI,0);
 
  126       flags_cp(&p_pre_fg_psi, &p);
 
  127       nfft_precompute_one_psi(&p_pre_fg_psi);
 
  130   nfft_init_guru(&p_pre_psi, d, NN, M, nn, m, PRE_PSI,0);
 
  131   flags_cp(&p_pre_psi, &p);
 
  132   nfft_precompute_one_psi(&p_pre_psi);
 
  134   if(test_pre_full_psi)
 
  136       nfft_init_guru(&p_pre_full_psi, d, NN, M, nn, m, PRE_FULL_PSI,0);
 
  137       flags_cp(&p_pre_full_psi, &p);
 
  138       nfft_precompute_one_psi(&p_pre_full_psi);
 
  155           nfft_trafo_direct(&p);
 
  157           t = nfft_elapsed_seconds(t1,t0);
 
  180   if(test_pre_full_psi)
 
  189     e=X(error_l_2_complex)(swapndft, p.
f, p.
M_total);
 
  193   printf(
"%.2e\t%d\t%.2e\t%.2e\t%.2e\t%.2e\t%.2e\t%.2e\t%.2e\t%.2e\t%.2e\t%.2e\n",
 
  212   if(test_pre_full_psi)
 
  213     nfft_finalize(&p_pre_full_psi);
 
  214   nfft_finalize(&p_pre_psi);
 
  216     nfft_finalize(&p_pre_fg_psi);
 
  217   nfft_finalize(&p_pre_lin_psi);
 
  219     nfft_finalize(&p_fg_psi);
 
  220   nfft_finalize(&p_pre_phi_hut);
 
  227 static void accuracy_pre_lin_psi(
int d, 
int N, 
int M, 
int n, 
int m, 
int K)
 
  231   double _Complex *swapndft;
 
  242   swapndft=(
double _Complex*)
nfft_malloc(M*
sizeof(
double _Complex));
 
  244   nfft_init_guru(&p, d, NN, M, nn, m,
 
  245                  MALLOC_X| MALLOC_F_HAT| MALLOC_F|
 
  246                  PRE_PHI_HUT| PRE_LIN_PSI|
 
  247      FFTW_INIT| FFT_OUT_OF_PLACE,
 
  248      FFTW_MEASURE| FFTW_DESTROY_INPUT);
 
  256   nfft_precompute_one_psi(&p);
 
  266   nfft_trafo_direct(&p);
 
  271   e=X(error_l_2_complex)(swapndft, p.
f, p.
M_total);
 
  274   printf(
"$%.1e$&\t",e);
 
  284 int main(
int argc,
char **argv)
 
  290       fprintf(stderr,
"flags type first last trials d m\n");
 
  294   if((test==0)&&(atoi(argv[1])<2))
 
  296       fprintf(stderr,
"MEASURE_TIME in nfft3util.h not set\n");
 
  300   fprintf(stderr,
"Testing different precomputation schemes for the nfft.\n");
 
  301   fprintf(stderr,
"Columns: d, N=M, t_ndft, e_nfft, t_D, t_pre_phi_hut, ");
 
  302   fprintf(stderr,
"t_fftw, t_B, t_fg_psi, t_pre_lin_psi, t_pre_fg_psi, ");
 
  303   fprintf(stderr,
"t_pre_psi, t_pre_full_psi\n\n");
 
  310     for(l=atoi(argv[2]); l<=atoi(argv[3]); l++)
 
  311       for(trial=0; trial<atoi(argv[4]); trial++)
 
  314       time_accuracy(d, (1U<< l), (1U<< (d*l)), (1U<< (l+1)), m, 0, 0);
 
  316       time_accuracy(d, (1U<< l), (1U<< (d*l)), (1U<< (l+1)), m, 0, 0);
 
  324     for(m=atoi(argv[2]); m<=atoi(argv[3]); m++)
 
  325       for(trial=0; trial<atoi(argv[4]); trial++)
 
  326         time_accuracy(d, N, (
int)pow(N,d), 2*N, m, 1, 1);
 
  335       printf(
"$\\log_2(K/(m+1))$&\t");
 
  336       for(l=atoi(argv[2]); l<atoi(argv[3]); l++)
 
  339       printf(
"$%d$\\\\\n",atoi(argv[3]));
 
  341       printf(
"$\\tilde E_2$&\t");
 
  342       for(l=atoi(argv[2]); l<=atoi(argv[3]); l++)
 
  343   accuracy_pre_lin_psi(d, N, (
int)pow(N,d), 2*N, m, (m+1)*(1U<< l));