/* This is the two-halo term.
*/
void calc_nbody_two_halo(float **gal, int *id, int ngal)
{
float rmax,rmin,lrstep,binfac,rcube,weight0,fac,rlow,density,weightrandom,vol,r;
int ibin,kbin,nbin,i,j,k,*binlookup,*npair,ngal_temp;
float *rupp,*rsqr,reduction_factor,*vxt,*vyt,*vzt;
int *meshparts, ***meshstart,nmesh,meshfac,nbrmax,*indx;
double *rbar,galden;
float *xg,*yg,*zg,*xt,*yt,*zt;
static float *rad, *xi;
static int nr, flag = 0;
char fname[100];
FILE *fp;
sprintf(fname,"%s.nbody_2halo",Task.root_filename);
fp = fopen(fname,"w");
rmax = 10;
rmin = 0.1;
nbin = nr = 20;
rad = vector(1,nr);
xi = vector(1,nr);
g21_rad = dvector(1,nr);
g21_xi = dvector(1,nr);
g21_nrad = nr;
xg = malloc(ngal*sizeof(float));
yg = malloc(ngal*sizeof(float));
zg = malloc(ngal*sizeof(float));
ngal_temp=0;
for(i=1;i<=ngal;++i)
{
xg[ngal_temp] = gal[i][0];
yg[ngal_temp] = gal[i][1];
zg[ngal_temp] = gal[i][2];
ngal_temp++;
}
ngal = ngal_temp;
indx=malloc(ngal*sizeof(int));
rsqr=malloc(ngal*sizeof(float));
/***********************
* initializing the logarithmic bins
*/
rupp = (float *) calloc(nbin+1,sizeof(float)) ;
lrstep=log(rmax/rmin)/(float)(nbin-1) ;
binlookup=(int *)calloc(NBINLOOKUP+2,sizeof(int)) ;
ibin=0 ;
for (i=0;i<=NBINLOOKUP;i++) {
r=rmax*i/NBINLOOKUP ;
if (r>0) {
kbin=(int)floor(log(r/rmin)/lrstep+1.0) ;
}
else {
kbin=0 ;
}
if (kbin<0) kbin=0 ;
if (kbin>ibin) {
rupp[ibin]=r ;
ibin=kbin ;
}
binlookup[i]=kbin ;
}
binlookup[NBINLOOKUP+1]=nbin ;
rupp[nbin-1]=rmax ;
rupp[nbin]=rmax ;
binfac=NBINLOOKUP/rmax ;
rbar=calloc(nbin,sizeof(double));
npair=calloc(nbin,sizeof(int));
rcube = BOX_SIZE;
nmesh=0;
meshlink2(ngal,&nmesh,0.0,rcube,rmax,xg,yg,zg,&meshparts,&meshstart,meshfac);
for(i=0;i<ngal;++i)
{
nbrmax=ngal;
nbrsfind2(0.0,rcube,rmax,nmesh,xg[i],yg[i],zg[i],&nbrmax,indx,rsqr,xg,yg,zg,
meshparts,meshstart,i);
for(j=0;j<nbrmax;++j)
{
k = indx[j];
// if gals in same halo, skip
if(id[i+1]==id[k+1])continue;
r=sqrt(rsqr[j]) ;
kbin=binlookup[(int)(binfac*r)] ;
if(kbin>=nbin)continue;
npair[kbin]++;
rbar[kbin]+=r;
}
}
density=ngal/(rcube*rcube*rcube) ;
rlow=0;
for (kbin=0;kbin<nbin;kbin++) {
weight0=(float) npair[kbin];
if (weight0>0.0) {
fac=1./weight0 ;
rbar[kbin] *= fac ;
}
else { /* avoid errors in empty bins */
rbar[kbin]=(rupp[kbin]+rlow)*0.5;
}
/* compute xi, dividing summed weight by that expected for a random set */
vol=4.*PI/3.*(rupp[kbin]*rupp[kbin]*rupp[kbin]-rlow*rlow*rlow) ;
weightrandom=ngal*density*vol ;
g21_rad[kbin+1] = rad[kbin+1]=log(rbar[kbin]);
g21_xi[kbin+1] = xi[kbin+1]=weight0/weightrandom-1 ;
rlow=rupp[kbin] ;
fprintf(fp,"%e %e %.0f\n",rbar[kbin],xi[kbin+1],weight0);
if(OUTPUT>1)
{
fprintf(stdout,"nbody_xi> %f %f %.0f\n",rbar[kbin],xi[kbin+1],weight0);
fflush(stdout);
}
}
fclose(fp);
free(indx);
free(rsqr);
free(rupp);
free(binlookup);
free(npair);
free(rbar);
free_i3tensor(meshstart,0,nmesh-1,0,nmesh-1,0,nmesh-1);
}
int main(int argc, char *argv[]){
double sumv ;
double avev ;
double minv ;
double maxv ;
double un ;
int N_empty ;
int lab_mcmc ;
int i ;
int k ;
int j ;
int pop ;
int iter ;
int ID ;
int N_sample ;
int N_thinning ;
int N_population ;
int N_iteration ;
int N_node ;
double z_min ;
double z_max ;
double *freq_ref ;
double *freq_est ;
double freq_zeta ;
double *theta ;
double theta_norm_const ;
double *grid_points ;
int grid_size ;
double grid_high ;
double grid_low ;
double gain ;
double gain_pow ;
int gain_warmup ;
double gain_high ;
double temp_saa ;
double temp_saa_pow ;
int temp_saa_warmup ;
double temp_saa_high ;
double temp_saa_low ;
int **x ;
int ***xmat ;
double *fx ;
double **fx_cond ;
int *changelength ;
int **changelist ;
int *z_best ;
int **zmat_best ;
double fz_best ;
double *fz_cond_best ;
double accpr ;
double *work0_d1 ;
int *work1_i1 ;
double *work2_d1 ;
int **work3_i2 ;
double *work4_d1 ;
int **work5_i2 ;
double exp_accpr_mh1 ;
double exp_accpr_mh2 ;
double exp_accpr_mh3 ;
double exp_accpr_co1 ;
int n_mh1 ;
int n_mh2 ;
int n_mh3 ;
int n_co1 ;
FILE *ins_hist = NULL ;
FILE *ins_fz_best_trace = NULL ;
FILE *ins_fz_best = NULL ;
char file_name[50] ;
char datapath[50] ;
/*INITIALIZE THE RNG -------------------------------------------------- */
printf("\n INITIALIZE THE RNG \n") ;
setseedrng( (unsigned long) time(NULL) ) ;
for ( i=1 ; i<=10 ; i++ ) un = uniformrng() ;
/* SET DEFAULT ALGORITHMIC SETTINGS ----------------------------------- */
printf("\n SET ALGORITHMIC SETTINGS \n") ;
snprintf(datapath, sizeof datapath, "./SPECT.dat") ;
N_population = 5 ;
N_iteration = 200000000 ;
ID = 1 ;
N_sample = 20000 ;
N_thinning = (int) (N_iteration/N_sample) ;
gain_warmup = 500000 ;
gain_pow = 1.0 ;
gain_high = 1.0 ;
temp_saa_warmup = 500000 ;
temp_saa_pow = 0.5 ;
temp_saa_high = 1.0 ;
temp_saa_low = 0.1 ;
freq_zeta = 0.1 ;
grid_low = 2000.0 ;
grid_high = 3999.0 ;
grid_size = 2000 ;
theta_norm_const = 100.0 ;
/*PASS EXTERNAL ALGORITHMIC ARGUMENTS -------------------------------- */
for (i = 1; i < argc; i++) {
if (strcmp("-ID", argv[i]) == 0) /*..REPEAT NO*/
ID = atoi(argv[++i]) ;
else if (strcmp("-Data", argv[i]) == 0) /*..DATA*/
snprintf(datapath, sizeof datapath, argv[++i]) ;
else if (strcmp("-Niter", argv[i]) == 0) /*..COUNTERS*/
{
N_iteration = atoi(argv[++i]) ;
N_thinning = (N_sample==0)?1:(N_iteration/N_sample) ;
}
else if (strcmp("-Npop", argv[i]) == 0)
N_population = atoi(argv[++i]) ;
else if (strcmp("-Nsam", argv[i]) == 0)
{
N_sample = atoi(argv[++i]) ;
N_thinning = (N_sample==0)?1:(N_iteration/N_sample) ;
}
else if (strcmp("-Gwarm", argv[i]) == 0) /*..GAIN*/
gain_warmup = atoi(argv[++i]) ;
else if (strcmp("-Ghigh", argv[i]) == 0)
gain_high = atof(argv[++i]) ;
else if (strcmp("-Gpow", argv[i]) == 0)
gain_pow = atof(argv[++i]) ;
else if (strcmp("-Hlow", argv[i]) == 0) /*..HIST*/
grid_low = atof(argv[++i]) ;
else if (strcmp("-Hhigh", argv[i]) == 0)
grid_high = atof(argv[++i]) ;
else if (strcmp("-Hsize", argv[i]) == 0)
grid_size = atoi(argv[++i]) ;
else if (strcmp("-Hzeta", argv[i]) == 0)
freq_zeta = atof(argv[++i]) ;
else if (strcmp("-Hconst", argv[i]) == 0)
theta_norm_const = atof(argv[++i]) ;
else if (strcmp("-Twarm", argv[i]) == 0) /*..TEMPERATURE LADER*/
temp_saa_warmup = atoi(argv[++i]) ;
else if (strcmp("-Tlow", argv[i]) == 0)
temp_saa_low = atof(argv[++i]) ;
else if (strcmp("-Thigh", argv[i]) == 0)
temp_saa_high = atof(argv[++i]) ;
else if (strcmp("-Tpow", argv[i]) == 0)
temp_saa_pow = atof(argv[++i]) ;
else if (strcmp("-flags", argv[i]) == 0)
flags_usage() ;
}
/*PRINT INPUTS OF THE ALGORITHM*/
printf( "\n PRINT INPUTS OF THE ALGORITHM \n") ;
printf( "Data path: \t\t %s \n", datapath) ;
printf( "N_iteration: \t\t %d \n", N_iteration) ;
printf( "N_population: \t\t %d \n", N_population) ;
printf( "ID: \t\t\t %d \n", ID) ;
printf( "N_sample: \t\t %d \n", N_sample) ;
printf( "N_thinning: \t\t %d \n", N_thinning) ;
printf( "gain_warmup: \t\t %d \n", gain_warmup) ;
printf( "gain_high: \t\t %f \n", gain_high) ;
printf( "gain_pow: \t\t %f \n", gain_pow) ;
printf( "grid_low: \t\t %f \n", grid_low) ;
printf( "grid_high: \t\t %f \n", grid_high) ;
printf( "grid_size: \t\t %d \n", grid_size) ;
printf( "freq_zeta: \t\t %f \n", freq_zeta) ;
printf( "theta_norm_const: \t %f \n", theta_norm_const) ;
printf( "temp_saa_warmup: \t %d \n", temp_saa_warmup) ;
printf( "temp_saa_low: \t\t %f \n", temp_saa_low) ;
printf( "temp_saa_high: \t\t %f \n", temp_saa_high) ;
printf( "temp_saa_pow: \t\t %f \n", temp_saa_pow) ;
printf( "\n") ;
/*GET DATA -----------------------------------------------------------*/
printf("\n GET DATA\n") ;
get_data(datapath,&N_node) ;
/*OPEN FILES -----------------------------------------------------------*/
printf("\n OPEN FILES\n") ;
snprintf(file_name, sizeof file_name, "./output_files/hist-n=%d-r=%d",
N_population, ID);
ins_hist = fopen( file_name , "w" ) ;
if ( N_sample>0 ) {
snprintf(file_name, sizeof file_name, "./output_files/fz_best_trace-n=%d-r=%d",
N_population, ID);
ins_fz_best_trace = fopen( file_name , "w" ) ;
}
snprintf(file_name, sizeof file_name, "./output_files/fz_best-n=%d-r=%d",
N_population, ID);
ins_fz_best = fopen( file_name , "w" ) ;
/* ALLOCATE SPACE FOR THE ARRAYS -------------------------------------- */
printf("\n ALLOCATE SPACE FOR THE ARRAYS \n") ;
grid_points = dvector( 1 , grid_size ) ;
freq_ref = dvector( 1 , grid_size+1 ) ;
theta = dvector( 1 , grid_size+1 ) ;
freq_est = dvector( 1 , grid_size+1 ) ;
x = imatrix(1, N_population, 1, N_node) ;
xmat = i3tensor(1, N_population, 1, N_node, 1, N_node) ;
fx = dvector(1, N_population) ;
fx_cond = dmatrix(1, N_population, 1, N_node) ;
changelength = ivector(1, N_population) ;
changelist = imatrix(1, N_population, 1, N_node) ;
z_best = ivector( 1, N_node ) ;
zmat_best = imatrix(1, N_node, 1, N_node) ;
fz_cond_best = dvector( 1, N_node ) ;
work0_d1 = dvector(1, grid_size+1) ;
work1_i1 = ivector(1, N_node) ;
work2_d1 = dvector(1, N_node) ;
work3_i2 = imatrix(1, N_node, 1, N_node) ;
work4_d1 = dvector(1, N_node) ;
work5_i2 = imatrix(1, N_node, 1, N_node) ;
/* INITIALIZE THE POPULATION -------------------------------------- */
printf("\n INITIALIZE THE POPULATION \n") ;
/*Get a random initialization*/
for (pop=1 ; pop<=N_population; pop++) {
/*Initialize values*/
for (i=1;i<=N_node; i++) x[pop][i] = i ;
permutrng(x[pop], N_node) ;
for (i=1;i<=N_node; i++)
for (j=1;j<=N_node; j++)
xmat[pop][i][j] = ((i==j) ? 1 : 0) ;
changelength[pop] = N_node ;
for (i=1;i<=N_node; i++) changelist[pop][i] = i ;
fx[pop] = cost(x[pop], xmat[pop], N_node, fx_cond[pop],
changelist[pop], changelength[pop]) ;
}
for (pop=1 ; pop<=N_population; pop++) {
printf("Popul. : %d \n",pop) ;
printf("Cost : %f \n",fx[pop]) ;
printf("Cost[i] : ") ;
for (i=1 ; i<=N_node; i++) printf("%f ", fx_cond[pop][i]) ;
printf("\n") ;
printf("x[i] : ") ;
for (i=1;i<=N_node; i++) printf("%d ",x[pop][i]) ; printf("\n") ;
printf("xmat : \n") ;
for (i=1; i<=N_node; i++){
for (j=1; j<=N_node; j++) printf("%d ",xmat[pop][i][j]) ;
printf("\n") ;
}
}
printf("\n") ;
/* INITIALIZE BEST VALUES ----------------------------------------- */
printf("\n INITIALIZE BEST VALUES \n") ;
k = 1 ; fz_best = fx[1] ;
for ( pop=2 ; pop <= N_population ; pop++ )
if ( fx[pop] < fz_best ){
k = pop ;
fz_best = fx[k] ;
}
for (i=1; i<=N_node; i++) fz_cond_best[i] = fx_cond[k][i] ;
for (i=1; i<=N_node; i++) z_best[i] = x[k][i] ;
for (i=1; i<=N_node; i++)
for (j=1; j<=N_node; j++)
zmat_best[i][j] = xmat[k][i][j] ;
/*PRINT*/
printf("Best value : \n") ;
printf( "fz_best : %f \n",fz_best) ;
printf( "fz_best_cond : \n") ;
for (i=1; i<=N_node; i++) printf("%f ", fz_cond_best[i]) ;
printf("\n") ;
printf( "z_best : \n") ;
for ( i=1 ; i<=N_node ; i++ ) printf("%d ", z_best[i]) ;
printf("\n") ;
printf( "zmat_best : \n") ;
for ( i=1 ; i<=N_node ; i++ ) {
for ( j=1 ; j<=N_node ; j++ ) printf("%d ", zmat_best[i][j]) ;
printf("\n") ;
}
/* INITIALIZE THE SELF-ADJUSTING MECHANISM ------------------------- */
printf("\n INITIALIZE THE SELF-ADJUSTING MECHANISM \n") ;
/* INITIALIZE THE REFERENCE FREQUENCE */
printf("\n INITIALIZE THE REFERENCE FREQUENCE \n") ;
self_adj_desired_freq(freq_ref, grid_size, freq_zeta) ;
/* INITIALIZE EMPIRICAL FREQUENCE */
printf("\n INITIALIZE EMPIRICAL FREQUENCE \n") ;
for (i=1 ; i<=grid_size+1 ; i++) freq_est[i] = 0.0 ;
/* INITIALIZE GRID POINTS */
printf("\n INITIALIZE GRID POINTSE \n") ;
self_adj_grid_points(grid_points, grid_size, grid_low, grid_high) ;
/* INITIALIZE THETA */
printf("\n INITIALIZE THETA \n") ;
for (i=1 ; i<=grid_size+1 ; i++) theta[i] = 0.0 ;
/* PRINT INITIAL SETTINGS OF THE SELF-ADJUSTMENT PROSEDURE */
if( grid_size < 500 ) {
printf("\n PRINT INITIAL SETTINGS OF "
"THE SELF-ADJUSTMENT PROSEDURE \n") ;
for (i=1 ; i<=grid_size ; i++)
printf("%d \t %f \t %f \t %f \t %f \t %f \n",
i,
grid_points[i],
theta[i], exp(theta[i]),
freq_ref[i], freq_est[i] ) ;
i = grid_size+1 ;
printf("%d \t %f \t %f \t %f \t %f \t %f \n",
i,
0.0,
theta[i], exp(theta[i]),
freq_ref[i], freq_est[i] ) ;
}
/* INITIALIZE THE COUNTERS ---------------------------------------- */
printf("\n INITIALIZE THE COUNTERS \n") ;
/* INITIALIZE THE EXPETED ACCEPTANCE PROBABLITY COUNTERS */
exp_accpr_mh1 = 0.0 ; n_mh1 = 0 ;
exp_accpr_mh2 = 0.0 ; n_mh2 = 0 ;
exp_accpr_mh3 = 0.0 ; n_mh3 = 0 ;
exp_accpr_co1 = 0.0 ; n_co1 = 0 ;
/* PERFORM PISAA ITERATIONS ------------------------------------------*/
printf("\n PERFORM PISAA ITERATIONS \n") ;
for( iter=-100; iter<=N_iteration; iter++ ) {
/* UPDATE THE TEMPERATURE -------------------------------------- */
if( iter <= temp_saa_warmup )
temp_saa = temp_saa_high + temp_saa_low ;
else{
temp_saa = temp_saa_warmup/((double) iter) ;
temp_saa = temp_saa_high*pow(temp_saa,temp_saa_pow)
+ temp_saa_low ;
}
/* SAMPLING UPDATE -------------------------------------------- */
lab_mcmc = integerrng(1, 3) ;
switch ( lab_mcmc ) {
case 0 :
break ;
case 1 :
/*sample*/
sumv = 0.0 ;
for (pop=1 ; pop<=N_population ; pop++ ) {
Mutation_TemporalOrderChange(x[pop], xmat[pop],
&fx[pop], fx_cond[pop],
N_node,
&changelength[pop], changelist[pop],
theta, grid_points, grid_size,
temp_saa, &accpr,
work1_i1, work3_i2, work2_d1) ;
sumv += accpr ;
}
accpr = sumv/pop ;
exp_accpr_mh1 += accpr ; n_mh1++ ;
break ;
case 2 :
/*sample*/
sumv = 0.0 ;
for (pop=1 ; pop<=N_population ; pop++ ) {
Mutation_SkeletalChange(x[pop], xmat[pop],
&fx[pop], fx_cond[pop],
N_node,
&changelength[pop], changelist[pop],
theta, grid_points, grid_size,
temp_saa, &accpr,
work1_i1, work3_i2, work2_d1) ;
sumv += accpr ;
}
accpr = sumv/pop ;
exp_accpr_mh2 += accpr ; n_mh2++ ;
break ;
case 3 :
/*sample*/
sumv = 0.0 ;
for (pop=1 ; pop<=N_population ; pop++ ) {
Mutation_DoubleSkeletalChange(x[pop], xmat[pop],
&fx[pop], fx_cond[pop],
N_node,
&changelength[pop], changelist[pop],
theta, grid_points, grid_size,
temp_saa, &accpr,
work1_i1, work3_i2, work2_d1) ;
sumv += accpr ;
}
accpr = sumv/pop ;
exp_accpr_mh3 += accpr ; n_mh3++ ;
break ;
case 4 :
/*sample*/
Crossover_int_Kpoint(x, xmat,
fx, fx_cond,
N_node, N_population,
changelength, changelist,
theta, grid_points, grid_size,
temp_saa, &accpr,
work3_i2, work5_i2, work1_i1,
work2_d1, work4_d1) ;
exp_accpr_co1 += accpr ; n_co1++ ;
break ;
default :
break ;
}
/* UPDATE THE GAIN FUNCTION ------------------------------------ */
if( iter <= gain_warmup )
gain = gain_high ;
else {
gain = gain_warmup/((double) iter) ;
gain = gain_high*pow( gain,gain_pow) ;
}
/* WEIGHTING UPDATE -------------------------------------------- */
self_adj_theta_update(fx, N_population,
theta, grid_points, grid_size,
freq_ref, gain, work0_d1) ;
for (i=1;i<=grid_size+1;i++) freq_est[i] += work0_d1[i] ;
/* BEST VALUE UPDATE ------------------------------------------- */
update_best_value(z_best, zmat_best, &fz_best, fz_cond_best,
x, xmat, fx, fx_cond, N_node, N_population ) ;
/* KEEP RECORDS ------------------------------------------------ */
if ( iter > 0 && iter%N_thinning == 0 && N_sample>0)
printf("iter=%d gain=%f temp_saa=%f min=%f \n",
iter, gain, temp_saa, fz_best ) ;
if (ins_fz_best_trace != NULL)
if (iter>0 && iter%N_thinning==0 && N_sample>0) {
fprintf(ins_fz_best_trace,"%d %f \n", iter, fz_best) ;
fflush(ins_fz_best_trace) ;
}
} /* ... ITERATIONS*/
/*THETA-NORMALIZATION STEP ----------------------------------------- */
printf("\n THETA-NORMALIZATION STEP \n") ;
for ( i=1 ; i<=grid_size+1 ; i++ ) freq_est[i] /= N_iteration ;
self_adj_theta_norm(theta,freq_ref,freq_est,grid_size,theta_norm_const) ;
/* RECORD THE SELF-ADJUSTMENT MECHANISM */
if (ins_hist != NULL){
for ( i=1 ; i<=grid_size ; i++ )
fprintf(ins_hist, "%d %f %f %15.15f %f %f \n",
i,grid_points[i],
theta[i], exp(theta[i]),
freq_ref[i], freq_est[i]) ;
i = grid_size+1 ;
fprintf(ins_hist, "%d %f %f %f %f %f \n",
i,0.0,
theta[i], exp(theta[i]),
freq_ref[i], freq_est[i]) ;
fflush(ins_hist) ;
}
/* RECORD BEST VALUES ---------------------------------------------- */
printf("\n RECORD BEST VALUES \n") ;
if (ins_fz_best != NULL){
fprintf(ins_fz_best, "%f \n", fz_best) ;
for (i=1; i<=N_node; i++)
fprintf(ins_fz_best, "%f ", fz_cond_best[i]) ;
fprintf(ins_fz_best, "\n") ;
for (i=1; i<=N_node; i++)
fprintf(ins_fz_best, "%d ", z_best[i]) ;
fprintf(ins_fz_best, "\n") ;
for (i=1; i<=N_node; i++) {
for (j=1; j<=N_node; j++)
fprintf(ins_fz_best, "%d ", zmat_best[i][j]) ;
fprintf(ins_fz_best, "\n") ;
}
fflush(ins_fz_best) ;
}
/* SUMMARY --------------------------------------------------------- */
printf("\n SUMMARY \n") ;
/*Result*/
printf( "\n ...Result \n");
printf( "fz_best : %f \n",fz_best) ;
printf( "fz_best_cond : \n") ;
for (i=1; i<=N_node; i++) printf("%f ", fz_cond_best[i]) ;
printf("\n") ;
printf( "z_best : \n") ;
for ( i=1 ; i<=N_node ; i++ ) printf("%d ", z_best[i]) ;
printf("\n") ;
printf( "zmat_best : \n") ;
for ( i=1 ; i<=N_node ; i++ ) {
for ( j=1 ; j<=N_node ; j++ ) printf("%d ", zmat_best[i][j]) ;
printf("\n") ;
}
/*Acceptance ratios*/
printf( "\n ...Acceptance ratios \n");
exp_accpr_mh1 /= n_mh1 ;
exp_accpr_mh2 /= n_mh2 ;
exp_accpr_mh3 /= n_mh3 ;
exp_accpr_co1 /= n_co1 ;
printf( "mh1 rate=%f \n",exp_accpr_mh1);
printf( "mh2 rate=%f \n",exp_accpr_mh2);
printf( "mh3 rate=%f \n",exp_accpr_mh3);
printf( "co1 rate=%f \n",exp_accpr_co1);
/* CLOSE FILES -------------------------------------------------------- */
printf("\n CLOSE FILES \n") ;
if (ins_hist != NULL) fclose( ins_hist ) ;
if (ins_fz_best_trace != NULL) fclose( ins_fz_best_trace ) ;
if (ins_fz_best != NULL) fclose( ins_fz_best ) ;
/* FREE SPACE --------------------------------------------------------- */
printf("\n FREE SPACE \n") ;
free_dvector(grid_points, 1, grid_size) ;
free_dvector(freq_ref, 1, grid_size+1) ;
free_dvector(freq_est, 1, grid_size+1) ;
free_dvector(theta, 1, grid_size+1) ;
free_dvector(fx, 1, N_population) ;
free_imatrix(x, 1, N_population, 1, N_node) ;
free_i3tensor(xmat, 1, N_population, 1, N_node, 1, N_node) ;
free_dmatrix(fx_cond, 1, N_population, 1, N_node) ;
free_ivector(changelength, 1, N_population) ;
free_imatrix(changelist, 1, N_population, 1, N_node) ;
free_ivector(z_best, 1, N_node) ;
free_imatrix(zmat_best, 1, N_node, 1, N_node) ;
free_dvector(fz_cond_best, 1, N_node ) ;
free_dvector(work0_d1, 1, grid_size+1) ;
free_ivector(work1_i1, 1, N_node) ;
free_dvector(work2_d1, 1, N_node) ;
free_imatrix(work3_i2, 1, N_node, 1, N_node) ;
free_dvector(work4_d1, 1, N_node) ;
free_imatrix(work5_i2, 1, N_node, 1, N_node) ;
printf("\n\nDONE\n") ;
return 0 ;
}
