NFFT Logo 3.1.0 API Reference

simple_test.c

00001 /*
00002  * Copyright (c) 2002, 2009 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: simple_test.c 3100 2009-03-12 08:42:48Z keiner $ */
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 }

Generated on 19 Mar 2009 by Doxygen 1.5.3