00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include <stdlib.h>
00022 #include <math.h>
00023 #include <complex.h>
00024
00025 #include "util.h"
00026 #include "nfft3.h"
00027
00028
00029 void simple_test_nnfft_1d(void)
00030 {
00031 int j,k;
00032 nnfft_plan my_plan;
00034 int N[1];
00035 N[0]=12;
00036
00038 nnfft_init(&my_plan, 1, 12, 19, N);
00039
00041 for(j=0;j<my_plan.M_total;j++)
00042 {
00043 my_plan.x[j]=((double)rand())/RAND_MAX-0.5;
00044 }
00046 for(j=0;j<my_plan.N_total;j++)
00047 {
00048 my_plan.v[j]=((double)rand())/RAND_MAX-0.5;
00049 }
00050
00052 if(my_plan.nnfft_flags & PRE_PSI)
00053 nnfft_precompute_psi(&my_plan);
00054
00055 if(my_plan.nnfft_flags & PRE_FULL_PSI)
00056 nnfft_precompute_full_psi(&my_plan);
00057
00058 if(my_plan.nnfft_flags & PRE_LIN_PSI)
00059 nnfft_precompute_lin_psi(&my_plan);
00060
00062 if(my_plan.nnfft_flags & PRE_PHI_HUT)
00063 nnfft_precompute_phi_hut(&my_plan);
00064
00066 for(k=0;k<my_plan.N_total;k++)
00067 my_plan.f_hat[k] = ((double)rand())/RAND_MAX + _Complex_I*((double)rand())/RAND_MAX;
00068
00069 nfft_vpr_complex(my_plan.f_hat,my_plan.N_total,"given Fourier coefficients, vector f_hat");
00070
00072 nndft_trafo(&my_plan);
00073 nfft_vpr_complex(my_plan.f,my_plan.M_total,"nndft, vector f");
00074
00076 nnfft_trafo(&my_plan);
00077 nfft_vpr_complex(my_plan.f,my_plan.M_total,"nnfft, vector f");
00078
00080 nnfft_finalize(&my_plan);
00081 }
00082
00083 void simple_test_nnfft_2d(void)
00084 {
00085 int j,k;
00086 nnfft_plan my_plan;
00088 int N[2];
00089 N[0]=12;
00090 N[1]=14;
00091
00093 nnfft_init(&my_plan, 2,12*14,19, N);
00094
00096 for(j=0;j<my_plan.M_total;j++)
00097 {
00098 my_plan.x[2*j]=((double)rand())/RAND_MAX-0.5;
00099 my_plan.x[2*j+1]=((double)rand())/RAND_MAX-0.5;
00100 }
00101
00103 for(j=0;j<my_plan.N_total;j++)
00104 {
00105 my_plan.v[2*j]=((double)rand())/RAND_MAX-0.5;
00106 my_plan.v[2*j+1]=((double)rand())/RAND_MAX-0.5;
00107 }
00108
00110 if(my_plan.nnfft_flags & PRE_PSI)
00111 nnfft_precompute_psi(&my_plan);
00112
00113 if(my_plan.nnfft_flags & PRE_FULL_PSI)
00114 nnfft_precompute_full_psi(&my_plan);
00115
00116 if(my_plan.nnfft_flags & PRE_LIN_PSI)
00117 nnfft_precompute_lin_psi(&my_plan);
00118
00120 if(my_plan.nnfft_flags & PRE_PHI_HUT)
00121 nnfft_precompute_phi_hut(&my_plan);
00122
00124 for(k=0;k<my_plan.N_total;k++)
00125 my_plan.f_hat[k] = ((double)rand())/RAND_MAX + _Complex_I*((double)rand())/RAND_MAX;
00126
00127 nfft_vpr_complex(my_plan.f_hat,12,
00128 "given Fourier coefficients, vector f_hat (first 12 entries)");
00129
00131 nndft_trafo(&my_plan);
00132 nfft_vpr_complex(my_plan.f,my_plan.M_total,"ndft, vector f");
00133
00135 nnfft_trafo(&my_plan);
00136 nfft_vpr_complex(my_plan.f,my_plan.M_total,"nfft, vector f");
00137
00139 nnfft_finalize(&my_plan);
00140 }
00141
00142 void simple_test_innfft_1d(void)
00143 {
00144 int j,k,l,N=8;
00145 nnfft_plan my_plan;
00146 solver_plan_complex my_iplan;
00149 nnfft_init(&my_plan,1 ,8 ,8 ,&N);
00150
00152 solver_init_advanced_complex(&my_iplan,(mv_plan_complex*)(&my_plan),CGNR);
00153
00155 for(j=0;j<my_plan.M_total;j++)
00156 my_plan.x[j]=((double)rand())/RAND_MAX-0.5;
00157
00159 for(j=0;j<my_plan.N_total;j++)
00160 my_plan.v[j]=((double)rand())/RAND_MAX-0.5;
00161
00163 if(my_plan.nnfft_flags & PRE_PSI)
00164 nnfft_precompute_psi(&my_plan);
00165
00166 if(my_plan.nnfft_flags & PRE_FULL_PSI)
00167 nnfft_precompute_full_psi(&my_plan);
00168
00170 if(my_plan.nnfft_flags & PRE_PHI_HUT)
00171 nnfft_precompute_phi_hut(&my_plan);
00172
00174 for(j=0;j<my_plan.M_total;j++)
00175 my_iplan.y[j] = ((double)rand())/RAND_MAX;
00176
00177 nfft_vpr_complex(my_iplan.y,my_plan.M_total,"given data, vector given_f");
00178
00180 for(k=0;k<my_plan.N_total;k++)
00181 my_iplan.f_hat_iter[k] = 0.0;
00182
00183 nfft_vpr_complex(my_iplan.f_hat_iter,my_plan.N_total,
00184 "approximate solution, vector f_hat_iter");
00185
00187 solver_before_loop_complex(&my_iplan);
00188 for(l=0;l<8;l++)
00189 {
00190 printf("iteration l=%d\n",l);
00191 solver_loop_one_step_complex(&my_iplan);
00192 nfft_vpr_complex(my_iplan.f_hat_iter,my_plan.N_total,
00193 "approximate solution, vector f_hat_iter");
00194
00195 NFFT_SWAP_complex(my_iplan.f_hat_iter,my_plan.f_hat);
00196 nnfft_trafo(&my_plan);
00197 nfft_vpr_complex(my_plan.f,my_plan.M_total,"fitting the data, vector f");
00198 NFFT_SWAP_complex(my_iplan.f_hat_iter,my_plan.f_hat);
00199 }
00200
00201 solver_finalize_complex(&my_iplan);
00202 nnfft_finalize(&my_plan);
00203 }
00204
00205 void measure_time_nnfft_1d(void)
00206 {
00207 int j,k;
00208 nnfft_plan my_plan;
00209 int my_N,N=4;
00210 double t;
00211
00212 for(my_N=16; my_N<=16384; my_N*=2)
00213 {
00214 nnfft_init(&my_plan,1,my_N,my_N,&N);
00215
00216 for(j=0;j<my_plan.M_total;j++)
00217 my_plan.x[j]=((double)rand())/RAND_MAX-0.5;
00218
00219 for(j=0;j<my_plan.N_total;j++)
00220 my_plan.v[j]=((double)rand())/RAND_MAX-0.5;
00221
00222 if(my_plan.nnfft_flags & PRE_PSI)
00223 nnfft_precompute_psi(&my_plan);
00224
00225 if(my_plan.nnfft_flags & PRE_FULL_PSI)
00226 nnfft_precompute_full_psi(&my_plan);
00227
00228 if(my_plan.nnfft_flags & PRE_PHI_HUT)
00229 nnfft_precompute_phi_hut(&my_plan);
00230
00231 for(k=0;k<my_plan.N_total;k++)
00232 my_plan.f_hat[k] = ((double)rand())/RAND_MAX + _Complex_I*((double)rand())/RAND_MAX;
00233
00234 t=nfft_second();
00235 nndft_trafo(&my_plan);
00236 t=nfft_second()-t;
00237 printf("t_nndft=%e,\t",t);
00238
00239 t=nfft_second();
00240 nnfft_trafo(&my_plan);
00241 t=nfft_second()-t;
00242 printf("t_nnfft=%e\t",t);
00243
00244 printf("(N=M=%d)\n",my_N);
00245
00246 nnfft_finalize(&my_plan);
00247 }
00248 }
00249
00250 int main(void)
00251 {
00252 system("clear");
00253 printf("1) computing an one dimensional nndft, nnfft\n\n");
00254 simple_test_nnfft_1d();
00255
00256 getc(stdin);
00257
00258 system("clear");
00259 printf("2) computing a two dimensional nndft, nnfft\n\n");
00260 simple_test_nnfft_2d();
00261
00262 getc(stdin);
00263
00264 system("clear");
00265 printf("3) computing an one dimensional innfft\n\n");
00266 simple_test_innfft_1d();
00267
00268 getc(stdin);
00269
00270 system("clear");
00271 printf("4) computing times for one dimensional nnfft\n\n");
00272 measure_time_nnfft_1d();
00273
00274 return 1;
00275 }