int main(int argc, char *argv[])
{
struct image image;
const double incr_frac = 1.0/1000000.0;
double incr_val;
double ax, ay, az;
double bx, by, bz;
double cx, cy, cz;
UnitCell *cell;
Crystal *cr;
struct quaternion orientation;
int i;
int fail = 0;
int quiet = 0;
int plot = 0;
int c;
gsl_rng *rng;
const struct option longopts[] = {
{"quiet", 0, &quiet, 1},
{"plot", 0, &plot, 1},
{0, 0, NULL, 0}
};
while ((c = getopt_long(argc, argv, "", longopts, NULL)) != -1) {
switch (c) {
case 0 :
break;
case '?' :
break;
default :
ERROR("Unhandled option '%c'\n", c);
break;
}
}
image.width = 1024;
image.height = 1024;
image.det = simple_geometry(&image);
image.det->panels[0].res = 13333.3;
image.det->panels[0].clen = 80e-3;
image.det->panels[0].coffset = 0.0;
image.lambda = ph_en_to_lambda(eV_to_J(8000.0));
image.div = 1e-3;
image.bw = 0.01;
image.filename = malloc(256);
cr = crystal_new();
if ( cr == NULL ) {
ERROR("Failed to allocate crystal.\n");
return 1;
}
crystal_set_mosaicity(cr, 0.0);
crystal_set_profile_radius(cr, 0.005e9);
crystal_set_image(cr, &image);
cell = cell_new_from_parameters(10.0e-9, 10.0e-9, 10.0e-9,
deg2rad(90.0),
deg2rad(90.0),
deg2rad(90.0));
rng = gsl_rng_alloc(gsl_rng_mt19937);
for ( i=0; i<2; i++ ) {
UnitCell *rot;
double val;
PartialityModel pmodel;
if ( i == 0 ) {
pmodel = PMODEL_SPHERE;
STATUS("Testing flat sphere model:\n");
} else {
pmodel = PMODEL_GAUSSIAN;
STATUS("Testing Gaussian model:\n");
}
/* No point testing TES model, because it has no Lorentz factor */
orientation = random_quaternion(rng);
rot = cell_rotate(cell, orientation);
crystal_set_cell(cr, rot);
cell_get_reciprocal(rot,
&ax, &ay, &az, &bx, &by,
&bz, &cx, &cy, &cz);
incr_val = incr_frac * image.div;
val = test_gradients(cr, incr_val, REF_DIV, "div", "div",
pmodel, quiet, plot);
if ( val < 0.99 ) fail = 1;
}
gsl_rng_free(rng);
return fail;
}
void hSDM_binomial_iCAR (
// Constants and data
const int *ngibbs, int *nthin, int *nburn, // Number of iterations, burning and samples
const int *nobs, // Number of observations
const int *ncell, // Constants
const int *np, // Number of fixed effects for theta
const int *Y_vect, // Number of successes (presences)
const int *T_vect, // Number of trials
const double *X_vect, // Suitability covariates
// Spatial correlation
const int *C_vect, // Cell Id
const int *nNeigh, // Number of neighbors for each cell
const int *Neigh_vect, // Vector of neighbors sorted by cell
// Predictions
const int *npred, // Number of predictions
const double *X_pred_vect, // Suitability covariates for predictions
const int *C_pred_vect, // Cell Id for predictions
// Starting values for M-H
const double *beta_start,
const double *rho_start,
// Parameters to save
double *beta_vect,
double *rho_pred,
double *Vrho,
// Defining priors
const double *mubeta, double *Vbeta,
const double *priorVrho,
const double *shape, double *rate,
const double *Vrho_max,
// Diagnostic
double *Deviance,
double *theta_latent, // Latent proba of suitability (length NOBS)
double *theta_pred, // Proba of suitability for predictions (length NPRED)
// Seeds
const int *seed,
// Verbose
const int *verbose,
// Save rho and p
const int *save_rho,
const int *save_p
) {
////////////////////////////////////////////////////////////////////////////////
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Defining and initializing objects
////////////////////////////////////////
// Initialize random number generator //
gsl_rng *r=gsl_rng_alloc(gsl_rng_mt19937);
gsl_rng_set(r,seed[0]);
///////////////////////////
// Redefining constants //
const int NGIBBS=ngibbs[0];
const int NTHIN=nthin[0];
const int NBURN=nburn[0];
const int NSAMP=(NGIBBS-NBURN)/NTHIN;
const int NOBS=nobs[0];
const int NCELL=ncell[0];
const int NP=np[0];
const int NPRED=npred[0];
///////////////////////////////////
// Declaring some useful objects //
double *theta_run=malloc(NOBS*sizeof(double));
for (int n=0; n<NOBS; n++) {
theta_run[n]=0.0;
}
double *theta_pred_run=malloc(NPRED*sizeof(double));
for (int m=0; m<NPRED; m++) {
theta_pred_run[m]=0.0;
}
//////////////////////////////////////////////////////////
// Set up and initialize structure for density function //
struct dens_par dens_data;
/* Data */
dens_data.NOBS=NOBS;
dens_data.NCELL=NCELL;
// Y
dens_data.Y=malloc(NOBS*sizeof(int));
for (int n=0; n<NOBS; n++) {
dens_data.Y[n]=Y_vect[n];
}
// T
dens_data.T=malloc(NOBS*sizeof(int));
for (int n=0; n<NOBS; n++) {
dens_data.T[n]=T_vect[n];
}
/* Spatial correlation */
// IdCell
dens_data.IdCell=malloc(NOBS*sizeof(int));
for (int n=0; n<NOBS; n++) {
dens_data.IdCell[n]=C_vect[n];
}
// nObsCell
dens_data.nObsCell=malloc(NCELL*sizeof(int));
for (int i=0; i<NCELL; i++) {
dens_data.nObsCell[i]=0;
for (int n=0; n<NOBS; n++) {
if (dens_data.IdCell[n]==i) {
dens_data.nObsCell[i]++;
}
}
}
// PosCell
dens_data.PosCell=malloc(NCELL*sizeof(int*));
for (int i=0; i<NCELL; i++) {
dens_data.PosCell[i]=malloc(dens_data.nObsCell[i]*sizeof(int));
int repCell=0;
for (int n=0; n<NOBS; n++) {
if (dens_data.IdCell[n]==i) {
dens_data.PosCell[i][repCell]=n;
repCell++;
}
}
}
// Number of neighbors by cell
dens_data.nNeigh=malloc(NCELL*sizeof(int));
for (int i=0; i<NCELL; i++) {
dens_data.nNeigh[i]=nNeigh[i];
}
// Neighbor identifiers by cell
int posNeigh=0;
dens_data.Neigh=malloc(NCELL*sizeof(int*));
for (int i=0; i<NCELL; i++) {
dens_data.Neigh[i]=malloc(nNeigh[i]*sizeof(int));
for (int m=0; m<nNeigh[i]; m++) {
dens_data.Neigh[i][m]=Neigh_vect[posNeigh+m];
}
posNeigh+=nNeigh[i];
}
dens_data.pos_rho=0;
dens_data.rho_run=malloc(NCELL*sizeof(double));
for (int i=0; i<NCELL; i++) {
dens_data.rho_run[i]=rho_start[i];
}
dens_data.shape=shape[0];
dens_data.rate=rate[0];
dens_data.Vrho_run=Vrho[0];
/* Suitability process */
dens_data.NP=NP;
dens_data.pos_beta=0;
dens_data.X=malloc(NOBS*sizeof(double*));
for (int n=0; n<NOBS; n++) {
dens_data.X[n]=malloc(NP*sizeof(double));
for (int p=0; p<NP; p++) {
dens_data.X[n][p]=X_vect[p*NOBS+n];
}
}
dens_data.mubeta=malloc(NP*sizeof(double));
dens_data.Vbeta=malloc(NP*sizeof(double));
for (int p=0; p<NP; p++) {
dens_data.mubeta[p]=mubeta[p];
dens_data.Vbeta[p]=Vbeta[p];
}
dens_data.beta_run=malloc(NP*sizeof(double));
for (int p=0; p<NP; p++) {
dens_data.beta_run[p]=beta_start[p];
}
/* Visited cell or not */
int *viscell = malloc(NCELL*sizeof(int));
for (int i=0; i<NCELL; i++) {
viscell[i]=0;
}
for (int n=0; n<NOBS; n++) {
viscell[dens_data.IdCell[n]]++;
}
int NVISCELL=0;
for (int i=0; i<NCELL; i++) {
if (viscell[i]>0) {
NVISCELL++;
}
}
/* Predictions */
// IdCell_pred
int *IdCell_pred=malloc(NPRED*sizeof(int));
for (int m=0; m<NPRED; m++) {
IdCell_pred[m]=C_pred_vect[m];
}
// X_pred
double **X_pred=malloc(NPRED*sizeof(double*));
for (int m=0; m<NPRED; m++) {
X_pred[m]=malloc(NP*sizeof(double));
for (int p=0; p<NP; p++) {
X_pred[m][p]=X_pred_vect[p*NPRED+m];
}
}
////////////////////////////////////////////////////////////
// Proposal variance and acceptance for adaptive sampling //
// beta
double *sigmap_beta = malloc(NP*sizeof(double));
int *nA_beta = malloc(NP*sizeof(int));
double *Ar_beta = malloc(NP*sizeof(double)); // Acceptance rate
for (int p=0; p<NP; p++) {
nA_beta[p]=0;
sigmap_beta[p]=1.0;
Ar_beta[p]=0.0;
}
// rho
double *sigmap_rho = malloc(NCELL*sizeof(double));
int *nA_rho = malloc(NCELL*sizeof(int));
double *Ar_rho = malloc(NCELL*sizeof(double)); // Acceptance rate
for (int i=0; i<NCELL; i++) {
nA_rho[i]=0;
sigmap_rho[i]=1.0;
Ar_rho[i]=0.0;
}
////////////
// Message//
Rprintf("\nRunning the Gibbs sampler. It may be long, please keep cool :)\n\n");
R_FlushConsole();
//R_ProcessEvents(); for windows
///////////////////////////////////////////////////////////////////////////////////////
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Gibbs sampler
for (int g=0; g<NGIBBS; g++) {
////////////////////////////////////////////////
// beta
for (int p=0; p<NP; p++) {
dens_data.pos_beta=p; // Specifying the rank of the parameter of interest
double x_now=dens_data.beta_run[p];
double x_prop=x_now+gsl_ran_gaussian_ziggurat(r,sigmap_beta[p]);
double p_now=betadens(x_now, &dens_data);
double p_prop=betadens(x_prop, &dens_data);
double ratio=exp(p_prop-p_now); // ratio
double z=gsl_rng_uniform(r);
// Actualization
if (z < ratio) {
dens_data.beta_run[p]=x_prop;
nA_beta[p]++;
}
}
////////////////////////////////////////////////
// rho
/* Sampling rho_run[i] */
for (int i=0; i<NCELL; i++) {
dens_data.pos_rho=i; // Specifying the rank of the parameter of interest
if (viscell[i]>0) {
double x_now=dens_data.rho_run[i];
double x_prop=x_now+gsl_ran_gaussian_ziggurat(r, sigmap_rho[i]);
double p_now=rhodens_visited(x_now, &dens_data);
double p_prop=rhodens_visited(x_prop, &dens_data);
double ratio=exp(p_prop-p_now); // ratio
double z=gsl_rng_uniform(r);
// Actualization
if (z < ratio) {
dens_data.rho_run[i]=x_prop;
nA_rho[i]++;
}
}
else {
dens_data.rho_run[i]=rhodens_unvisited(r, &dens_data);
}
}
/* Centering rho_run[i] */
double rho_sum=0.0;
for (int i=0; i<NCELL; i++) {
rho_sum+=dens_data.rho_run[i];
}
double rho_bar=rho_sum/NCELL;
for (int i=0; i<NCELL; i++) {
dens_data.rho_run[i]=dens_data.rho_run[i]-rho_bar;
}
////////////////////////////////////////////////
// Vrho
if (priorVrho[0]>0.0) { // fixed value for Vrho
dens_data.Vrho_run=priorVrho[0];
}
else {
double Sum=0.0;
for (int i=0; i<NCELL; i++) {
double Sum_neigh=0.0;
double nNeigh=dens_data.nNeigh[i];
double rho_run=dens_data.rho_run[i];
for (int m=0; m<nNeigh; m++) {
Sum_neigh += dens_data.rho_run[dens_data.Neigh[i][m]];
}
Sum += rho_run*(nNeigh*rho_run-Sum_neigh);
}
if (priorVrho[0]==-1.0) { // prior = 1/Gamma(shape,rate)
double Shape=shape[0]+0.5*(NCELL-1);
double Rate=rate[0]+0.5*Sum;
dens_data.Vrho_run=Rate/gsl_ran_gamma(r, Shape, 1.0);
}
if (priorVrho[0]==-2.0) { // prior = Uniform(0,Vrho_max)
double Shape=0.5*NCELL-1;
double Rate=0.5*Sum;
dens_data.Vrho_run=1/myrtgamma_left_gsl(r, Shape, Rate, 1/Vrho_max[0]);
}
}
//////////////////////////////////////////////////
// Deviance
// logLikelihood
double logL=0.0;
for (int n=0; n<NOBS; n++) {
/* theta */
double Xpart_theta=0.0;
for (int p=0; p<NP; p++) {
Xpart_theta+=dens_data.X[n][p]*dens_data.beta_run[p];
}
theta_run[n]=invlogit(Xpart_theta+dens_data.rho_run[dens_data.IdCell[n]]);
/* log Likelihood */
logL+=dbinom(dens_data.Y[n],dens_data.T[n],theta_run[n],1);
}
// Deviance
double Deviance_run=-2*logL;
//////////////////////////////////////////////////
// Predictions
for (int m=0; m<NPRED; m++) {
/* theta_pred_run */
double Xpart_theta_pred=0.0;
for (int p=0; p<NP; p++) {
Xpart_theta_pred+=X_pred[m][p]*dens_data.beta_run[p];
}
theta_pred_run[m]=invlogit(Xpart_theta_pred+dens_data.rho_run[IdCell_pred[m]]);
}
//////////////////////////////////////////////////
// Output
if (((g+1)>NBURN) && (((g+1)%(NTHIN))==0)) {
int isamp=((g+1)-NBURN)/(NTHIN);
for (int p=0; p<NP; p++) {
beta_vect[p*NSAMP+(isamp-1)]=dens_data.beta_run[p];
}
Deviance[isamp-1]=Deviance_run;
for (int n=0; n<NOBS; n++) {
theta_latent[n]+=theta_run[n]/NSAMP; // We compute the mean of NSAMP values
}
// rho
if (save_rho[0]==0) { // We compute the mean of NSAMP values
for (int i=0; i<NCELL; i++) {
rho_pred[i]+=dens_data.rho_run[i]/NSAMP;
}
}
if (save_rho[0]==1) { // The NSAMP sampled values for rhos are saved
for (int i=0; i<NCELL; i++) {
rho_pred[i*NSAMP+(isamp-1)]=dens_data.rho_run[i];
}
}
// prob.p
if (save_p[0]==0) { // We compute the mean of NSAMP values
for (int m=0; m<NPRED; m++) {
theta_pred[m]+=theta_pred_run[m]/NSAMP;
}
}
if (save_p[0]==1) { // The NSAMP sampled values for theta are saved
for (int m=0; m<NPRED; m++) {
theta_pred[m*NSAMP+(isamp-1)]=theta_pred_run[m];
}
}
// Vrho
Vrho[isamp-1]=dens_data.Vrho_run;
}
///////////////////////////////////////////////////////
// Adaptive sampling (on the burnin period)
const double ropt=0.234;
int DIV=0;
if (NGIBBS >=1000) DIV=100;
else DIV=NGIBBS/10;
/* During the burnin period */
if ((g+1)%DIV==0 && (g+1)<=NBURN) {
// beta
for (int p=0; p<NP; p++) {
Ar_beta[p]=((double) nA_beta[p])/DIV;
if (Ar_beta[p]>=ropt) sigmap_beta[p]=sigmap_beta[p]*(2-(1-Ar_beta[p])/(1-ropt));
else sigmap_beta[p]=sigmap_beta[p]/(2-Ar_beta[p]/ropt);
nA_beta[p]=0.0; // We reinitialize the number of acceptance to zero
}
// rho
for (int i=0; i<NCELL; i++) {
if (viscell[i]>0) {
Ar_rho[i]=((double) nA_rho[i])/DIV;
if (Ar_rho[i]>=ropt) sigmap_rho[i]=sigmap_rho[i]*(2-(1-Ar_rho[i])/(1-ropt));
else sigmap_rho[i]=sigmap_rho[i]/(2-Ar_rho[i]/ropt);
nA_rho[i]=0.0; // We reinitialize the number of acceptance to zero
}
}
}
/* After the burnin period */
if ((g+1)%DIV==0 && (g+1)>NBURN) {
// beta
for (int p=0; p<NP; p++) {
Ar_beta[p]=((double) nA_beta[p])/DIV;
nA_beta[p]=0.0; // We reinitialize the number of acceptance to zero
}
// rho
for (int i=0; i<NCELL; i++) {
if (viscell[i]>0) {
Ar_rho[i]=((double) nA_rho[i])/DIV;
nA_rho[i]=0.0; // We reinitialize the number of acceptance to zero
}
}
}
//////////////////////////////////////////////////
// Progress bar
double Perc=100*(g+1)/(NGIBBS);
if (((g+1)%(NGIBBS/100))==0 && verbose[0]==1) {
Rprintf("*");
R_FlushConsole();
//R_ProcessEvents(); for windows
if (((g+1)%(NGIBBS/10))==0) {
double mAr_beta=0; // Mean acceptance rate
double mAr_rho=0;
// beta
for (int p=0; p<NP; p++) {
mAr_beta+=Ar_beta[p]/NP;
}
// rho
for (int i=0; i<NCELL; i++) {
if (viscell[i]>0) {
mAr_rho+=Ar_rho[i]/NVISCELL;
}
}
Rprintf(":%.1f%%, mean accept. rates= beta:%.3f, rho:%.3f\n",Perc,mAr_beta,mAr_rho);
R_FlushConsole();
//R_ProcessEvents(); for windows
}
}
//////////////////////////////////////////////////
// User interrupt
R_CheckUserInterrupt(); // allow user interrupt
} // Gibbs sampler
///////////////
// Delete memory allocation (see malloc())
/* Data */
free(dens_data.Y);
free(dens_data.T);
free(dens_data.IdCell);
free(dens_data.nObsCell);
for (int i=0; i<NCELL; i++) {
free(dens_data.PosCell[i]);
}
free(dens_data.PosCell);
/* Spatial correlation */
free(dens_data.nNeigh);
for (int i=0; i<NCELL; i++) {
free(dens_data.Neigh[i]);
}
free(dens_data.Neigh);
free(dens_data.rho_run);
/* Suitability */
for (int n=0; n<NOBS; n++) {
free(dens_data.X[n]);
}
free(dens_data.X);
free(dens_data.mubeta);
free(dens_data.Vbeta);
free(dens_data.beta_run);
free(theta_run);
/* Visited cells */
free(viscell);
/* Predictions */
free(IdCell_pred);
for (int m=0; m<NPRED; m++) {
free(X_pred[m]);
}
free(X_pred);
free(theta_pred_run);
/* Adaptive MH */
free(sigmap_beta);
free(nA_beta);
free(Ar_beta);
free(sigmap_rho);
free(nA_rho);
free(Ar_rho);
/* Random seed */
gsl_rng_free(r);
} // end hSDM function
int
main (int argc, char ** argv)
{
annealing_simple_workspace_t S;
fitting_data_t D;
fitting_step_t max_step = { 1.0, 0.1, 1.0 };
configuration_t configurations[3];
int verbose_mode = 0;
{
int c;
while ((c = getopt(argc, argv, "hv")) != -1)
switch (c)
{
case 'h':
fprintf(stderr, "usage: test_fitting [-v] [-h]\n");
goto exit;
case 'v':
verbose_mode = 1;
break;
default:
fprintf(stderr, "test_fitting error: unknown option %c\n", c);
exit(EXIT_FAILURE);
}
}
printf("\n------------------------------------------------------------\n");
printf("test_fitting: exponential parameters fitting with simulated annealing\n");
/* fitting data initialisation */
{
D.num = NUM;
linspace(D.t, D.num, 0.0, 10.0);
make_observations(D.t, D.observations, D.num);
}
/* annealing workspace initialisation */
{
S.number_of_iterations_at_fixed_temperature = 10;
S.max_step_value = &max_step;
S.temperature = 10.0;
S.minimum_temperature = 0.1;
S.restart_temperature = 1.0;
S.boltzmann_constant = 1.0;
S.damping_factor = 1.005;
S.energy_function = energy_function;
S.step_function = step_function;
S.copy_function = copy_function;
S.log_function = (verbose_mode)? log_function : NULL;
S.cooling_function = NULL;
S.numbers_generator = gsl_rng_alloc(gsl_rng_rand);
gsl_rng_set(S.numbers_generator, 15);
S.current_configuration.data= &(configurations[0]);
S.best_configuration.data = &(configurations[1]);
S.new_configuration.data = &(configurations[2]);
/* start configuration */
configurations[0].A = 6.0;
configurations[0].lambda = 3.0;
configurations[0].b = 1.0;
S.params = &D;
}
annealing_simple_solve(&S);
printf("test_fitting: final best solution: %f, %f, %f; original: %g, %g, %g\n",
configurations[1].A, configurations[1].lambda, configurations[1].b,
original_params.A, original_params.lambda, original_params.b);
printf("------------------------------------------------------------\n\n");
gsl_rng_free(S.numbers_generator);
exit:
exit(EXIT_SUCCESS);
}
int
main (void)
{
gsl_ieee_env_setup ();
gsl_rng_env_setup ();
r_global = gsl_rng_alloc (gsl_rng_default);
#define FUNC(x) test_ ## x, "test gsl_ran_" #x
#define FUNC2(x) test_ ## x, test_ ## x ## _pdf, "test gsl_ran_" #x
test_shuffle ();
test_choose ();
testMoments (FUNC (ugaussian), 0.0, 100.0, 0.5);
testMoments (FUNC (ugaussian), -1.0, 1.0, 0.6826895);
testMoments (FUNC (ugaussian), 3.0, 3.5, 0.0011172689);
testMoments (FUNC (ugaussian_tail), 3.0, 3.5, 0.0011172689 / 0.0013498981);
testMoments (FUNC (exponential), 0.0, 1.0, 1 - exp (-0.5));
testMoments (FUNC (cauchy), 0.0, 10000.0, 0.5);
testMoments (FUNC (discrete1), -0.5, 0.5, 0.59);
testMoments (FUNC (discrete1), 0.5, 1.5, 0.40);
testMoments (FUNC (discrete1), 1.5, 3.5, 0.01);
testMoments (FUNC (discrete2), -0.5, 0.5, 1.0/45.0 );
testMoments (FUNC (discrete2), 8.5, 9.5, 0 );
testMoments (FUNC (discrete3), -0.5, 0.5, 0.05 );
testMoments (FUNC (discrete3), 0.5, 1.5, 0.05 );
testMoments (FUNC (discrete3), -0.5, 9.5, 0.5 );
test_dirichlet_moments ();
test_multinomial_moments ();
testPDF (FUNC2 (beta));
testPDF (FUNC2 (cauchy));
testPDF (FUNC2 (chisq));
testPDF (FUNC2 (chisqnu2));
testPDF (FUNC2 (dirichlet));
testPDF (FUNC2 (dirichlet_small));
testPDF (FUNC2 (erlang));
testPDF (FUNC2 (exponential));
testPDF (FUNC2 (exppow0));
testPDF (FUNC2 (exppow1));
testPDF (FUNC2 (exppow1a));
testPDF (FUNC2 (exppow2));
testPDF (FUNC2 (exppow2a));
testPDF (FUNC2 (exppow2b));
testPDF (FUNC2 (fdist));
testPDF (FUNC2 (fdist_large));
testPDF (FUNC2 (flat));
testPDF (FUNC2 (gamma));
testPDF (FUNC2 (gamma1));
testPDF (FUNC2 (gamma_int));
testPDF (FUNC2 (gamma_large));
testPDF (FUNC2 (gamma_vlarge));
testPDF (FUNC2 (gamma_knuth_vlarge));
testPDF (FUNC2 (gamma_small));
testPDF (FUNC2 (gamma_mt));
testPDF (FUNC2 (gamma_mt1));
testPDF (FUNC2 (gamma_mt_int));
testPDF (FUNC2 (gamma_mt_large));
testPDF (FUNC2 (gamma_mt_small));
testPDF (FUNC2 (gaussian));
testPDF (FUNC2 (gaussian_ratio_method));
testPDF (FUNC2 (gaussian_ziggurat));
testPDF (FUNC2 (ugaussian));
testPDF (FUNC2 (ugaussian_ratio_method));
testPDF (FUNC2 (gaussian_tail));
testPDF (FUNC2 (gaussian_tail1));
testPDF (FUNC2 (gaussian_tail2));
testPDF (FUNC2 (ugaussian_tail));
testPDF (FUNC2 (bivariate_gaussian1));
testPDF (FUNC2 (bivariate_gaussian2));
testPDF (FUNC2 (bivariate_gaussian3));
testPDF (FUNC2 (bivariate_gaussian4));
testPDF (FUNC2 (gumbel1));
testPDF (FUNC2 (gumbel2));
testPDF (FUNC2 (landau));
testPDF (FUNC2 (levy1));
testPDF (FUNC2 (levy2));
testPDF (FUNC2 (levy1a));
testPDF (FUNC2 (levy2a));
testPDF (FUNC2 (levy_skew1));
testPDF (FUNC2 (levy_skew2));
testPDF (FUNC2 (levy_skew1a));
testPDF (FUNC2 (levy_skew2a));
testPDF (FUNC2 (levy_skew1b));
testPDF (FUNC2 (levy_skew2b));
testPDF (FUNC2 (logistic));
testPDF (FUNC2 (lognormal));
testPDF (FUNC2 (pareto));
testPDF (FUNC2 (rayleigh));
testPDF (FUNC2 (rayleigh_tail));
testPDF (FUNC2 (tdist1));
testPDF (FUNC2 (tdist2));
testPDF (FUNC2 (laplace));
testPDF (FUNC2 (weibull));
testPDF (FUNC2 (weibull1));
testPDF (FUNC2 (dir2d));
testPDF (FUNC2 (dir2d_trig_method));
testPDF (FUNC2 (dir3dxy));
testPDF (FUNC2 (dir3dyz));
testPDF (FUNC2 (dir3dzx));
testDiscretePDF (FUNC2 (discrete1));
testDiscretePDF (FUNC2 (discrete2));
testDiscretePDF (FUNC2 (discrete3));
testDiscretePDF (FUNC2 (poisson));
testDiscretePDF (FUNC2 (poisson_large));
testDiscretePDF (FUNC2 (bernoulli));
testDiscretePDF (FUNC2 (binomial));
testDiscretePDF (FUNC2 (binomial0));
testDiscretePDF (FUNC2 (binomial1));
testDiscretePDF (FUNC2 (binomial_knuth));
testDiscretePDF (FUNC2 (binomial_large));
testDiscretePDF (FUNC2 (binomial_large_knuth));
testDiscretePDF (FUNC2 (binomial_huge));
testDiscretePDF (FUNC2 (binomial_huge_knuth));
testDiscretePDF (FUNC2 (binomial_max));
testDiscretePDF (FUNC2 (geometric));
testDiscretePDF (FUNC2 (geometric1));
testDiscretePDF (FUNC2 (hypergeometric1));
testDiscretePDF (FUNC2 (hypergeometric2));
testDiscretePDF (FUNC2 (hypergeometric3));
testDiscretePDF (FUNC2 (hypergeometric4));
testDiscretePDF (FUNC2 (hypergeometric5));
testDiscretePDF (FUNC2 (hypergeometric6));
testDiscretePDF (FUNC2 (logarithmic));
testDiscretePDF (FUNC2 (multinomial));
testDiscretePDF (FUNC2 (multinomial_large));
testDiscretePDF (FUNC2 (negative_binomial));
testDiscretePDF (FUNC2 (pascal));
gsl_rng_free (r_global);
gsl_ran_discrete_free (g1);
gsl_ran_discrete_free (g2);
gsl_ran_discrete_free (g3);
exit (gsl_test_summary ());
}
void opiniao(int **rede, par *P, int s[], unsigned long int sem, unsigned long int sem_rede, char out[], char fran[]) {
// ---------------------------------------------------
// Aqui é a parte da simulação da dinâmica de opinião.
// ---------------------------------------------------
// Obtendo os parâmetros
int *h, k_max=0; // vetor de conectividade e com o estado dos sitios;
double epsilon=P->eps, J=P->J, q=P->q;
int i, w, t, tt, T=P->T_mcs, nt=P->D_mcs; // passo monte-carlo e iterador de sítios da rede
double *tau, rho=0; // campo local de cada sítio e taca de transição
FILE *f=fopen(out,"w"), *g, *ff=fopen(fran,"r");
char ou[255];
// Variáveis do gerador
gsl_rng *r;
// Arquivo de saída de estado
strcpy(ou,out);
strcat(ou,"~");
// Iniciando a galera
h=(int *)calloc(n,I);
// Pegar o grau máximo
for(i=0;i<n;i++)
if(rede[i][0]>k_max) k_max=rede[i][0];
// Constrói as taxas de k=0 até o grau máximo
tau=make_tau(k_max,J,q,epsilon);
// Iniciando a semente de números aleatórios
r = gsl_rng_alloc (gsl_rng_mt19937);
gsl_rng_fread(ff,r);
fclose(ff);
for(i=0;i<n;i++)
rho+=s[i];
rho/=((double)n);
// Primeiro ponto na saida
fprintf(f, "%lf\n", rho);
// O monte-carlo começa aqui
for(t=0;t<T;t+=nt) {
g=fopen(ou,"w");
ff=fopen(fran,"w");
fprintf(g,"# N=%d\tk=%d\tp=%lf\tsem=-1\tJ=%lf\teps=%lf\tq=%lf\tSR=%lu\n",n,K,p,J,epsilon,q,sem_rede);
fprintf(g, "# Semente: -1\n");
for(tt=0;tt<nt;tt++) {
// Calcular o vetor h dos sítios
for(i=0;i<n;i++) {
h[i]=0;
for(w=1;w<=rede[i][0];w++) {
h[i]+=s[rede[i][w]];
}
}
// Atualiza os sítios
for(i=0;i<n;i++) {
if(gsl_rng_uniform(r)<tau[h[i]-1+(rede[i][0]+1)*rede[i][0]/2])
s[i]=1;
else
s[i]=0;
}
// Calcula a densidade de estados
rho=0;
for(i=0;i<n;i++)
rho+=s[i];
rho/=((double)n);
// Imprime saída
fprintf(f, "%lf\n", rho);
}
// Salvando o estado
for(i=0;i<n;i++)
fprintf(g, "%d\n", s[i]);
gsl_rng_fwrite(ff,r);
fclose(g);
fclose(ff);
}
free(tau);
free(h);
// Libera memória do gerador
gsl_rng_free (r);
}
int main(int argc, char** argv)
{
//--Foodweb Struktur mit Standardwerten aufstellen------------------------------------------------------------------------------------------
struct simuParams simParams = {0.3, 0.65, 0.35, 0.5, 6.0}; // Diese Parameter sind konstant
struct simuMemory simMem = {NULL, NULL, NULL, NULL, NULL}; // Größe der Vektoren liegt noch nicht fest
gsl_vector* fixpunkte = gsl_vector_calloc(9);
struct foodweb nicheweb = {NULL, fixpunkte, NULL,&simParams, &simMem, 18, 3, 1, 5, 0, 0, -7., 0.0, 0, 1}; // Reihenfolge: network, fxpkt, migrPara, AllMus, AllNus, S, B, Rnum, Y, T, Tchoice, d, x, M, Z
struct migration stochastic = {NULL, NULL, NULL, NULL, NULL, NULL, 0.00001, NULL, NULL, NULL, NULL, NULL};
struct resource res = {500.0, 0.0}; // Resource: Größe, Wachstum
//--Konsoleneingabe-------------------------------------------------------------------------------------------------------------------------
int L = 5; // Statistik
int i = 0,j; // Counter
char aims6[255] = ORT;
FILE* RobustnessEachRun;
int checksum = getArgs(argc, argv, &(nicheweb.S), &(nicheweb.B), &(nicheweb.T), &(nicheweb.d), &L, &(nicheweb.Y), &(nicheweb.x), &(nicheweb.M), &(res.size), &(nicheweb.Z), &(stochastic.Bmigr));
if (checksum != 11 && checksum!=(int)(argc-1)/2) // Alles gesetzt?
{
printf("Bitte gültige Eingabe für Parameter machen!\nProgramm wird beendet.\n");
return(0);
}
/* int length = ((nicheweb.Rnum+nicheweb.S)*(nicheweb.S+nicheweb.Rnum)+1+nicheweb.Y*nicheweb.Y+1+(nicheweb.Rnum+nicheweb.S)+nicheweb.S+1); // Länge des Rückabewerts
nicheweb.network = gsl_vector_calloc(length);
*/
// Speicher belegen, nachdem die Größe des Systems durch die Konsoleneingabe bekannt ist
CallocFoodwebMem(&nicheweb);
CallocStochasticMem(&stochastic, nicheweb.Y, nicheweb.S);
printf("Z = %i\n",nicheweb.Z);
nicheweb.migrPara = gsl_vector_calloc(7); // Reihenfolge: tau, mu, nu, SpeciesNumber, momentanes t, ymigr, migrationEventNumber
// stochastic.SpeciesNumbers = gsl_vector_calloc(nicheweb.Z);
// stochastic.AllMus = gsl_vector_calloc(nicheweb.Z);
// stochastic.AllNus = gsl_vector_calloc(nicheweb.Z);
// stochastic.Biomass_SpeciesNumbers = gsl_vector_calloc(nicheweb.Z);
// stochastic.Biomass_AllMus = gsl_vector_calloc(nicheweb.Z);
// stochastic.Biomass_AllNus = gsl_vector_calloc(nicheweb.Z);
//--Zufallszahlengenerator initialisieren--------------------------------------------------------------------------------
const gsl_rng_type *rng1_T; // ****
gsl_rng *rng1; // initialize random number generator
gsl_rng_env_setup(); // ermöglicht Konsolenparameter
rng1_T = gsl_rng_default; // default random number generator (so called mt19937)
gsl_rng_default_seed = 0; // default seed for rng
// gsl_rng_default_seed = ((unsigned)time(NULL)); // random starting seed for rng
rng1 = gsl_rng_alloc(rng1_T);
//--Struct initialisieren für patchweise Ausgabe----------------------------------------------------------------------------------------
struct data patchwise[nicheweb.Y];
for(i=0; i<nicheweb.Y; i++)
{
gsl_vector* sini = gsl_vector_calloc(6);
gsl_vector* sfini = gsl_vector_calloc(6);
gsl_vector* bini = gsl_vector_calloc(6);
gsl_vector* bfini = gsl_vector_calloc(6);
gsl_vector* robness = gsl_vector_calloc(2);
//struct data tempo = {sini,sfini,bini,bfini,robness};
struct data temp = {sini,sfini,bini,bfini,robness};
patchwise[i] = temp;
}
//printf("test");
//--Initialisierungen---------------------------------------------------------------------------------------------------
nicheweb.Tchoice = nicheweb.T;
nicheweb.T = 0;
nicheweb.d = nicheweb.d/10;
printf("d ist %f\n",nicheweb.d);
res.size = res.size/10;
stochastic.Bmigr = 2.5*stochastic.Bmigr*pow(10,nicheweb.d);
nicheweb.Z = pow(10,nicheweb.Z);
printf("Bmigr ist %f\n",stochastic.Bmigr);
printf("Z ist %i\n",nicheweb.Z);
printf("x ist %f\n",nicheweb.x);
//int len = ((nicheweb.Rnum+nicheweb.S)*(nicheweb.S+nicheweb.Rnum)+1+nicheweb.Y*nicheweb.Y+1+(nicheweb.Rnum+nicheweb.S)+nicheweb.S); // Länge des Rückabewerts
gsl_vector *populationFIN = gsl_vector_calloc((nicheweb.Rnum + nicheweb.S)*(nicheweb.Y)*5 + (nicheweb.S) + 3); // Gleiche Länge wie Rückgabe von evolveNetwork
gsl_vector *robustness = gsl_vector_calloc(63);
gsl_vector *resultEvolveWeb = gsl_vector_calloc((nicheweb.Rnum+nicheweb.S)*nicheweb.Y*5 + 3 + nicheweb.S); // y[Simulation], y0, ymax, ymin, yavg, fixp, TL
gsl_vector *resultRobustness = gsl_vector_calloc(63);
gsl_matrix *D = gsl_matrix_calloc(nicheweb.Y,nicheweb.Y);
gsl_matrix* Dchoice = gsl_matrix_calloc(nicheweb.Y,nicheweb.Y);
gsl_vector *robustnesstemp = gsl_vector_calloc(63);
gsl_vector *meanSquOfDataAll = gsl_vector_calloc(63);
gsl_vector *meanSquOfDataAlltemp = gsl_vector_calloc(63);
gsl_vector *standardDeviationAll = gsl_vector_calloc(63);
gsl_vector *meanOfData = gsl_vector_calloc((6*4+2)*nicheweb.Y);
gsl_vector *meanOfDatatemp = gsl_vector_calloc((6*4+2)*nicheweb.Y);
gsl_vector *meanSquOfData = gsl_vector_calloc((6*4+2)*nicheweb.Y);
gsl_vector *standardDeviation = gsl_vector_calloc((6*4+2)*nicheweb.Y);
gsl_vector_set_zero(robustness);
gsl_vector_set_zero(meanOfData);
gsl_vector_set_zero(meanSquOfData);
gsl_vector_set_zero(nicheweb.migrPara);
gsl_vector_set_zero(meanSquOfDataAll);
// double SpeciesNumber[L*nicheweb.Z][2];
// double AllMu[L*nicheweb.Z][2];
// double AllNu[L*nicheweb.Z][2];
double ymigr = 0;
double mu = 0;
double nu = 0;
double ymigrtemp;
double ymigrSqu = 0;
double ymigrDeviation;
double migrationEventNumber = 0;
double migrationEventNumbertemp;
double migrationEventNumberSqu = 0.0;
double migrationEventNumberDeviation;
int lastMigrationEventNumber = 0;
//--Simulation---------------------------------------------------------------------------------------------------------------------
//SetTopology(nicheweb.Y, nicheweb.T, D);
SetTopology(nicheweb.Y, nicheweb.Tchoice, Dchoice);
// for(i = 0; i<nicheweb.Y; i++)
// {
// for(j = 0 ; j<nicheweb.Y; j++)
// {
// printf("%f\t",gsl_matrix_get(Dchoice,i,j));
// }
// printf("\n");
// }
for(i = 0; i < L; i++)
{
// const gsl_rng_type *rng1_T; // ****
// gsl_rng *rng1; // initialize random number generator
// gsl_rng_env_setup(); // ermöglicht Konsolenparameter
// rng1_T = gsl_rng_default; // default random number generator (so called mt19937)
// gsl_rng_default_seed = 0; // default seed for rng
// //gsl_rng_default_seed = ((unsigned)time(NULL)); // random starting seed for rng
// rng1 = gsl_rng_alloc(rng1_T);
printf("\nStarte Durchlauf L = %i\n", i);
//--Starte Simulation-----------------------------------------------------------------------------------------------
SetNicheNetwork(nicheweb, stochastic, res, rng1, rng1_T, D);
gsl_vector_set_zero(resultEvolveWeb);
populationFIN = EvolveNetwork(nicheweb, stochastic, rng1, rng1_T, Dchoice, resultEvolveWeb);
gsl_vector_set_zero(resultRobustness);
gsl_vector_memcpy(robustnesstemp, EvaluateRobustness(populationFIN, nicheweb, patchwise, resultRobustness)); // Robustness Analyse
//--Standardabweichung für Mittelung vorbereiten-----------------------------------------------------------------------------------------
determineMean(robustnesstemp, 63, robustness);
determineMeanSqu(robustnesstemp, 63, meanSquOfDataAll);
//--Ausgabewerte----------------------------------------------------------------------------------------------------------
ymigrtemp = gsl_vector_get(nicheweb.migrPara, 5);
migrationEventNumbertemp = gsl_vector_get(nicheweb.migrPara, 6);
// for(int j= 0; j<migrationEventNumbertemp; j++)
// {
// AllMu[lastMigrationEventNumber+j][0] = gsl_vector_get(stochastic.AllMus, j);
// AllNu[lastMigrationEventNumber+j][0] = gsl_vector_get(stochastic.AllNus, j);
// SpeciesNumber[lastMigrationEventNumber+j][0] = gsl_vector_get(stochastic.SpeciesNumbers,j);
//
// AllMu[lastMigrationEventNumber+j][1] = gsl_vector_get(stochastic.Biomass_AllMus, j);
// AllNu[lastMigrationEventNumber+j][1] = gsl_vector_get(stochastic.Biomass_AllNus, j);
// SpeciesNumber[lastMigrationEventNumber+j][1] = gsl_vector_get(stochastic.Biomass_SpeciesNumbers,j);
// }
lastMigrationEventNumber += migrationEventNumbertemp;
//printf("SpeciesNumber ist %f\n",SpeciesNumber[i]);
ymigr += ymigrtemp;
migrationEventNumber += migrationEventNumbertemp;
ymigrSqu += (ymigrtemp*ymigrtemp);
migrationEventNumberSqu = (migrationEventNumberSqu*(i)+(migrationEventNumbertemp*migrationEventNumbertemp))/(i+1);
// printf("Additionsteil ist %f\n",(migrationEventNumberSqu*(i)+(migrationEventNumbertemp*migrationEventNumbertemp))/(i+1));
//--Mittelwert und Vorbereitungen für Standardabweichung für die patchweise Ausgabe berechnen--------------------------------
linkElements(patchwise, nicheweb.Y, meanOfDatatemp);
determineMean(meanOfDatatemp, (6*4+2)*nicheweb.Y, meanOfData);
determineMeanSqu(meanOfDatatemp, (6*4+2)*nicheweb.Y, meanSquOfData);
createOutputRobustnessPatchwiseEachRun(nicheweb,patchwise,aims6,RobustnessEachRun,i);
printf("\nBeende Durchlauf L = %i\n", i);
}
//-- Standardabweichung berechnen--------------------------------------------------------------------------------------
ymigrSqu = ymigrSqu/L;
ymigr = ymigr/L;
ymigrDeviation = sqrt(ymigrSqu - ymigr*ymigr);
//migrationEventNumberSqu = migrationEventNumberSqu/L;
migrationEventNumber = migrationEventNumber/L;
migrationEventNumberDeviation = sqrt(migrationEventNumberSqu - migrationEventNumber*migrationEventNumber);
// printf("migrationEventNumber ist %f\n",migrationEventNumber);
// printf("migrationEventNumberSqu ist %f\n",migrationEventNumberSqu);
// printf("migrationEventNumberDeviation ist %f\n",migrationEventNumberDeviation);
//
//-- Für patchweise Ausgabe-------------------------------------------------------------------------------------------
standardDeviation = determineStandardDeviation((6*4+2)*nicheweb.Y, meanOfData, meanSquOfData, L, standardDeviation);
standardDeviationAll = determineStandardDeviation(63, robustness, meanSquOfDataAll, L, standardDeviationAll);
//printf("der 3. Eintrag in standardDeviationAll ist %f\n", gsl_vector_get(standardDeviationAll,3));
// printf("S ist %f\n", gsl_vector_get(robustness,3));
// printf("Standardabweichung von S ist %f\n", gsl_vector_get(standardDeviationAll,3));
// printf("meanOfDataSqu ist %f\n", gsl_vector_get(meanOfDataSquAll,3));
// printf("meanSquOfData ist %f\n", gsl_vector_get(meanSquOfDataAll,3));
printf("L=%i\tspeciesini=%f\tspeciesfinal=%f\n", L, gsl_vector_get(robustness, 3)/L, gsl_vector_get(robustness, 9)/L);
//--Abspeichern in File-------------------------------------------------------------------------------------
char aims[255] = ORT;
createOutputGeneral(nicheweb, res, stochastic, aims, robustness, standardDeviationAll, L, mu, nu, ymigr, ymigrDeviation, migrationEventNumber, migrationEventNumberDeviation); // Datei schließen
//--Daten patchweise abspeichern----------------------------------------------------------------------
// printf("population ist %f\n",gsl_vector_get(stochastic.Biomass_AllMus,0));
for(int l = 0 ; l< nicheweb.Y; l++)
{
//char name[100];
char aims2[255] = ORT2;
createOutputPatchwise(nicheweb, res, stochastic, aims2, meanOfData, standardDeviation, L, l);
}
// if(nicheweb.Tchoice != 0)
// {
//--Ausgewählte Spezies rausschreiben, die migrieren darf---------------------------------------------------------------------------
// char aims3[255] = ORT;
//
// //createOutputSpeciesNumber(nicheweb, res, aims3, SpeciesNumber, L, migrationEventNumber);
//
//
// //--Ausgewählte Verbindung rausschreiben, über die migriert werden darf---------------------------------------------------------------------------
//
// char aims4[255] = ORT;
//
// // createOutputPatchlink(nicheweb, res, aims4, AllMu, AllNu, L, migrationEventNumber);
// }
printf("\nSimulation abgespeichert\n\n");
//--free----------------------------------------------------------------------------------------------------------------
free(nicheweb.network);
gsl_vector_free(fixpunkte);
for(i=0; i<nicheweb.Y; i++)
{
gsl_vector_free(patchwise[i].sini);
gsl_vector_free(patchwise[i].sfini);
gsl_vector_free(patchwise[i].bini);
gsl_vector_free(patchwise[i].bfini);
gsl_vector_free(patchwise[i].robness);
}
FreeFoodwebMem(&nicheweb); // eigene Funktion
FreeStochasticMem(&stochastic);
gsl_vector_free(nicheweb.migrPara);
// gsl_vector_free(stochastic.AllMus);
// gsl_vector_free(stochastic.AllNus);
// gsl_vector_free(stochastic.SpeciesNumbers);
// gsl_vector_free(stochastic.Biomass_AllMus);
// gsl_vector_free(stochastic.Biomass_AllNus);
// gsl_vector_free(stochastic.Biomass_SpeciesNumbers);
gsl_vector_free(populationFIN);
gsl_vector_free(robustness);
gsl_vector_free(meanOfData);
gsl_vector_free(meanOfDatatemp);
gsl_vector_free(meanSquOfData);
gsl_vector_free(standardDeviation);
gsl_vector_free(standardDeviationAll);
gsl_vector_free(meanSquOfDataAll);
gsl_vector_free(meanSquOfDataAlltemp);
gsl_matrix_free(D);
gsl_matrix_free(Dchoice);
//gsl_vector_free(resultEvolveWeb);
gsl_vector_free(robustnesstemp);
gsl_rng_free(rng1);
return(0);
}
void pcat_client_cleanup( pcat_client client )
{
pcat_space_cleanup( &client->space );
pcat_map_destroy( &client->tested_points );
gsl_rng_free( client->rng );
}
void Testrapt(CuTest* tc) {
gsl_vector* x = gsl_vector_alloc(DIM);
gsl_vector_set_all(x, 0.0);
gsl_rng* rng = gsl_rng_alloc(gsl_rng_default);
gsl_matrix* sigma_whole = gsl_matrix_alloc(DIM, DIM);
gsl_matrix_set_identity(sigma_whole);
gsl_matrix* sigma_local[K];
for(int k=0; k<K; k++) {
sigma_local[k] = gsl_matrix_alloc(DIM, DIM);
gsl_matrix_set_identity(sigma_local[k]);
}
double means[K];
double variances[K];
double nk[K];
for(int k=0; k<K; k++) {
means[k] = 0.0;
variances[k] = 0.0;
nk[k] = 0.0;
}
double mean = 0.0;
double variance = 0.0;
mcmclib_amh* s = mcmclib_rapt_alloc(rng,
dunif, NULL, /*target distrib.*/
x, T0,
sigma_whole, K, sigma_local,
which_region, NULL, NULL);
rapt_suff* suff = (rapt_suff*) s->suff;
/*Main MCMC loop*/
gsl_matrix* X = gsl_matrix_alloc(N, DIM);
gsl_vector* which_region_n = gsl_vector_alloc(N);
for(size_t n=0; n<N; n++) {
mcmclib_amh_update(s);
gsl_vector_view Xn = gsl_matrix_row(X, n);
gsl_vector_memcpy(&(Xn.vector), x);
gsl_vector_set(which_region_n, n, (double) which_region(NULL, x));
means[which_region(NULL, x)] += x0;
variances[which_region(NULL, x)] += x0 * x0;
nk[which_region(NULL, x)] += 1.0;
mean += x0;
variance += x0 * x0;
}
/*compute means and variances*/
mean /= (double) N;
variance = variance / ((double) N) - (mean * mean);
for(size_t k=0; k<K; k++) {
means[k] /= nk[k];
variances[k] = (variances[k] / nk[k]) - (means[k] * means[k]);
}
/*check results*/
CuAssertDblEquals(tc, mean, v0(suff->global_mean), TOL);
CuAssertDblEquals(tc, variance, m00(suff->global_variance), TOL);
static char kmsg[3];
for(size_t k=0; k<K; k++) {
sprintf(kmsg, "%zd", k);
CuAssertDblEquals_Msg(tc, kmsg, nk[k], gsl_vector_get(suff->n, k), TOL);
CuAssertDblEquals_Msg(tc, kmsg, means[k], v0(suff->means[k]), TOL);
CuAssertDblEquals_Msg(tc, kmsg, variances[k], m00(suff->variances[k]), TOL);
}
/*free memory*/
gsl_matrix_free(X);
for(int k=0; k<K; k++)
gsl_matrix_free(sigma_local[k]);
gsl_matrix_free(sigma_whole);
gsl_vector_free(x);
mcmclib_amh_free(s);
gsl_rng_free(rng);
gsl_vector_free(which_region_n);
}
void hSDM_Nmixture (
// Constants and data
const int *ngibbs, int *nthin, int *nburn, // Number of iterations, burning and samples
const int *nobs, int *nsite, // Number of observations and sites
const int *np, // Number of fixed effects for lambda
const int *nq, // Number of fixed effects for delta
const int *Y_vect, // Number of successes (presences)
const double *W_vect, // Observability covariates (nobs x nq)
const double *X_vect, // Suitability covariates (nsite x np)
// Spatial sites
const int *S_vect, // Site Id
// Predictions
const int *npred, // Number of predictions
const double *X_pred_vect, // Suitability covariates for predictions
// Starting values for M-H
const double *beta_start,
const double *gamma_start,
const int *N_start,
// Parameters
double *beta_vect,
double *gamma_vect,
int *N_pred,
// Defining priors
const double *mubeta, double *Vbeta,
const double *mugamma, double *Vgamma,
// Diagnostic
double *Deviance,
double *lambda_latent, // Latent proba of suitability (length NSITE)
double *delta_latent, // Latent proba of observability (length NOBS)
double *lambda_pred, // Proba of suitability for predictions (length NPRED)
// Seeds
const int *seed,
// Verbose
const int *verbose,
// Save p and N
const int *save_p,
const int *save_N
) {
////////////////////////////////////////////////////////////////////////////////
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Defining and initializing objects
////////////////////////////////////////
// Initialize random number generator //
gsl_rng *r=gsl_rng_alloc(gsl_rng_mt19937);
gsl_rng_set(r,seed[0]);
///////////////////////////
// Redefining constants //
const int NGIBBS=ngibbs[0];
const int NTHIN=nthin[0];
const int NBURN=nburn[0];
const int NSAMP=(NGIBBS-NBURN)/NTHIN;
const int NOBS=nobs[0];
const int NSITE=nsite[0];
const int NP=np[0];
const int NQ=nq[0];
const int NPRED=npred[0];
///////////////////////////////////
// Declaring some useful objects //
double *lambda_run=malloc(NSITE*sizeof(double));
for (int i=0; i<NSITE; i++) {
lambda_run[i]=0.0;
}
double *delta_run=malloc(NOBS*sizeof(double));
for (int n=0; n<NOBS; n++) {
delta_run[n]=0.0;
}
double *lambda_pred_run=malloc(NPRED*sizeof(double));
for (int m=0; m<NPRED; m++) {
lambda_pred_run[m]=0.0;
}
double *N_pred_double=malloc(NSITE*sizeof(double));
for (int i=0; i<NSITE; i++) {
N_pred_double[i]=0.0;
}
//////////////////////////////////////////////////////////
// Set up and initialize structure for density function //
struct dens_par dens_data;
/* Data */
dens_data.NOBS=NOBS;
dens_data.NSITE=NSITE;
// Y
dens_data.Y=malloc(NOBS*sizeof(int));
for (int n=0; n<NOBS; n++) {
dens_data.Y[n]=Y_vect[n];
}
/* Latent variable */
// N_run
dens_data.N_run=malloc(NSITE*sizeof(int));
for (int i=0; i<NSITE; i++) {
dens_data.N_run[i]=N_start[i];
}
dens_data.pos_N=0;
/* Sites */
// IdSite
dens_data.IdSite=malloc(NOBS*sizeof(int));
for (int n=0; n<NOBS; n++) {
dens_data.IdSite[n]=S_vect[n];
}
// nObsSite
dens_data.nObsSite=malloc(NSITE*sizeof(int));
for (int i=0; i<NSITE; i++) {
dens_data.nObsSite[i]=0;
for (int n=0; n<NOBS; n++) {
if (dens_data.IdSite[n]==i) {
dens_data.nObsSite[i]++;
}
}
}
// PosSite
dens_data.PosSite=malloc(NSITE*sizeof(int*));
for (int i=0; i<NSITE; i++) {
dens_data.PosSite[i]=malloc(dens_data.nObsSite[i]*sizeof(int));
int repSite=0;
for (int n=0; n<NOBS; n++) {
if (dens_data.IdSite[n]==i) {
dens_data.PosSite[i][repSite]=n;
repSite++;
}
}
}
/* Suitability process */
dens_data.NP=NP;
dens_data.pos_beta=0;
dens_data.X=malloc(NSITE*sizeof(double*));
for (int i=0; i<NSITE; i++) {
dens_data.X[i]=malloc(NP*sizeof(double));
for (int p=0; p<NP; p++) {
dens_data.X[i][p]=X_vect[p*NSITE+i];
}
}
dens_data.mubeta=malloc(NP*sizeof(double));
dens_data.Vbeta=malloc(NP*sizeof(double));
for (int p=0; p<NP; p++) {
dens_data.mubeta[p]=mubeta[p];
dens_data.Vbeta[p]=Vbeta[p];
}
dens_data.beta_run=malloc(NP*sizeof(double));
for (int p=0; p<NP; p++) {
dens_data.beta_run[p]=beta_start[p];
}
/* Observability process */
dens_data.NQ=NQ;
dens_data.pos_gamma=0;
dens_data.W=malloc(NOBS*sizeof(double*));
for (int n=0; n<NOBS; n++) {
dens_data.W[n]=malloc(NQ*sizeof(double));
for (int q=0; q<NQ; q++) {
dens_data.W[n][q]=W_vect[q*NOBS+n];
}
}
dens_data.mugamma=malloc(NQ*sizeof(double));
dens_data.Vgamma=malloc(NQ*sizeof(double));
for (int q=0; q<NQ; q++) {
dens_data.mugamma[q]=mugamma[q];
dens_data.Vgamma[q]=Vgamma[q];
}
dens_data.gamma_run=malloc(NQ*sizeof(double));
for (int q=0; q<NQ; q++) {
dens_data.gamma_run[q]=gamma_start[q];
}
/* Predictions */
// X_pred
double **X_pred=malloc(NPRED*sizeof(double*));
for (int m=0; m<NPRED; m++) {
X_pred[m]=malloc(NP*sizeof(double));
for (int p=0; p<NP; p++) {
X_pred[m][p]=X_pred_vect[p*NPRED+m];
}
}
////////////////////////////////////////////////////////////
// Proposal variance and acceptance for adaptive sampling //
// beta
double *sigmap_beta = malloc(NP*sizeof(double));
int *nA_beta = malloc(NP*sizeof(int));
double *Ar_beta = malloc(NP*sizeof(double)); // Acceptance rate
for (int p=0; p<NP; p++) {
nA_beta[p]=0;
sigmap_beta[p]=1.0;
Ar_beta[p]=0.0;
}
// gamma
double *sigmap_gamma = malloc(NQ*sizeof(double));
int *nA_gamma = malloc(NQ*sizeof(int));
double *Ar_gamma = malloc(NQ*sizeof(double)); // Acceptance rate
for (int q=0; q<NQ; q++) {
nA_gamma[q]=0;
sigmap_gamma[q]=1.0;
Ar_gamma[q]=0.0;
}
// N
int *nA_N = malloc(NSITE*sizeof(int));
double *Ar_N = malloc(NSITE*sizeof(double)); // Acceptance rate
for (int i=0; i<NSITE; i++) {
nA_N[i]=0;
Ar_N[i]=0.0;
}
////////////
// Message//
Rprintf("\nRunning the Gibbs sampler. It may be long, please keep cool :)\n\n");
R_FlushConsole();
//R_ProcessEvents(); for windows
///////////////////////////////////////////////////////////////////////////////////////
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Gibbs sampler
for (int g=0; g<NGIBBS; g++) {
////////////////////////////////////////////////
// beta
for (int p=0; p<NP; p++) {
dens_data.pos_beta=p; // Specifying the rank of the parameter of interest
double x_now=dens_data.beta_run[p];
double x_prop=x_now+gsl_ran_gaussian_ziggurat(r, sigmap_beta[p]);
double p_now=betadens(x_now, &dens_data);
double p_prop=betadens(x_prop, &dens_data);
double ratio=exp(p_prop-p_now); // ratio
double z=gsl_rng_uniform(r);
// Actualization
if (z < ratio) {
dens_data.beta_run[p]=x_prop;
nA_beta[p]++;
}
}
////////////////////////////////////////////////
// gamma
for (int q=0; q<NQ; q++) {
dens_data.pos_gamma=q; // Specifying the rank of the parameter of interest
double x_now=dens_data.gamma_run[q];
double x_prop=x_now+gsl_ran_gaussian_ziggurat(r, sigmap_gamma[q]);
double p_now=gammadens(x_now, &dens_data);
double p_prop=gammadens(x_prop, &dens_data);
double ratio=exp(p_prop-p_now); // ratio
double z=gsl_rng_uniform(r);
// Actualization
if (z < ratio) {
dens_data.gamma_run[q]=x_prop;
nA_gamma[q]++;
}
}
////////////////////////////////////////////////
// N
for (int i=0; i<NSITE; i++) {
dens_data.pos_N=i; // Specifying the rank of the parameter of interest
int x_now=dens_data.N_run[i];
if (x_now==0) {
double s=gsl_rng_uniform(r);
if (s < 0.5) {
//dens_data.N_run[i]=x_now;
dens_data.N_run[i]=0;
}
else {
// Proposal
//int x_prop=x_now+1;
int x_prop=1;
// Ratio
double p_now=Ndens(x_now, &dens_data);
double p_prop=Ndens(x_prop, &dens_data);
double ratio=exp(p_prop-p_now);
// Actualization
double z=gsl_rng_uniform(r);
if (z < ratio) {
dens_data.N_run[i]=x_prop;
nA_N[i]++;
}
}
}
else {
// Proposal
double s=gsl_rng_uniform(r);
int x_prop=0;
if (s < 0.5) x_prop=x_now-1;
else x_prop=x_now+1;
// Ratio
double p_now=Ndens(x_now, &dens_data);
double p_prop=Ndens(x_prop, &dens_data);
double ratio=exp(p_prop-p_now);
// Actualization
double z=gsl_rng_uniform(r);
if (z < ratio) {
dens_data.N_run[i]=x_prop;
nA_N[i]++;
}
}
}
//////////////////////////////////////////////////
// Deviance
// logLikelihood
double logL1=0.0;
for (int n=0; n<NOBS; n++) {
/* delta */
double logit_delta=0.0;
for (int q=0; q<NQ; q++) {
logit_delta+=dens_data.W[n][q]*dens_data.gamma_run[q];
}
delta_run[n]=invlogit(logit_delta);
/* log Likelihood */
logL1+=dbinom(dens_data.Y[n],dens_data.N_run[dens_data.IdSite[n]],delta_run[n],1);
}
double logL2=0.0;
for (int i=0; i<NSITE; i++) {
/* lambda */
double Xpart_lambda=0.0;
for (int p=0; p<NP; p++) {
Xpart_lambda+=dens_data.X[i][p]*dens_data.beta_run[p];
}
lambda_run[i]=exp(Xpart_lambda);
logL2+=dpois(dens_data.N_run[i],lambda_run[i],1);
}
double logL=logL1+logL2;
// Deviance
double Deviance_run=-2*logL;
//////////////////////////////////////////////////
// Predictions
for (int m=0; m<NPRED; m++) {
/* lambda_pred_run */
double Xpart_lambda_pred=0.0;
for (int p=0; p<NP; p++) {
Xpart_lambda_pred+=X_pred[m][p]*dens_data.beta_run[p];
}
lambda_pred_run[m]=exp(Xpart_lambda_pred);
}
//////////////////////////////////////////////////
// Output
if (((g+1)>NBURN) && (((g+1)%(NTHIN))==0)) {
int isamp=((g+1)-NBURN)/(NTHIN);
// beta
for (int p=0; p<NP; p++) {
beta_vect[p*NSAMP+(isamp-1)]=dens_data.beta_run[p];
}
// gamma
for (int q=0; q<NQ; q++) {
gamma_vect[q*NSAMP+(isamp-1)]=dens_data.gamma_run[q];
}
// Deviance
Deviance[isamp-1]=Deviance_run;
for (int i=0; i<NSITE; i++) {
lambda_latent[i]+=lambda_run[i]/NSAMP; // We compute the mean of NSAMP values
}
for (int n=0; n<NOBS; n++) {
delta_latent[n]+=delta_run[n]/NSAMP; // We compute the mean of NSAMP values
}
// lambda
if (save_p[0]==0) { // We compute the mean of NSAMP values
for (int m=0; m<NPRED; m++) {
lambda_pred[m]+=lambda_pred_run[m]/NSAMP;
}
}
if (save_p[0]==1) { // The NSAMP sampled values for lambda are saved
for (int m=0; m<NPRED; m++) {
lambda_pred[m*NSAMP+(isamp-1)]=lambda_pred_run[m];
}
}
// N
if (save_N[0]==0) { // We compute the mean of NSAMP values
for (int i=0; i<NSITE; i++) {
N_pred_double[i]+= ((double) dens_data.N_run[i])/NSAMP;
}
}
if (save_N[0]==1) { // The NSAMP sampled values for lambda are saved
for (int i=0; i<NSITE; i++) {
N_pred[i*NSAMP+(isamp-1)]=dens_data.N_run[i];
}
}
}
///////////////////////////////////////////////////////
// Adaptive sampling (on the burnin period)
const double ropt=0.234;
int DIV=0;
if (NGIBBS >=1000) DIV=100;
else DIV=NGIBBS/10;
/* During the burnin period */
if ((g+1)%DIV==0 && (g+1)<=NBURN) {
// beta
for (int p=0; p<NP; p++) {
Ar_beta[p]=((double) nA_beta[p])/DIV;
if(Ar_beta[p]>=ropt) sigmap_beta[p]=sigmap_beta[p]*(2-(1-Ar_beta[p])/(1-ropt));
else sigmap_beta[p]=sigmap_beta[p]/(2-Ar_beta[p]/ropt);
nA_beta[p]=0.0; // We reinitialize the number of acceptance to zero
}
// gamma
for (int q=0; q<NQ; q++) {
Ar_gamma[q]=((double) nA_gamma[q])/DIV;
if(Ar_gamma[q]>=ropt) sigmap_gamma[q]=sigmap_gamma[q]*(2-(1-Ar_gamma[q])/(1-ropt));
else sigmap_gamma[q]=sigmap_gamma[q]/(2-Ar_gamma[q]/ropt);
nA_gamma[q]=0.0; // We reinitialize the number of acceptance to zero
}
// N
for (int i=0; i<NSITE; i++) {
Ar_N[i]=((double) nA_N[i])/DIV;
nA_N[i]=0.0; // We reinitialize the number of acceptance to zero
}
}
/* After the burnin period */
if ((g+1)%DIV==0 && (g+1)>NBURN) {
// beta
for (int p=0; p<NP; p++) {
Ar_beta[p]=((double) nA_beta[p])/DIV;
nA_beta[p]=0.0; // We reinitialize the number of acceptance to zero
}
// gamma
for (int q=0; q<NQ; q++) {
Ar_gamma[q]=((double) nA_gamma[q])/DIV;
nA_gamma[q]=0.0; // We reinitialize the number of acceptance to zero
}
// N
for (int i=0; i<NSITE; i++) {
Ar_N[i]=((double) nA_N[i])/DIV;
nA_N[i]=0.0; // We reinitialize the number of acceptance to zero
}
}
//////////////////////////////////////////////////
// Progress bar
double Perc=100*(g+1)/(NGIBBS);
if (((g+1)%(NGIBBS/100))==0 && verbose[0]==1) {
Rprintf("*");
R_FlushConsole();
//R_ProcessEvents(); for windows
if (((g+1)%(NGIBBS/10))==0) {
double mAr_beta=0; // Mean acceptance rate
double mAr_gamma=0;
double mAr_N=0;
// beta
for (int p=0; p<NP; p++) {
mAr_beta+=Ar_beta[p]/NP;
}
// gamma
for (int q=0; q<NQ; q++) {
mAr_gamma+=Ar_gamma[q]/NQ;
}
// N
for (int i=0; i<NSITE; i++) {
mAr_N+=Ar_N[i]/NSITE;
}
Rprintf(":%.1f%%, mean accept. rates= beta:%.3f, gamma:%.3f, N:%.3f\n",Perc,mAr_beta,mAr_gamma,mAr_N);
R_FlushConsole();
//R_ProcessEvents(); for windows
}
}
//////////////////////////////////////////////////
// User interrupt
R_CheckUserInterrupt(); // allow user interrupt
} // Gibbs sampler
//////////////////////////
// Rounding N_pred if save.N==0
if (save_N[0]==0) {
for (int i=0; i<NSITE; i++) {
N_pred[i]= (int)(N_pred_double[i] < 0 ? (N_pred_double[i]-0.5):(N_pred_double[i]+0.5));
}
}
///////////////
// Delete memory allocation (see malloc())
/* Data */
free(dens_data.Y);
free(dens_data.N_run);
free(N_pred_double);
free(dens_data.IdSite);
free(dens_data.nObsSite);
for (int i=0; i<NSITE; i++) {
free(dens_data.PosSite[i]);
}
free(dens_data.PosSite);
/* Suitability */
for (int i=0; i<NSITE; i++) {
free(dens_data.X[i]);
}
free(dens_data.X);
free(dens_data.mubeta);
free(dens_data.Vbeta);
free(dens_data.beta_run);
free(lambda_run);
/* Observability */
for (int n=0; n<NOBS; n++) {
free(dens_data.W[n]);
}
free(dens_data.W);
free(dens_data.mugamma);
free(dens_data.Vgamma);
free(dens_data.gamma_run);
free(delta_run);
/* Predictions */
for (int m=0; m<NPRED; m++) {
free(X_pred[m]);
}
free(X_pred);
free(lambda_pred_run);
/* Adaptive MH */
free(sigmap_beta);
free(nA_beta);
free(Ar_beta);
free(sigmap_gamma);
free(nA_gamma);
free(Ar_gamma);
free(nA_N);
free(Ar_N);
/* Random seed */
gsl_rng_free(r);
} // end hSDM function
gsl_vector* least_square_nl_fit(struct data dat, struct parameters par, gsl_multifit_function_fdf f)
{
size_t n, p;
int status, i, iter = 0;
double *x_init;
const gsl_rng_type * type;
const gsl_multifit_fdfsolver_type *T;
gsl_multifit_fdfsolver *s;
n = dat.n;
p = par.n;
gsl_matrix *covar = gsl_matrix_alloc(p,p);
x_init = (double *) calloc(par.n, sizeof(double));
for(i=0; i<par.n; i++)
x_init[i] = par.guess_p[i];
gsl_vector_view x = gsl_vector_view_array (x_init, p);
gsl_rng * r;
gsl_rng_env_setup();
type = gsl_rng_default;
r = gsl_rng_alloc (type);
T = gsl_multifit_fdfsolver_lmsder;
s = gsl_multifit_fdfsolver_alloc(T, n, p);
gsl_multifit_fdfsolver_set(s, &f, &x.vector);
#ifdef PRINT_INFO
print_state (iter, s);
#endif
do
{
iter++;
status = gsl_multifit_fdfsolver_iterate (s);
#ifdef PRINT_INFO
print_state (iter, s);
#endif
if (status)
break;
status = gsl_multifit_test_delta (s->dx, s->x,
1e-6, 1e-6);
}
while (status == GSL_CONTINUE && iter < 500);
#ifdef PRINT_INFO
print_state (iter, s);
#endif
gsl_multifit_covar (s->J, 0.0, covar);
{
gsl_matrix_free (covar);
gsl_rng_free (r);
}
return s->x;
gsl_multifit_fdfsolver_free (s);
}
int
main(int argc, char **argv)
{
long seed;
char *netF;
int method;
FILE *inFile;
struct node_gra *net = NULL;
gsl_rng *rand_gen;
int S, L;
int nsteps;
double step, damp;
/*
---------------------------------------------------------------------------
Command line parameters
---------------------------------------------------------------------------
*/
if (argc < 7) {
printf("\nUse: netlayout.out net_file_name seed step(-1) nsteps damping(-1) 1(2d)/2(2dp)/3(3d)\n\n");
return -1;
}
netF = argv[1];
seed = atoi(argv[2]);
step = atof(argv[3]);
if (step < 0.0 )
step = 0.05; // Default step
nsteps = atoi(argv[4]);
damp = atof(argv[5]);
if (damp < 0.0 )
damp = 0.05; // Default damping
method = atoi(argv[6]);
/*
---------------------------------------------------------------------------
Initialize the random number generator
---------------------------------------------------------------------------
*/
rand_gen = gsl_rng_alloc(gsl_rng_mt19937);
gsl_rng_set(rand_gen, seed);
/*
---------------------------------------------------------------------------
Build the network
---------------------------------------------------------------------------
*/
inFile=fopen(netF, "r");
net = FBuildNetwork(inFile, 0, 0, 0, 1);
fclose(inFile);
S = CountNodes(net);
L = TotalNLinks(net, 1);
/*
---------------------------------------------------------------------------
Layout the graph
---------------------------------------------------------------------------
*/
if (method == 3) {
MDGraphLayout3D(net, damp, step, nsteps, rand_gen, 0);
}
else if (method == 2) {
MDGraphLayout2Dp(net, damp, step, nsteps, rand_gen, 0);
}
else {
MDGraphLayout(net, damp, step, nsteps, rand_gen, 0);
}
/*
---------------------------------------------------------------------------
Output coordinates
---------------------------------------------------------------------------
*/
PrintNodeCoordinates(stdout, net);
/*
---------------------------------------------------------------------------
Free memory
---------------------------------------------------------------------------
*/
RemoveGraph(net);
gsl_rng_free(rand_gen);
return 0;
}
void poisson_distrib_destroy(poisson_distrib *p) {
gsl_rng_free(p->r);
free(p);
}
/**
* @brief Main principal
* @param argc El número de argumentos del programa
* @param argv Cadenas de argumentos del programa
* @return Nada si es correcto o algún número negativo si es incorrecto
*/
int main( int argc, char** argv ) {
if( argc < 4 )
return -1;
// Declaración de variables
gsl_rng *rng;
IplImage *frame, *hsv_frame;
histogram **ref_histos, *histo_aux;
CvCapture *video;
particle **particles, **aux, **nuevas_particulas;
CvScalar color_rojo = CV_RGB(255,0,0), color_azul = CV_RGB(0,0,255);
CvRect *regions;
int num_objects = 0;
int i = 1, MAX_OBJECTS = atoi(argv[3]), PARTICLES = atoi(argv[2]);
FILE *datos;
char name[45], num[3], *p1, *p2;
clock_t t_ini, t_fin;
double ms;
video = cvCaptureFromFile( argv[1] );
if( !video ) {
printf("No se pudo abrir el fichero de video %s\n", argv[1]);
exit(-1);
}
first_frame = cvQueryFrame( video );
num_objects = get_regions( ®ions, MAX_OBJECTS, argv[1] );
if( num_objects == 0 )
exit(-1);
t_ini = clock();
hsv_frame = bgr2hsv( first_frame );
histo_aux = (histogram*) malloc( sizeof(histogram) );
histo_aux->n = NH*NS + NV;
nuevas_particulas = (particle**) malloc( num_objects * sizeof( particle* ) );
for( int j = 0; j < num_objects; ++j )
nuevas_particulas[j] = (particle*) malloc( PARTICLES * sizeof( particle ) );
// Computamos los histogramas de referencia y distribuimos las partículas iniciales
ref_histos = compute_ref_histos( hsv_frame, regions, num_objects );
particles = init_distribution( regions, num_objects, PARTICLES );
// Mostramos el tracking
if( show_tracking ) {
// Mostramos todas las partículas
if( show_all )
for( int k = 0; k < num_objects; ++k )
for( int j = 0; j < PARTICLES; ++j )
display_particle( first_frame, particles[k][j], color_azul );
// Dibujamos la partícula más prometedora de cada objeto
for( int k = 0; k < num_objects; ++k )
display_particle( first_frame, particles[k][0], color_rojo );
cvNamedWindow( "Video", 1 );
cvShowImage( "Video", first_frame );
cvWaitKey( 5 );
}
// Exportamos los histogramas de referencia y los frames
if( exportar ) {
export_ref_histos( ref_histos, num_objects );
export_frame( first_frame, 1 );
for( int k = 0; k < num_objects; ++k ) {
sprintf( num, "%02d", k );
strcpy( name, REGION_BASE);
p1 = strrchr( argv[1], '/' );
p2 = strrchr( argv[1], '.' );
strncat( name, (++p1), p2-p1 );
strcat( name, num );
strcat( name, ".txt" );
datos = fopen( name, "a+" );
if( ! datos ) {
printf("Error creando fichero para datos\n");
return -1;
}
fprintf( datos, "%d\t%f\t%f\n", 0, particles[k][0].x, particles[k][0].y );
fclose( datos );
}
}
cvReleaseImage( &hsv_frame );
// Inicializamos el generador de números aleatorios
gsl_rng_env_setup();
rng = gsl_rng_alloc( gsl_rng_mt19937 );
gsl_rng_set(rng, (unsigned long) time(NULL));
// Recordar que frame no se puede liberar debido al cvQueryFrame
while( frame = cvQueryFrame( video ) ) {
hsv_frame = bgr2hsv( frame );
// Realizamos la predicción y medición de probabilidad para cada partícula
for( int k = 0; k < num_objects; ++k )
for( int j = 0; j < PARTICLES; ++j ) {
transition( &particles[k][j], frame->width, frame->height, rng );
particles[k][j].w = likelihood( hsv_frame, &particles[k][j], ref_histos[k], histo_aux );
}
// Normalizamos los pesos y remuestreamos un conjunto de partículas no ponderadas
normalize_weights( particles, num_objects, PARTICLES );
for (int k = 0; k < num_objects; ++k )
resample( particles[k], PARTICLES, nuevas_particulas[k] );
aux = particles;
particles = nuevas_particulas;
nuevas_particulas = aux;
// Mostramos el tracking
if( show_tracking ) {
// Mostramos todas las partículas
if( show_all )
for( int k = 0; k < num_objects; ++k )
for( int j = 0; j < PARTICLES; ++j )
display_particle( frame, particles[k][j], color_azul );
// Dibujamos la partícula más prometedora de cada objeto
for( int k = 0; k < num_objects; ++k )
display_particle( frame, particles[k][0], color_rojo );
cvNamedWindow( "Video", 1 );
cvShowImage( "Video", frame );
cvWaitKey( 5 );
}
// Exportamos los histogramas de referencia y los frames
if( exportar ) {
export_frame( frame, i+1 );
for( int k = 0; k < num_objects; ++k ) {
sprintf( num, "%02d", k );
strcpy( name, REGION_BASE);
p1 = strrchr( argv[1], '/' );
p2 = strrchr( argv[1], '.' );
strncat( name, (++p1), p2-p1 );
strcat( name, num );
strcat( name, ".txt" );
datos = fopen( name, "a+" );
if( ! datos ) {
printf("Error abriendo fichero para datos\n");
return -1;
}
fprintf( datos, "%d\t%f\t%f\n", i, particles[k][0].x, particles[k][0].y );
fclose( datos );
}
}
cvReleaseImage( &hsv_frame );
++i;
}
// Liberamos todos los recursos usados (mallocs, gsl y frames)
cvReleaseCapture( &video );
gsl_rng_free( rng );
free( histo_aux );
free( regions );
for( int i = 0; i < num_objects; ++i ) {
free( ref_histos[i] );
free( particles[i] );
free( nuevas_particulas[i] );
}
free( particles );
free( nuevas_particulas );
t_fin = clock();
ms = ((double)(t_fin - t_ini) / CLOCKS_PER_SEC) * 1000.0;
printf("%d\t%d\t%.10g\n", PARTICLES, num_objects, ms);
}
//if you want to simulate a true hom, pass in var with both alleles the same
void simulator(int depth, int read_len, int kmer, double seq_err_per_base,
int number_repetitions, int colour_indiv,
int colour_allele1, int colour_allele2, int colour_ref_minus_site,
VariantBranchesAndFlanks* var,
int len_genome_minus_site, zygosity true_gt,
GraphAndModelInfo* model_info,
char* fasta, char* true_ml_gt_name,
int working_colour1, int working_colour2,
boolean using_1and2_nets,
dBGraph* db_graph)
//dBNode** genome_minus_site
//boolean are_the_two_alleles_identical
//char* filelist_net1, char* filelist_net2
//int working_colour_1net, int working_colour_2net
{
if (NUMBER_OF_COLOURS<4)
{
die("Cannot run the simulator with <4 colours. Recompile.\n");
}
int count_passes = 0;
int count_fails = 0;
const gsl_rng_type * T;
gsl_rng * r;
// GLS setup:
/* create a generator chosen by the
environment variable GSL_RNG_TYPE */
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc (T);
//put the alleles and reference into their colours:
mark_allele_with_all_1s_or_more(var->one_allele, var->len_one_allele, colour_allele1);
mark_allele_with_all_1s_or_more(var->other_allele, var->len_other_allele, colour_allele2);
int i;
for (i=0; i<number_repetitions; i++)
{
zero_path_except_two_alleles_and_ref(var->one_allele, var->len_one_allele, colour_allele1, colour_allele2, colour_ref_minus_site);
zero_path_except_two_alleles_and_ref(var->other_allele, var->len_other_allele, colour_allele1, colour_allele2, colour_ref_minus_site);
//give the each allele depth which is taken from a Poisson with mean = (D/2) * (R-k+1)/R * (1-k*epsilon)
//printf("Depth %d, var->len one allele - k,er +1 = %d, and 1-kmer * seq_err = %f \n", depth, (var->len_one_allele)-kmer+1, 1-kmer*seq_err_per_base ) ;
double exp_depth_on_allele1 = 0;
if (true_gt==het)
//het. So 1/3 of seq errors on the other allele end up on this one
{
exp_depth_on_allele1 = ((double) depth/2) *
( (double)(read_len+(var->len_one_allele)-kmer+1)/read_len) * (1-kmer*seq_err_per_base);
// + ((double) depth/2) *
//( (double)(read_len+(var->len_other_allele)-kmer+1)/read_len) * (kmer*seq_err_per_base/3); //some errors from the other allele give covg here
}
else if (true_gt==hom_one)
{//hom
exp_depth_on_allele1 = ((double) depth) *
( (double)(read_len+(var->len_one_allele)-kmer+1)/read_len) * (1-kmer*seq_err_per_base);
}
else if (true_gt==hom_other)
{
exp_depth_on_allele1 = ((double) depth) *
( (double)(read_len+(var->len_other_allele)-kmer+1)/read_len) * kmer*seq_err_per_base/3;// 1/3 of the errors on the true allele are on this one
}
double exp_depth_on_allele2 = 0;
if (true_gt==het)
//het. So 1/3 of seq errors are not a problem. So loss of covg is (1-k*(2/3)*e)
{
exp_depth_on_allele2 = exp_depth_on_allele1;
}
else if (true_gt==hom_one)
{
exp_depth_on_allele2 = ( (double)(read_len+(var->len_one_allele)-kmer+1)/read_len) * kmer*seq_err_per_base/3;
}
else if (true_gt==hom_other)
{
exp_depth_on_allele2 = ((double) depth) *
( (double)(read_len+(var->len_other_allele)-kmer+1)/read_len) * (1-kmer*seq_err_per_base);
}
double exp_depth_on_ref_minus_site = (double) depth * ((double)(len_genome_minus_site-kmer+1)/read_len) * (1-kmer*seq_err_per_base);
//printf("exp ZAMMER %f %f %f\n", exp_depth_on_allele1, exp_depth_on_allele2, exp_depth_on_ref_minus_site);
unsigned int sampled_covg_allele1 = gsl_ran_poisson (r, exp_depth_on_allele1);
unsigned int sampled_covg_allele2 = gsl_ran_poisson (r, exp_depth_on_allele2);
unsigned int sampled_covg_rest_of_genome = gsl_ran_poisson (r, exp_depth_on_ref_minus_site);
printf("Sampled covgs on alleles 1,2 and genome are %d %d %d\n", sampled_covg_allele1, sampled_covg_allele2, sampled_covg_rest_of_genome);
update_allele(var->one_allele, var->len_one_allele,
colour_indiv, sampled_covg_allele1,read_len-kmer+1);
update_allele(var->other_allele, var->len_other_allele,
colour_indiv, sampled_covg_allele2, read_len-kmer+1);
//update_allele(genome_minus_site,len_genome_minus_site, colour_indiv, sampled_covg_rest_of_genome);
test(var, model_info, fasta, colour_ref_minus_site,
colour_indiv, using_1and2_nets,
working_colour1, working_colour2,
&count_passes, &count_fails, db_graph, true_ml_gt_name);
}
//cleanup
zero_allele(var->one_allele, var->len_one_allele, colour_indiv, colour_allele1, colour_allele2, colour_ref_minus_site);
zero_allele(var->other_allele, var->len_other_allele, colour_indiv, colour_allele1, colour_allele2, colour_ref_minus_site);
CU_ASSERT((double)count_passes/(double)(count_passes+count_fails) > 0.9 );//actually, we could set this to ==1
printf("Number of passes: %d, number of fails %d\n", count_passes, count_fails);
gsl_rng_free (r);
}
// Find a point in space with high density.
void TChain::find_center(double* const center, gsl_matrix *const cov, gsl_matrix *const inv_cov, double* det_cov, double dmax, unsigned int iterations) const {
// Check that the matrices are the correct size
/*assert(cov->size1 == N);
assert(cov->size2 == N);
assert(inv_cov->size1 == N);
assert(inv_cov->size2 == N);*/
// Choose random point in chain as starting point
gsl_rng *r;
seed_gsl_rng(&r);
long unsigned int index_tmp = gsl_rng_uniform_int(r, length);
const double *x_tmp = get_element(index_tmp);
for(unsigned int i=0; i<N; i++) { center[i] = x_tmp[i]; }
//std::cout << "center #0:";
//for(unsigned int n=0; n<N; n++) { std::cout << " " << center[n]; }
//std::cout << std::endl;
/*double *E_k = new double[N];
double *E_ij = new double[N*N];
for(unsigned int n1=0; n1<N; n1++) {
E_k[n1] = 0.;
for(unsigned int n2=0; n2<N; n2++) { E_ij[n1 + N*n2] = 0.; }
}*/
// Iterate
double *sum = new double[N];
double weight;
for(unsigned int i=0; i<iterations; i++) {
// Set mean of nearby points as center
weight = 0.;
for(unsigned int n=0; n<N; n++) { sum[n] = 0.; }
for(unsigned int k=0; k<length; k++) {
x_tmp = get_element(k);
if(metric_dist2(inv_cov, x_tmp, center, N) < dmax*dmax) {
for(unsigned int n=0; n<N; n++) { sum[n] += w[k] * x_tmp[n]; }
weight += w[k];
// Calculate the covariance
/*if(i == iterations - 1) {
for(unsigned int n1=0; n1<N; n1++) {
E_k[n1] += w[k] * x_tmp[n1];
for(unsigned int n2=0; n2<N; n2++) { E_ij[n1 + N*n2] += w[k] * x_tmp[n1] * x_tmp[n2]; }
}
}*/
}
}
//std::cout << "center #" << i+1 << ":";
for(unsigned int n=0; n<N; n++) { center[n] = sum[n] / (double)weight; }//std::cout << " " << center[n]; }
//std::cout << " (" << weight << ")" << std::endl;
dmax *= 0.9;
}
for(unsigned int n=0; n<N; n++) { std::cout << " " << center[n]; }
std::cout << std::endl;
// Calculate the covariance matrix of the enclosed points
/*double tmp;
for(unsigned int i=0; i<N; i++) {
for(unsigned int j=i; j<N; j++) {
tmp = (E_ij[i + N*j] - E_k[i]*E_k[j]/(double)weight) / (double)weight;
gsl_matrix_set(cov, i, j, tmp);
if(i != j) { gsl_matrix_set(cov, j, i, tmp); }
}
}*/
// Get the inverse of the covariance
/*int s;
gsl_permutation* p = gsl_permutation_alloc(N);
gsl_matrix* LU = gsl_matrix_alloc(N, N);
gsl_matrix_memcpy(LU, cov);
gsl_linalg_LU_decomp(LU, p, &s);
gsl_linalg_LU_invert(LU, p, inv_cov);
// Get the determinant of the covariance
*det_cov = gsl_linalg_LU_det(LU, s);
// Cleanup
gsl_matrix_free(LU);
gsl_permutation_free(p);
delete[] E_k;
delete[] E_ij;*/
gsl_rng_free(r);
delete[] sum;
}
/*
* Break yu12 image in little square pieces
* args:
* frame - pointer to frame buffer (yu12 format)
* width - frame width
* height - frame height
* piece_size - multiple of 2 (we need at least 2 pixels to get the entire pixel information)
*
* asserts:
* frame is not null
*/
static void fx_yu12_pieces(uint8_t* frame, int width, int height, int piece_size )
{
int numx = width / piece_size; //number of pieces in x axis
int numy = height / piece_size; //number of pieces in y axis
uint8_t piece[(piece_size * piece_size * 3) / 2];
uint8_t *ppiece = piece;
int i = 0, j = 0, w = 0, h = 0;
/*random generator setup*/
gsl_rng_env_setup();
const gsl_rng_type *T = gsl_rng_default;
gsl_rng *r = gsl_rng_alloc (T);
int rot = 0;
uint8_t *py = NULL;
uint8_t *pu = NULL;
uint8_t *pv = NULL;
for(h = 0; h < height; h += piece_size)
{
for(w = 0; w < width; w += piece_size)
{
uint8_t *ppy = piece;
uint8_t *ppu = piece + (piece_size * piece_size);
uint8_t *ppv = ppu + ((piece_size * piece_size) / 4);
for(i = 0; i < piece_size; ++i)
{
py = frame + ((h + i) * width) + w;
for (j=0; j < piece_size; ++j)
{
*ppy++ = *py++;
}
}
for(i = 0; i < piece_size; i += 2)
{
uint8_t *pu = frame + (width * height) + (((h + i) * width) / 4) + (w / 2);
uint8_t *pv = pu + ((width * height) / 4);
for(j = 0; j < piece_size; j += 2)
{
*ppu++ = *pu++;
*ppv++ = *pv++;
}
}
ppy = piece;
ppu = piece + (piece_size * piece_size);
ppv = ppu + ((piece_size * piece_size) / 4);
/*rotate piece and copy it to frame*/
//rotation is random
rot = (int) lround(8 * gsl_rng_uniform (r)); /*0 to 8*/
switch(rot)
{
case 0: // do nothing
break;
case 5:
case 1: //mirror
fx_yu12_mirror(piece, piece_size, piece_size);
break;
case 6:
case 2: //upturn
fx_yu12_upturn(piece, piece_size, piece_size);
break;
case 4:
case 3://mirror upturn
fx_yu12_upturn(piece, piece_size, piece_size);
fx_yu12_mirror(piece, piece_size, piece_size);
break;
default: //do nothing
break;
}
ppy = piece;
ppu = piece + (piece_size * piece_size);
ppv = ppu + ((piece_size * piece_size) / 4);
for(i = 0; i < piece_size; ++i)
{
py = frame + ((h + i) * width) + w;
for (j=0; j < piece_size; ++j)
{
*py++ = *ppy++;
}
}
for(i = 0; i < piece_size; i += 2)
{
uint8_t *pu = frame + (width * height) + (((h + i) * width) / 4) + (w / 2);
uint8_t *pv = pu + ((width * height) / 4);
for(j = 0; j < piece_size; j += 2)
{
*pu++ = *ppu++;
*pv++ = *ppv++;
}
}
}
}
/*free the random seed generator*/
gsl_rng_free (r);
}
/*
* Trail of particles obtained from the image frame
* args:
* frame - pointer to frame buffer (yuyv format)
* width - frame width
* height - frame height
* trail_size - trail size (in frames)
* particle_size - maximum size in pixels - should be even (square - size x size)
*
* asserts:
* frame is not null
*
* returns: void
*/
static void fx_particles(uint8_t* frame, int width, int height, int trail_size, int particle_size)
{
/*asserts*/
assert(frame != NULL);
int i,j,w,h = 0;
int part_w = width>>7;
int part_h = height>>6;
/*random generator setup*/
gsl_rng_env_setup();
const gsl_rng_type *T = gsl_rng_default;
gsl_rng *r = gsl_rng_alloc (T);
/*allocation*/
if (particles == NULL)
{
particles = calloc(trail_size * part_w * part_h, sizeof(particle_t));
if(particles == NULL)
{
fprintf(stderr,"RENDER: FATAL memory allocation failure (fx_particles): %s\n", strerror(errno));
exit(-1);
}
}
particle_t *part = particles;
particle_t *part1 = part;
/*move particles in trail*/
for (i = trail_size; i > 1; --i)
{
part += (i - 1) * part_w * part_h;
part1 += (i - 2) * part_w * part_h;
for (j= 0; j < part_w * part_h; ++j)
{
if(part1->decay > 0)
{
part->PX = part1->PX + (int) lround(3 * gsl_rng_uniform (r)); /*0 to 3*/
part->PY = part1->PY -4 + (int) lround(5 * gsl_rng_uniform (r));/*-4 to 1*/
if(ODD(part->PX)) part->PX++; /*make sure PX is allways even*/
if((part->PX > (width-particle_size)) || (part->PY > (height-particle_size)) || (part->PX < 0) || (part->PY < 0))
{
part->PX = 0;
part->PY = 0;
part->decay = 0;
}
else
{
part->decay = part1->decay - 1;
}
part->Y = part1->Y;
part->U = part1->U;
part->V = part1->V;
part->size = part1->size;
}
else
{
part->decay = 0;
}
part++;
part1++;
}
part = particles; /*reset*/
part1 = part;
}
part = particles; /*reset*/
/*get particles from frame (one pixel per particle - make PX allways even)*/
for(i =0; i < part_w * part_h; i++)
{
/* (2 * particle_size) to (width - 4 * particle_size)*/
part->PX = 2 * particle_size + (int) lround( (width - 6 * particle_size) * gsl_rng_uniform (r));
/* (2 * particle_size) to (height - 4 * particle_size)*/
part->PY = 2 * particle_size + (int) lround( (height - 6 * particle_size) * gsl_rng_uniform (r));
if(ODD(part->PX)) part->PX++;
int y_pos = part->PX + (part->PY * width);
int u_pos = (part->PX + (part->PY * width / 2)) / 2;
int v_pos = u_pos + ((width * height) / 4);
part->Y = frame[y_pos];
part->U = frame[u_pos];
part->V = frame[v_pos];
part->size = 1 + (int) lround((particle_size -1) * gsl_rng_uniform (r));
if(ODD(part->size)) part->size++;
part->decay = (float) trail_size;
part++; /*next particle*/
}
part = particles; /*reset*/
int line = 0;
float blend =0;
float blend1 =0;
/*render particles to frame (expand pixel to particle size)*/
for (i = 0; i < trail_size * part_w * part_h; i++)
{
if(part->decay > 0)
{
int y_pos = part->PX + (part->PY * width);
int u_pos = (part->PX + (part->PY * width / 2)) / 2;
int v_pos = u_pos + ((width * height) / 4);
blend = part->decay/trail_size;
blend1= 1 - blend;
//y
for(h = 0; h <(part->size); h++)
{
line = h * width;
for (w = 0; w <(part->size); w++)
{
frame[y_pos + line + w] = CLIP((part->Y * blend) + (frame[y_pos + line + w] * blend1));
}
}
//u v
for(h = 0; h <(part->size); h+=2)
{
line = (h * width) / 4;
for (w = 0; w <(part->size); w+=2)
{
frame[u_pos + line + (w / 2)] = CLIP((part->U * blend) + (frame[u_pos + line + (w / 2)] * blend1));
frame[v_pos + line + (w / 2)] = CLIP((part->V * blend) + (frame[v_pos + line + (w / 2)] * blend1));
}
}
}
part++;
}
/*free the random seed generator*/
gsl_rng_free (r);
}
/*
* Break yuyv image in little square pieces
* args:
* frame - pointer to frame buffer (yuyv format)
* width - frame width
* height - frame height
* piece_size - multiple of 2 (we need at least 2 pixels to get the entire pixel information)
*
* asserts:
* frame is not null
*/
static void fx_yuyv_pieces(uint8_t* frame, int width, int height, int piece_size )
{
int numx = width / piece_size; //number of pieces in x axis
int numy = height / piece_size; //number of pieces in y axis
uint8_t *piece = calloc (piece_size * piece_size * 2, sizeof(uint8_t));
if(piece == NULL)
{
fprintf(stderr,"RENDER: FATAL memory allocation failure (fx_pieces): %s\n", strerror(errno));
exit(-1);
}
int i = 0, j = 0, line = 0, column = 0, linep = 0, px = 0, py = 0;
/*random generator setup*/
gsl_rng_env_setup();
const gsl_rng_type *T = gsl_rng_default;
gsl_rng *r = gsl_rng_alloc (T);
int rot = 0;
for(j = 0; j < numy; j++)
{
int row = j * piece_size;
for(i = 0; i < numx; i++)
{
column = i * piece_size * 2;
//get piece
for(py = 0; py < piece_size; py++)
{
linep = py * piece_size * 2;
line = (py + row) * width * 2;
for(px=0 ; px < piece_size * 2; px++)
{
piece[px + linep] = frame[(px + column) + line];
}
}
/*rotate piece and copy it to frame*/
//rotation is random
rot = (int) lround(8 * gsl_rng_uniform (r)); /*0 to 8*/
switch(rot)
{
case 0: // do nothing
break;
case 5:
case 1: //mirror
fx_yuyv_mirror(piece, piece_size, piece_size);
break;
case 6:
case 2: //upturn
fx_yuyv_upturn(piece, piece_size, piece_size);
break;
case 4:
case 3://mirror upturn
fx_yuyv_upturn(piece, piece_size, piece_size);
fx_yuyv_mirror(piece, piece_size, piece_size);
break;
default: //do nothing
break;
}
//write piece
for(py = 0; py < piece_size; py++)
{
linep = py * piece_size * 2;
line = (py + row) * width * 2;
for(px=0 ; px < piece_size * 2; px++)
{
frame[(px + column) + line] = piece[px + linep];
}
}
}
}
/*free the random seed generator*/
gsl_rng_free (r);
/*free the piece buffer*/
free(piece);
}
/*This is the main function of the integration program that calls the gsl Runge-Kutta integrator:*/
void integrator(function F, int D, void *params, double x[], double dxdt[], double x0[], double t[], int iters, double s_noise, double abstol, double reltol) {
/*Temporary variables*/
double *y = (double*) malloc( sizeof(double)*D ); /*state variable at time t-1 (input) and then at time t(output)*/
double *dydt_in = (double*) malloc( sizeof(double)*D ); /*rate of change at time point t-1*/
double *dydt_out= (double*) malloc( sizeof(double)*D ); /*rate of change at time point t*/
double *yerr = (double*) malloc( sizeof(double)*D );/*error*/
double t0,tf,tc,dt=(t[1]-t[0])/2,noise;/*initial time point, final time point, current time point, current time step, noise*/
int j,ii;/*State variable and iteration indexes*/
int status;/*integrator success flag*/
/*Definitions and initializations of gsl integrator necessary inputs and parameters:*/
/*Prepare noise generator*/
const gsl_rng_type *Q;
gsl_rng *r;
gsl_rng_env_setup();
Q = gsl_rng_default;
r = gsl_rng_alloc(Q);
/*Create a stepping function*/
const gsl_odeiv_step_type *T = gsl_odeiv_step_rkf45;
gsl_odeiv_step *s = gsl_odeiv_step_alloc(T, D);
/*Create an adaptive control function*/
gsl_odeiv_control *c = gsl_odeiv_control_y_new(abstol, reltol);
/*Create the system to be integrated (with NULL jacobian)*/
gsl_odeiv_system sys = {F, NULL, D, params};
/*The integration loop:*/
/*Initialize*/
/*Calculate dx/dt for x0*/
tc=t[0];
/* initialise dydt_in from system parameters */
/*GSL_ODEIV_FN_EVAL(&sys, t, y, dydt_in);*/
GSL_ODEIV_FN_EVAL(&sys, tc, x0, dydt_in);
for (j=0;j<D;j++) {
y[j] = x[j] = x0[j];
}
/*Integration*/
for (ii=1; ii<iters; ii++) {
/*Call the integrator*/
/*int gsl_odeiv_step_apply(gsl_odeiv_step * s, double t, double h, double y[], double yerr[], const double dydt_in[], double dydt_out[], const gsl_odeiv_system * dydt)*/
t0=t[ii-1];
tf=t[ii];
tc=t0;
while (tc<tf) {
/*Constraint time step h such as that tc+h<=tf*/
if (tc+dt>tf) dt=tf-tc;
/*Advance a h time step*/
status=gsl_odeiv_step_apply(s, tc, dt, y, yerr, dydt_in, dydt_out, &sys);
if (status != GSL_SUCCESS) break;
/*Modify time sep*/
gsl_odeiv_control_hadjust(c,s,y,yerr,dydt_in,&dt);
/*Increase current time*/
tc += dt;
/*Add noise*/
for (j=0;j<D;j++) {
noise=gsl_ran_gaussian_ziggurat(r, s_noise);
y[j] += sqrt(dt)*noise;
//dydt_in[j]+=noise;
}
}
/*Unpack and store result for this time point*/
if (status != GSL_SUCCESS) break;
for (j=0;j<D;j++) {
x[ii*D+j] = y[j];
dxdt[(ii-1)*D+j] = dydt_in[j];
/*Prepare next step*/
dydt_in[j] = dydt_out[j];
}
}
/*Get dxdt for the last time point*/
for (j=0;j<D;j++) dxdt[(iters-1)*D+j] = dydt_out[j];
/*Free dynamically allocated memory*/
gsl_odeiv_control_free(c);
printf("c freed\n");
gsl_odeiv_step_free(s);
printf("s freed\n");
gsl_rng_free(r);
printf("rng freed\n");
free(yerr);
printf("yerr freed\n");
free(dydt_out);
printf("dydt_out freed\n");
free(dydt_in);
printf("dydt_in freed\n");
free(y);
printf("y freed\n");
}
int
main()
{
const size_t n = N;
const size_t p = 2;
size_t i;
gsl_rng *r = gsl_rng_alloc(gsl_rng_default);
gsl_matrix *X = gsl_matrix_alloc(n, p);
gsl_vector *y = gsl_vector_alloc(n);
for (i = 0; i < n; ++i)
{
/* generate first random variable u */
double ui = gsl_ran_gaussian(r, 1.0);
/* set v = u + noise */
double vi = ui + gsl_ran_gaussian(r, 0.001);
/* set y = u + v + noise */
double yi = ui + vi + gsl_ran_gaussian(r, 1.0);
/* since u =~ v, the matrix X is ill-conditioned */
gsl_matrix_set(X, i, 0, ui);
gsl_matrix_set(X, i, 1, vi);
/* rhs vector */
gsl_vector_set(y, i, yi);
}
{
gsl_multifit_linear_workspace *w =
gsl_multifit_linear_alloc(n, p);
gsl_vector *c = gsl_vector_alloc(p);
gsl_vector *c_ridge = gsl_vector_alloc(p);
gsl_matrix *cov = gsl_matrix_alloc(p, p);
double chisq;
/* unregularized (standard) least squares fit, lambda = 0 */
gsl_multifit_linear_ridge(0.0, X, y, c, cov, &chisq, w);
fprintf(stderr, "=== Unregularized fit ===\n");
fprintf(stderr, "best fit: y = %g u + %g v\n",
gsl_vector_get(c, 0), gsl_vector_get(c, 1));
fprintf(stderr, "chisq/dof = %g\n", chisq / (n - p));
/* regularize with lambda = 1 */
gsl_multifit_linear_ridge(1.0, X, y, c_ridge, cov, &chisq, w);
fprintf(stderr, "=== Regularized fit ===\n");
fprintf(stderr, "best fit: y = %g u + %g v\n",
gsl_vector_get(c_ridge, 0), gsl_vector_get(c_ridge, 1));
fprintf(stderr, "chisq/dof = %g\n", chisq / (n - p));
gsl_multifit_linear_free(w);
gsl_matrix_free(cov);
gsl_vector_free(c);
gsl_vector_free(c_ridge);
}
gsl_rng_free(r);
gsl_matrix_free(X);
gsl_vector_free(y);
return 0;
}
double pfilter(Model & sim_model, Parameter & model_params, MCMCoptions & options, Particle &particles, Trajectory & output_traj, TimeSeriesData &epi_data, TreeData &tree_data, MultiTreeData &multitree_data) {
int thread_max = omp_get_max_threads();
gsl_rng** rngs = new gsl_rng*[thread_max];
for (int thread = 0; thread < thread_max; thread++) {
rngs[thread] = gsl_rng_alloc(gsl_rng_mt19937);
gsl_rng_set(rngs[thread], omp_get_thread_num() + thread);
}
double loglik = 0.0;
int num_groups = options.num_groups;
int num_particles = options.particles;
int init_seed = options.seed;
int total_dt = options.total_dt;
double sim_dt = options.sim_dt;
int total_steps = ceil((double)total_dt/(double)options.pfilter_every);
int add_dt = 0;
double ESS_threshold = options.pfilter_threshold*(double)num_particles;
Likelihood likelihood_calc;
// std::vector <Parameter> values;// (options.num_threads, model_params);
// for (int i=0; i!=options.num_threads; ++i) values.push_back(model_params);
// for (int i=0; i!=model_params.get_total_params(); ++i) values.push_back(model_params.get(i));
std::vector <std::vector<double> > values(options.num_threads, std::vector<double>(model_params.get_total_params(), 0.0));
for (int i=0; i!=options.num_threads; ++i) {
for (int j=0; j!=model_params.get_total_params(); ++j) {
values[i][j] = model_params.get(j);
}
}
// printf("Size of values = %d\n",values.size());
double reporting_rate = 1.0;
if (model_params.param_exists("reporting")) {
reporting_rate = model_params.get("reporting");
}
std::vector <std::string> param_names = model_params.get_names_vector();
std::vector <std::vector<std::string> > param_names_threads (options.num_threads);
if (model_params.param_exists("time_before_data")) {
add_dt = model_params.get("time_before_data");
}
if (options.save_traj) {
if (add_dt > 0) {
particles.start_particle_tracing(add_dt+total_dt, num_groups);
}
else if (add_dt < 0) {
particles.start_particle_tracing(add_dt+total_dt, num_groups);
total_steps = ceil((double)(total_dt+add_dt)/(double)options.pfilter_every);
}
else {
particles.start_particle_tracing(total_dt, num_groups);
}
}
std::vector <Model> models;
for (int i=0; i<options.num_threads; ++i) {
models.push_back(sim_model);
}
std::vector <int> add_dt_threads (options.num_threads, add_dt);
std::vector <int> start_dt_threads (options.num_threads, 0);
std::vector <int> end_dt_threads (options.num_threads, add_dt);
std::vector <double> dt_threads (options.num_threads, sim_dt);
std::vector <int> total_dt_threads(options.num_threads, total_dt);
std::vector <double> reporting_rate_threads(options.num_threads, reporting_rate);
std::vector <int> num_groups_threads(options.num_threads, num_groups);
// Simulate model and calculate likelihood assuming no observed data
if (model_params.param_exists("time_before_data")) {
if (add_dt > 0) {
omp_set_num_threads(options.num_threads);
// std::vector <Trajectory *> curr_trajs;
// for (int i=0; i!=num_particles; ++i) {
// curr_trajs.push_back(particles.get_traj(i));
// }
#pragma omp parallel for shared(particles, values) schedule(static,1)
for (int tn = 0; tn < thread_max; tn++) {
for (int i = tn; i < num_particles; i += thread_max) {
// Adjust length of trajectory
particles.get_traj(i)->resize(add_dt, num_groups);
models[tn].simulate(values[tn], param_names_threads[tn], particles.get_traj(i), 0, add_dt_threads[tn], dt_threads[tn], total_dt_threads[tn], rngs[tn]);
if (options.which_likelihood < 2) {
double w = likelihood_calc.binomial_lik(reporting_rate_threads[tn], particles.get_traj(i)->get_total_traj(), add_dt_threads[tn] + total_dt_threads[tn], 0, add_dt_threads[tn], num_groups_threads[tn], false);
particles.set_weight(w, i, false);
}
if (options.save_traj) {
particles.save_traj_to_matrix(i, 0, add_dt);
particles.save_ancestry(i, 0, add_dt);
}
}
}
}
}
init_seed += num_particles;
int t=0;
int start_dt;
int end_dt;
for (t = 0; t != total_steps; ++t) {
// std::vector<double> we(options.particles, 0.0), wg(options.particles, 0.0);
start_dt = t*options.pfilter_every;
end_dt = std::min(total_dt, (t + 1)*options.pfilter_every);
std::fill(start_dt_threads.begin(), start_dt_threads.end(), start_dt);
std::fill(end_dt_threads.begin(), end_dt_threads.end(), end_dt);
omp_set_num_threads(options.num_threads);
#pragma omp parallel for shared (particles, values) schedule(static,1)
for (int tn = 0; tn < thread_max; tn++) {
for (int i = tn; i < num_particles; i+=thread_max) {
// Adjust length of trajectory
// if (tn==0) std::cout << i << ' ' << std::endl;
particles.get_traj(i)->resize(end_dt - start_dt, options.num_groups);
models[tn].simulate(values[tn], param_names_threads[tn], particles.get_traj(i), start_dt_threads[tn], end_dt_threads[tn], dt_threads[tn], total_dt_threads[tn], rngs[tn]);
double w = 1.0;
double temp = 0.0;
if (options.which_likelihood < 2) {
double A = particles.get_traj(i)->get_total_traj();
temp = likelihood_calc.binomial_lik(reporting_rate_threads[tn], A, epi_data.get_data_ptr(0), add_dt_threads[tn] + total_dt_threads[tn], start_dt_threads[tn], end_dt_threads[tn], add_dt_threads[tn], num_groups_threads[tn], false);
w *= temp;
// we[i] = log(temp);
}
if (options.which_likelihood != 1) {
temp = likelihood_calc.coalescent_lik(particles.get_traj(i)->get_traj_ptr(0, 0), particles.get_traj(i)->get_traj_ptr(1, 0),
tree_data.get_binomial_ptr(0), tree_data.get_interval_ptr(0), tree_data.get_ends_ptr(0),
start_dt_threads[tn], end_dt_threads[tn], add_dt_threads[tn], false);
w *= temp;
// wg[i] = log(temp);
}
particles.set_weight(w, i, true);
if (options.save_traj) {
particles.save_traj_to_matrix(i, start_dt_threads[tn] + add_dt_threads[tn], end_dt_threads[tn] + add_dt_threads[tn]);
particles.save_ancestry(i, start_dt_threads[tn] + add_dt_threads[tn], end_dt_threads[tn] + add_dt_threads[tn]);
}
}
}
// std::cout << "Epi Weight: " << std::accumulate(we.begin(), we.end(), 0.0) << " Gen Weight: " << std::accumulate(wg.begin(), wg.end(), 0.0) << " Total: " << particles.get_total_weight() << std::endl;
double curr_ESS = particles.get_ESS();
if (curr_ESS < ESS_threshold) {
double total_weight = particles.get_total_weight();
if (total_weight == 0.0) {
loglik += -0.1*std::numeric_limits<double>::max();
// std::cout << std::accumulate(epi_data.get_data_ptr(0)+start_dt, epi_data.get_data_ptr(0)+end_dt, 0.0) << " : " << particles.get_traj(0)->get_traj(0) << std::endl;
std::cout << "stop time: " << end_dt << std::endl;
break;
} else {
loglik += log(total_weight) - log(num_particles);
}
particles.resample(options.rng[0]);
}
else {
particles.reset_parents();
}
}
if (options.save_traj) {
output_traj.resize((total_dt+add_dt), num_groups);
//if (loglik > -0.1*std::numeric_limits<double>::max()) {
particles.retrace_traj(output_traj, options.rng[0]);
//}
}
for (int i=0; i!=num_particles; ++i) {
particles.get_traj(i)->reset();
}
std::vector < std::vector<double> >().swap(values);
for (int thread = 0; thread < thread_max; thread++) {
gsl_rng_free(rngs[thread]);
}
delete[] rngs;
return (loglik);
}
int
main(int argc, char *argv[])
{
gen_workspace *gen_workspace_p;
lapack_workspace *lapack_workspace_p;
size_t N;
int c;
int lower;
int upper;
int incremental;
size_t nmat;
gsl_matrix *A, *B;
gsl_rng *r;
int s;
int compute_schur;
size_t i;
gsl_ieee_env_setup();
gsl_rng_env_setup();
N = 30;
lower = -10;
upper = 10;
incremental = 0;
nmat = 0;
compute_schur = 0;
while ((c = getopt(argc, argv, "ic:n:l:u:z")) != (-1))
{
switch (c)
{
case 'i':
incremental = 1;
break;
case 'n':
N = strtol(optarg, NULL, 0);
break;
case 'l':
lower = strtol(optarg, NULL, 0);
break;
case 'u':
upper = strtol(optarg, NULL, 0);
break;
case 'c':
nmat = strtoul(optarg, NULL, 0);
break;
case 'z':
compute_schur = 1;
break;
case '?':
default:
printf("usage: %s [-i] [-z] [-n size] [-l lower-bound] [-u upper-bound] [-c num]\n", argv[0]);
exit(1);
break;
} /* switch (c) */
}
A = gsl_matrix_alloc(N, N);
B = gsl_matrix_alloc(N, N);
gen_workspace_p = gen_alloc(N, compute_schur);
lapack_workspace_p = lapack_alloc(N);
r = gsl_rng_alloc(gsl_rng_default);
if (incremental)
{
make_start_matrix(A, lower);
/* we need B to be non-singular */
make_random_integer_matrix(B, r, lower, upper);
}
fprintf(stderr, "testing N = %d", N);
if (incremental)
fprintf(stderr, " incrementally");
else
fprintf(stderr, " randomly");
fprintf(stderr, " on element range [%d, %d]", lower, upper);
if (compute_schur)
fprintf(stderr, ", with Schur vectors");
fprintf(stderr, "\n");
while (1)
{
if (nmat && (count >= nmat))
break;
++count;
if (!incremental)
{
make_random_matrix(A, r, lower, upper);
make_random_matrix(B, r, lower, upper);
}
else
{
s = inc_matrix(A, lower, upper);
if (s)
break; /* all done */
make_random_integer_matrix(B, r, lower, upper);
}
/*if (count != 89120)
continue;*/
/* make copies of matrices */
gsl_matrix_memcpy(gen_workspace_p->A, A);
gsl_matrix_memcpy(gen_workspace_p->B, B);
gsl_matrix_transpose_memcpy(lapack_workspace_p->A, A);
gsl_matrix_transpose_memcpy(lapack_workspace_p->B, B);
/* compute eigenvalues with LAPACK */
s = lapack_proc(lapack_workspace_p);
if (s != GSL_SUCCESS)
{
printf("LAPACK failed, case %lu\n", count);
exit(1);
}
#if 0
print_matrix(A, "A");
print_matrix(B, "B");
gsl_matrix_transpose(lapack_workspace_p->A);
gsl_matrix_transpose(lapack_workspace_p->B);
print_matrix(lapack_workspace_p->A, "S_lapack");
print_matrix(lapack_workspace_p->B, "T_lapack");
#endif
/* compute eigenvalues with GSL */
s = gen_proc(gen_workspace_p);
if (s != GSL_SUCCESS)
{
printf("=========== CASE %lu ============\n", count);
printf("Failed to converge: found %u eigenvalues\n",
gen_workspace_p->n_evals);
print_matrix(A, "A");
print_matrix(B, "B");
print_matrix(gen_workspace_p->A, "Af");
print_matrix(gen_workspace_p->B, "Bf");
print_matrix(lapack_workspace_p->A, "Ae");
print_matrix(lapack_workspace_p->B, "Be");
exit(1);
}
#if 0
print_matrix(gen_workspace_p->A, "S_gsl");
print_matrix(gen_workspace_p->B, "T_gsl");
#endif
/* compute alpha / beta vectors */
for (i = 0; i < N; ++i)
{
double beta;
gsl_complex alpha, z;
beta = gsl_vector_get(gen_workspace_p->beta, i);
if (beta == 0.0)
GSL_SET_COMPLEX(&z, GSL_POSINF, GSL_POSINF);
else
{
alpha = gsl_vector_complex_get(gen_workspace_p->alpha, i);
z = gsl_complex_div_real(alpha, beta);
}
gsl_vector_complex_set(gen_workspace_p->evals, i, z);
beta = gsl_vector_get(lapack_workspace_p->beta, i);
GSL_SET_COMPLEX(&alpha,
lapack_workspace_p->alphar[i],
lapack_workspace_p->alphai[i]);
if (beta == 0.0)
GSL_SET_COMPLEX(&z, GSL_POSINF, GSL_POSINF);
else
z = gsl_complex_div_real(alpha, beta);
gsl_vector_complex_set(lapack_workspace_p->evals, i, z);
gsl_vector_complex_set(lapack_workspace_p->alpha, i, alpha);
}
#if 0
gsl_sort_vector(gen_workspace_p->beta);
gsl_sort_vector(lapack_workspace_p->beta);
sort_complex_vector(gen_workspace_p->alpha);
sort_complex_vector(lapack_workspace_p->alpha);
s = test_alpha(gen_workspace_p->alpha,
lapack_workspace_p->alpha,
A,
B,
"gen",
"lapack");
s = test_beta(gen_workspace_p->beta,
lapack_workspace_p->beta,
A,
B,
"gen",
"lapack");
#endif
#if 1
sort_complex_vector(gen_workspace_p->evals);
sort_complex_vector(lapack_workspace_p->evals);
s = test_evals(gen_workspace_p->evals,
lapack_workspace_p->evals,
A,
B,
"gen",
"lapack");
#endif
if (compute_schur)
{
test_schur(A,
gen_workspace_p->A,
gen_workspace_p->Q,
gen_workspace_p->Z);
test_schur(B,
gen_workspace_p->B,
gen_workspace_p->Q,
gen_workspace_p->Z);
}
}
gsl_matrix_free(A);
gsl_matrix_free(B);
gen_free(gen_workspace_p);
lapack_free(lapack_workspace_p);
if (r)
gsl_rng_free(r);
return 0;
} /* main() */
int main(int argc, char* argv[]) {
unsigned int i = 0;
unsigned int nbIntervals = 0;
double* intervals = NULL;
FILE* outputFileFd = NULL;
gsl_rng* rng = NULL;
unsigned int nbStates = 0;
struct arg_file* outputFile = arg_file1("o", NULL, "<file>", "The output file for the generated initial state");
struct arg_int* n = arg_int1("n", NULL, "<n>", "The number of initial states to generate");
struct arg_str* s = arg_str1(NULL, "intervals", "<s>", "The intervals for the initial states generation");
struct arg_end* end = arg_end(4);
void* argtable[4];
int nerrors = 0;
argtable[0] = outputFile;
argtable[1] = n;
argtable[2] = s;
argtable[3] = end;
if(arg_nullcheck(argtable) != 0) {
printf("error: insufficient memory\n");
arg_freetable(argtable, 4);
return EXIT_FAILURE;
}
nerrors = arg_parse(argc, argv, argtable);
if(nerrors > 0) {
printf("%s:", argv[0]);
arg_print_syntax(stdout, argtable, "\n");
arg_print_errors(stdout, end, argv[0]);
arg_freetable(argtable, 4);
return EXIT_FAILURE;
}
nbStates = n->ival[0];
intervals = parseIntervals(s->sval[0], &nbIntervals);
rng = gsl_rng_alloc(gsl_rng_mt19937);
gsl_rng_set(rng, time(NULL));
outputFileFd = fopen(outputFile->filename[0], "w");
fprintf(outputFileFd, "%u\n", n->ival[0]);
for(; i < nbStates; i++) {
unsigned int j = 0;
for(; j < (nbIntervals - 1); j++)
fprintf(outputFileFd, "%.15f,", (fabs(intervals[(j * 2) + 1] - intervals[j * 2]) * gsl_rng_uniform(rng)) + intervals[j * 2]);
fprintf(outputFileFd, "%.15f\n", (fabs(intervals[(j * 2) + 1] - intervals[j * 2]) * gsl_rng_uniform(rng)) + intervals[j * 2]);
}
fclose(outputFileFd);
gsl_rng_free(rng);
free(intervals);
arg_freetable(argtable, 4);
return EXIT_SUCCESS;
}
int main (int argc, char *argv[])
{
double psr;
// source bulge
double res_s,err_s;
double xl_s[1]={4.5};
double xu_s[1]={11.5};
const gsl_rng_type *T_s;
gsl_rng *r_s;
gsl_monte_function G_s={&source,1,0};
size_t calls_s=50000000;
gsl_rng_env_setup ();
T_s=gsl_rng_default;
r_s = gsl_rng_alloc (T_s);
gsl_monte_vegas_state *s_s = gsl_monte_vegas_alloc (1);
gsl_monte_vegas_integrate (&G_s, xl_s, xu_s, 1, 10000, r_s, s_s, &res_s, &err_s);
do
{
gsl_monte_vegas_integrate (&G_s, xl_s, xu_s, 1, calls_s/5, r_s, s_s, &res_s, &err_s);
}
while (fabs (gsl_monte_vegas_chisq (s_s) - 1.0) > 0.5);
gsl_monte_vegas_free (s_s);
gsl_rng_free (r_s);
//////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
// neutron stars, pulsar to bulge
double res_x,err_x;
//double xl_x[4]={3.0,0.0,-1200.0,-1200.0};
//double xu_x[4]={13.0,13.0,1200.0,1200.0};
double xl_x[8]={4.5,0.01,-2000.0,-2000.0,-2000.0,-550.0,-450.0,-350.0};
double xu_x[8]={11.5,8.0,2000.0,2000.0,2000.0,550.0,450.0,350.0};
const gsl_rng_type *T_x;
gsl_rng *r_x;
gsl_monte_function G_x={&g_psr,8,0};
size_t calls_x=50000000;
T_x=gsl_rng_default;
// calculation
r_x=gsl_rng_alloc(T_x);
gsl_monte_vegas_state *s_x = gsl_monte_vegas_alloc (8);
gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 8, 10000, r_x, s_x,&res_x, &err_x);
do
{
gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 8, calls_x/5, r_x, s_x,&res_x, &err_x);
}
while (fabs (gsl_monte_vegas_chisq (s_x) - 1.0) > 0.5);
/////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
// source disk
double res_sd,err_sd;
double xl_sd[1]={0.0};
double xu_sd[1]={11.5};
const gsl_rng_type *T_sd;
gsl_rng *r_sd;
gsl_monte_function G_sd={&source_d,1,0};
size_t calls_sd=50000000;
T_sd=gsl_rng_default;
r_sd = gsl_rng_alloc (T_sd);
gsl_monte_vegas_state *s_sd = gsl_monte_vegas_alloc (1);
gsl_monte_vegas_integrate (&G_sd, xl_sd, xu_sd, 1, 10000, r_sd, s_sd, &res_sd, &err_sd);
do
{
gsl_monte_vegas_integrate (&G_sd, xl_sd, xu_sd, 1, calls_sd/5, r_sd, s_sd, &res_sd, &err_sd);
}
while (fabs (gsl_monte_vegas_chisq (s_sd) - 1.0) > 0.5);
gsl_monte_vegas_free (s_sd);
gsl_rng_free (r_sd);
//////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////
// neutron stars, pulsar to disk
double res_xd,err_xd;
//double xl_x[4]={3.0,0.0,-1200.0,-1200.0};
//double xu_x[4]={13.0,13.0,1200.0,1200.0};
double xl_xd[8]={0.0,0.01,-2000.0,-2000.0,-2000.0,-100.0,-150.0,-100.0};
double xu_xd[8]={11.5,8.0,2000.0,2000.0,2000.0,100.0,150.0,100.0};
const gsl_rng_type *T_xd;
gsl_rng *r_xd;
gsl_monte_function G_xd={&g_psr_d,8,0};
size_t calls_xd=50000000;
T_xd=gsl_rng_default;
// calculation
r_xd=gsl_rng_alloc(T_xd);
gsl_monte_vegas_state *s_xd = gsl_monte_vegas_alloc (8);
gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 8, 10000, r_xd, s_xd, &res_xd, &err_xd);
do
{
gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 8, calls_xd/5, r_xd, s_xd, &res_xd, &err_xd);
}
while (fabs (gsl_monte_vegas_chisq (s_xd) - 1.0) > 0.5);
/////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
psr = (fabs(res_x)+fabs(res_xd))/(fabs(res_s)+fabs(res_sd));
printf ("bulge:%e %e %e\n", res_x, res_s, res_x/res_s);
printf ("disk:%e %e %e\n", res_xd, res_sd, res_xd/res_sd);
printf ("psr event rate:%e\n", psr);
//printf ("psr event rate: %e\n", psr);
gsl_monte_vegas_free (s_x);
gsl_rng_free (r_x);
gsl_monte_vegas_free (s_xd);
gsl_rng_free (r_xd);
return 0;
}
scope_ray *rays_initialize(int ray_setup, int *ray_status, double *overshoot){
/* Variable Declarations */
long i,j;
scope_ray *rays,normal,g,det_plane;
double angle=0.;
printf("Initializing %0.3e rays...\n",N_RAYS);
rays = (scope_ray *)malloc(N_RAYS * sizeof(scope_ray));
*ray_status = 2222;
/* Initialize ray position randomly across the aperture */
/* Start GSL's RNG */
const gsl_rng_type *T;
gsl_rng *r;
gsl_rng_env_setup();
// T = gsl_rng_ranlux389; // Second slowest
T = gsl_rng_taus2;
r = gsl_rng_alloc(T);
/* Assign random starting point for rays */
double radius = 1.0;
double x,y;
for(i=0,j=0;i<N_RAYS;i++,j++){ // j counts the # of times the loop executes
x = gsl_rng_uniform(r)*2. - 1.;
y = gsl_rng_uniform(r)*2. - 1.;
if(x*x + y*y > 1.){ // If outside the circle,
i--; // decriment i,
continue; // and try again.
}
rays[i].x = x*radius;
rays[i].y = y*radius;
rays[i].z = +10.; // Start way up high
rays[i].lost = false; // Not lost yet
}
*overshoot = (double)j/(double)i;
/* Initialize ray direction based on setup criteria */
switch(ray_setup){
case(TARGET_POINT):
printf("Serving up a single point source...\n");
for(i=0;i<N_RAYS;i++){
rays[i].vx = sin(angle);
rays[i].vy = 0;
rays[i].vz = -cos(angle);
}
break;
case(TARGET_POINTS):
break;
case(TARGET_IMAGE):
i=0;
/* Variable Declaration */
int stat;
gsl_histogram2d imghist;
gsl_histogram2d_pdf imgpdf;
double x,y;
stat = gsl_histogram2d_pdf_sample(&imgpdf,
gsl_rng_uniform(r), gsl_rng_uniform(r),
&x, &y);
rays[i].x = x;
rays[i].y = y;
rays[i].z = +10.;
break;
default:
printf("I am defaulting on ray direction.\n");
}
/* Clean up */
gsl_rng_free(r);
return rays;
}
void free_rng(gsl_rng * rng) {
gsl_rng_free(rng);
}
void
free_rng( void )
{
gsl_rng_free( r );
return ;
}
Lattice::~Lattice()
{
gsl_rng_free(rng);
delete [] phi_data;
}
int main(int argc, char *argv[]){
double zmin=0.0, zmax=0.0;
int galaxies=0.0;
string outputfile;
bool HALF=false, START=false;
int arg=1;
int nside=512;
while (arg < argc) {
if (argv[arg][0] == '-') {
switch (argv[arg][1]) {
case 'O':
outputfile=string(argv[arg+1]);
arg+=2;
break;
case 'N':
nside=atoi(argv[arg+1]);
arg+=2;
break;
case 'G':
galaxies=atoi(argv[arg+1]);
arg+=2;
break;
case 'H':
HALF=true;
arg+=1;
break;
case 'h':
cout<<BOLDRED<<"Options:"<<RESET<<endl;
cout<<endl;
cout<<YELLOW<<"-O"<<RESET<<"utput: name of the "<<BLUE<<"'outputfile'"<<RESET<<" in fits format"<<endl;
cout<<YELLOW<<"-N"<<RESET<<"side: "<<BLUE<<"'nside'"<<RESET<<" Healpix resolution of the output map; default 512"<<endl;
cout<<YELLOW<<"-G"<<RESET<<"alaxies: "<<BLUE<<"'galaxy number'"<<RESET<<" of the uniform distributed map"<<endl;
cout<<YELLOW<<"-H"<<RESET<<"alf: upper half of the sphere will be realised, otherwise full sphere"<<endl;
cout<<MAGENTA<<"Example:"<<endl<<"./RandomReal -O out_map.fits -G 100000 -H"<<endl<<";"<<RESET<<endl<<endl;
cout<<GREEN<<"Queries should be directed to [email protected]"<<RESET<<endl;
START=false;
arg++;
break;
default:
cout<<"bad argument: do RandomReal -h to get man page. "<<RED<<"Exit now"<<RESET<<endl;
exit(-1);
break;
}
}else{
cout<<"bad argument: do RandomReal -h to get man page. "<<RED<<"Exit now."<<RESET<<endl;
exit(-1);
}
}
int order=log2(nside);
Healpix_Map<double> randomreal(order, RING);
//Initialise random numbers
gsl_rng *random=gsl_rng_alloc(gsl_rng_default);
gsl_rng *random2=gsl_rng_alloc(gsl_rng_default);
gsl_rng *random3=gsl_rng_alloc(gsl_rng_default);
int seed=time(NULL);
int seed2=time(NULL)+100;
int seed3=time(NULL)+1000;
gsl_rng_set(random, seed);
gsl_rng_set(random2, seed2);
gsl_rng_set(random3, seed3);
randomreal.fill(0.0);
pointing pointer;
double phi, costheta;
int pixel=0;
for(int i=0; i<galaxies;i++){
costheta=gsl_rng_uniform(random);
phi=2.0*pi*gsl_rng_uniform(random2);
if(!HALF) if(gsl_rng_uniform(random3)>0.5) costheta=-costheta;
pointer.theta=acos(costheta);
pointer.phi=phi;
pixel=randomreal.ang2pix(pointer);
randomreal[pixel]+=1.0;
}
write_Healpix_map_to_fits<float64>(outputfile, randomreal, PLANCK_FLOAT64);
gsl_rng_free(random);
gsl_rng_free(random2);
return 0;
}
void fnIMIS(const size_t InitSamples, const size_t StepSamples, const size_t FinalResamples, const size_t MaxIter, const size_t NumParam, unsigned long int rng_seed, const char * runName)
{
// Declare and configure GSL RNG
gsl_rng * rng;
const gsl_rng_type * T;
gsl_rng_env_setup();
T = gsl_rng_default;
rng = gsl_rng_alloc (T);
gsl_rng_set(rng, rng_seed);
char strDiagnosticsFile[strlen(runName) + 15 +1];
char strResampleFile[strlen(runName) + 12 +1];
strcpy(strDiagnosticsFile, runName); strcat(strDiagnosticsFile, "Diagnostics.txt");
strcpy(strResampleFile, runName); strcat(strResampleFile, "Resample.txt");
FILE * diagnostics_file = fopen(strDiagnosticsFile, "w");
fprintf(diagnostics_file, "Seeded RNG: %zu\n", rng_seed);
fprintf(diagnostics_file, "Running IMIS. InitSamples: %zu, StepSamples: %zu, FinalResamples %zu, MaxIter %zu\n", InitSamples, StepSamples, FinalResamples, MaxIter);
// Setup IMIS arrays
gsl_matrix * Xmat = gsl_matrix_alloc(InitSamples + StepSamples*MaxIter, NumParam);
double * prior_all = (double*) malloc(sizeof(double) * (InitSamples + StepSamples*MaxIter));
double * likelihood_all = (double*) malloc(sizeof(double) * (InitSamples + StepSamples*MaxIter));
double * imp_weight_denom = (double*) malloc(sizeof(double) * (InitSamples + StepSamples*MaxIter)); // proportional to q(k) in stage 2c of Raftery & Bao
double * gaussian_sum = (double*) calloc(InitSamples + StepSamples*MaxIter, sizeof(double)); // sum of mixture distribution for mode
struct dst * distance = (struct dst *) malloc(sizeof(struct dst) * (InitSamples + StepSamples*MaxIter)); // Mahalanobis distance to most recent mode
double * imp_weights = (double*) malloc(sizeof(double) * (InitSamples + StepSamples*MaxIter));
double * tmp_MVNpdf = (double*) malloc(sizeof(double) * (InitSamples + StepSamples*MaxIter));
gsl_matrix * nearestX = gsl_matrix_alloc(StepSamples, NumParam);
double center_all[MaxIter][NumParam];
gsl_matrix * sigmaChol_all[MaxIter];
gsl_matrix * sigmaInv_all[MaxIter];
// Initial prior samples
sample_prior(rng, InitSamples, Xmat);
// Calculate prior covariance
double prior_invCov_diag[NumParam];
/*
The paper describing the algorithm uses the full prior covariance matrix.
This follows the code in the IMIS R package and diagonalizes the prior
covariance matrix to ensure invertibility.
*/
for(size_t i = 0; i < NumParam; i++){
gsl_vector_view tmpCol = gsl_matrix_subcolumn(Xmat, i, 0, InitSamples);
prior_invCov_diag[i] = gsl_stats_variance(tmpCol.vector.data, tmpCol.vector.stride, InitSamples);
prior_invCov_diag[i] = 1.0/prior_invCov_diag[i];
}
// IMIS steps
fprintf(diagnostics_file, "Step Var(w_i) MargLik Unique Max(w_i) ESS Time\n");
printf("Step Var(w_i) MargLik Unique Max(w_i) ESS Time\n");
time_t time1, time2;
time(&time1);
size_t imisStep = 0, numImisSamples;
for(imisStep = 0; imisStep < MaxIter; imisStep++){
numImisSamples = (InitSamples + imisStep*StepSamples);
// Evaluate prior and likelihood
if(imisStep == 0){ // initial stage
#pragma omp parallel for
for(size_t i = 0; i < numImisSamples; i++){
gsl_vector_const_view theta = gsl_matrix_const_row(Xmat, i);
prior_all[i] = prior(&theta.vector);
likelihood_all[i] = likelihood(&theta.vector);
}
} else { // imisStep > 0
#pragma omp parallel for
for(size_t i = InitSamples + (imisStep-1)*StepSamples; i < numImisSamples; i++){
gsl_vector_const_view theta = gsl_matrix_const_row(Xmat, i);
prior_all[i] = prior(&theta.vector);
likelihood_all[i] = likelihood(&theta.vector);
}
}
// Determine importance weights, find current maximum, calculate monitoring criteria
#pragma omp parallel for
for(size_t i = 0; i < numImisSamples; i++){
imp_weight_denom[i] = (InitSamples*prior_all[i] + StepSamples*gaussian_sum[i])/(InitSamples + StepSamples * imisStep);
imp_weights[i] = (prior_all[i] > 0)?likelihood_all[i]*prior_all[i]/imp_weight_denom[i]:0;
}
double sumWeights = 0.0;
for(size_t i = 0; i < numImisSamples; i++){
sumWeights += imp_weights[i];
}
double maxWeight = 0.0, varImpW = 0.0, entropy = 0.0, expectedUnique = 0.0, effSampSize = 0.0, margLik;
size_t maxW_idx;
#pragma omp parallel for reduction(+: varImpW, entropy, expectedUnique, effSampSize)
for(size_t i = 0; i < numImisSamples; i++){
imp_weights[i] /= sumWeights;
varImpW += pow(numImisSamples * imp_weights[i] - 1.0, 2.0);
entropy += imp_weights[i] * log(imp_weights[i]);
expectedUnique += (1.0 - pow((1.0 - imp_weights[i]), FinalResamples));
effSampSize += pow(imp_weights[i], 2.0);
}
for(size_t i = 0; i < numImisSamples; i++){
if(imp_weights[i] > maxWeight){
maxW_idx = i;
maxWeight = imp_weights[i];
}
}
for(size_t i = 0; i < NumParam; i++)
center_all[imisStep][i] = gsl_matrix_get(Xmat, maxW_idx, i);
varImpW /= numImisSamples;
entropy = -entropy / log(numImisSamples);
effSampSize = 1.0/effSampSize;
margLik = log(sumWeights/numImisSamples);
fprintf(diagnostics_file, "%4zu %8.2f %8.2f %8.2f %8.2f %8.2f %8.2f\n", imisStep, varImpW, margLik, expectedUnique, maxWeight, effSampSize, difftime(time(&time2), time1));
printf("%4zu %8.2f %8.2f %8.2f %8.2f %8.2f %8.2f\n", imisStep, varImpW, margLik, expectedUnique, maxWeight, effSampSize, difftime(time(&time2), time1));
time1 = time2;
// Check for convergence
if(expectedUnique > FinalResamples*(1.0 - exp(-1.0))){
break;
}
// Calculate Mahalanobis distance to current mode
GetMahalanobis_diag(Xmat, center_all[imisStep], prior_invCov_diag, numImisSamples, NumParam, distance);
// Find StepSamples nearest points
// (Note: this was a major bottleneck when InitSamples and StepResamples are large. qsort substantially outperformed GSL sort options.)
qsort(distance, numImisSamples, sizeof(struct dst), cmp_dst);
#pragma omp parallel for
for(size_t i = 0; i < StepSamples; i++){
gsl_vector_const_view tmpX = gsl_matrix_const_row(Xmat, distance[i].idx);
gsl_matrix_set_row(nearestX, i, &tmpX.vector);
}
// Calculate weighted covariance of nearestX
// (a) Calculate weights for nearest points 1...StepSamples
double weightsCov[StepSamples];
#pragma omp parallel for
for(size_t i = 0; i < StepSamples; i++){
weightsCov[i] = 0.5*(imp_weights[distance[i].idx] + 1.0/numImisSamples); // cov_wt function will normalize the weights
}
// (b) Calculate weighted covariance
sigmaChol_all[imisStep] = gsl_matrix_alloc(NumParam, NumParam);
covariance_weighted(nearestX, weightsCov, StepSamples, center_all[imisStep], NumParam, sigmaChol_all[imisStep]);
// (c) Do Cholesky decomposition and inverse of covariance matrix
gsl_linalg_cholesky_decomp(sigmaChol_all[imisStep]);
for(size_t j = 0; j < NumParam; j++) // Note: GSL outputs a symmetric matrix rather than lower tri, so have to set upper tri to zero
for(size_t k = j+1; k < NumParam; k++)
gsl_matrix_set(sigmaChol_all[imisStep], j, k, 0.0);
sigmaInv_all[imisStep] = gsl_matrix_alloc(NumParam, NumParam);
gsl_matrix_memcpy(sigmaInv_all[imisStep], sigmaChol_all[imisStep]);
gsl_linalg_cholesky_invert(sigmaInv_all[imisStep]);
// Sample new inputs
gsl_matrix_view newSamples = gsl_matrix_submatrix(Xmat, numImisSamples, 0, StepSamples, NumParam);
GenerateRandMVnorm(rng, StepSamples, center_all[imisStep], sigmaChol_all[imisStep], NumParam, &newSamples.matrix);
// Evaluate sampling probability from mixture distribution
// (a) For newly sampled points, sum over all previous centers
for(size_t pastStep = 0; pastStep < imisStep; pastStep++){
GetMVNpdf(&newSamples.matrix, center_all[pastStep], sigmaInv_all[pastStep], sigmaChol_all[pastStep], StepSamples, NumParam, tmp_MVNpdf);
#pragma omp parallel for
for(size_t i = 0; i < StepSamples; i++)
gaussian_sum[numImisSamples + i] += tmp_MVNpdf[i];
}
// (b) For all points, add weight for most recent center
gsl_matrix_const_view Xmat_curr = gsl_matrix_const_submatrix(Xmat, 0, 0, numImisSamples + StepSamples, NumParam);
GetMVNpdf(&Xmat_curr.matrix, center_all[imisStep], sigmaInv_all[imisStep], sigmaChol_all[imisStep], numImisSamples + StepSamples, NumParam, tmp_MVNpdf);
#pragma omp parallel for
for(size_t i = 0; i < numImisSamples + StepSamples; i++)
gaussian_sum[i] += tmp_MVNpdf[i];
} // loop over imisStep
//// FINISHED IMIS ROUTINE
fclose(diagnostics_file);
// Resample posterior outputs
int resampleIdx[FinalResamples];
walker_ProbSampleReplace(rng, numImisSamples, imp_weights, FinalResamples, resampleIdx); // Note: Random sampling routine used in R sample() function.
// Print results
FILE * resample_file = fopen(strResampleFile, "w");
for(size_t i = 0; i < FinalResamples; i++){
for(size_t j = 0; j < NumParam; j++)
fprintf(resample_file, "%.15e\t", gsl_matrix_get(Xmat, resampleIdx[i], j));
gsl_vector_const_view theta = gsl_matrix_const_row(Xmat, resampleIdx[i]);
fprintf(resample_file, "\n");
}
fclose(resample_file);
/*
// This outputs Xmat (parameter matrix), centers, and covariance matrices to files for debugging
FILE * Xmat_file = fopen("Xmat.txt", "w");
for(size_t i = 0; i < numImisSamples; i++){
for(size_t j = 0; j < NumParam; j++)
fprintf(Xmat_file, "%.15e\t", gsl_matrix_get(Xmat, i, j));
fprintf(Xmat_file, "%e\t%e\t%e\t%e\t%e\t\n", prior_all[i], likelihood_all[i], imp_weights[i], gaussian_sum[i], distance[i]);
}
fclose(Xmat_file);
FILE * centers_file = fopen("centers.txt", "w");
for(size_t i = 0; i < imisStep; i++){
for(size_t j = 0; j < NumParam; j++)
fprintf(centers_file, "%f\t", center_all[i][j]);
fprintf(centers_file, "\n");
}
fclose(centers_file);
FILE * sigmaInv_file = fopen("sigmaInv.txt", "w");
for(size_t i = 0; i < imisStep; i++){
for(size_t j = 0; j < NumParam; j++)
for(size_t k = 0; k < NumParam; k++)
fprintf(sigmaInv_file, "%f\t", gsl_matrix_get(sigmaInv_all[i], j, k));
fprintf(sigmaInv_file, "\n");
}
fclose(sigmaInv_file);
*/
// free memory allocated by IMIS
for(size_t i = 0; i < imisStep; i++){
gsl_matrix_free(sigmaChol_all[i]);
gsl_matrix_free(sigmaInv_all[i]);
}
// release RNG
gsl_rng_free(rng);
gsl_matrix_free(Xmat);
gsl_matrix_free(nearestX);
free(prior_all);
free(likelihood_all);
free(imp_weight_denom);
free(gaussian_sum);
free(distance);
free(imp_weights);
free(tmp_MVNpdf);
return;
}