int GSLRNG_negative_binomial(stEval *args, stEval *result, void *i) {
gsl_rng *r = STPOINTER(&args[0]);
double p = STDOUBLE(&args[1]);
int n = STINT(&args[2]);
STINT(result) = gsl_ran_negative_binomial(r,p,n);
return EC_OK;
}
inline
void CNPLCM_CR_Basic_Freq::sam_n0(){
//GSL: "This function returns a random integer from the negative binomial distribution,
// the number of failures occurring before n successes in independent trials with probability
// p of success. The probability distribution for negative binomial variates is,
// p(k) = {\Gamma(n + k) \over \Gamma(k+1) \Gamma(n) } p^n (1-p)^k NOTE THE +1 IN GAMMA(K+1)!!!!
par->n0 = gsl_ran_negative_binomial(r, 1.0 - par->prob_zero, data->n); //<-=-this one is the correct.
//This corresponds to an (improper) prior P(Nmis|n) \propto n/(Nmis+n). This ensures that after integrating Nmis
// the joint probability correspond to the correct truncated distribution.
}
void librdist_negative_binomial(gsl_rng *rng, int argc, void *argv, int bufc, float *buf){
t_atom *av = (t_atom *)argv;
if(argc != librdist_getnargs(ps_negative_binomial)){
return;
}
const double p = librdist_atom_getfloat(av);
const double n = librdist_atom_getfloat(av + 1);
int i;
for(i = 0; i < bufc; i++)
buf[i] = (float)gsl_ran_negative_binomial(rng, p, n);
}
unsigned int
gsl_ran_pascal (const gsl_rng * r, double p, unsigned int n)
{
/* This is a separate interface for the pascal distribution so that
it can be optimized differently from the negative binomial in
future.
e.g. if n < 10 it might be faster to generate the Pascal
distributions as the sum of geometric variates directly. */
unsigned int k = gsl_ran_negative_binomial (r, p, (double) n);
return k;
}
rcount nulldist::rand()
{
if( gsl_ran_bernoulli( rng, a ) ) return 0;
/* This uses a rejection sampling scheme worked out by Charles Geyer,
* detailed in his notes "Lower-Truncated Poisson and Negative Binomial
* Distributions".
*/
rcount x;
double accp;
while( true ) {
x = gsl_ran_negative_binomial( rng, p, r + 1.0 ) + 1;
accp = gsl_sf_lnfact( x - 1 ) - gsl_sf_lnfact( x );
if( gsl_ran_bernoulli( rng, exp( accp ) ) ) break;
}
return x;
}
int
main (int argc, char *argv[])
{
size_t i,j;
size_t n = 0;
double mu = 0, nu = 0, nu1 = 0, nu2 = 0, sigma = 0, a = 0, b = 0, c = 0;
double zeta = 0, sigmax = 0, sigmay = 0, rho = 0;
double p = 0;
double x = 0, y =0, z=0 ;
unsigned int N = 0, t = 0, n1 = 0, n2 = 0 ;
unsigned long int seed = 0 ;
const char * name ;
gsl_rng * r ;
if (argc < 4)
{
printf (
"Usage: gsl-randist seed n DIST param1 param2 ...\n"
"Generates n samples from the distribution DIST with parameters param1,\n"
"param2, etc. Valid distributions are,\n"
"\n"
" beta\n"
" binomial\n"
" bivariate-gaussian\n"
" cauchy\n"
" chisq\n"
" dir-2d\n"
" dir-3d\n"
" dir-nd\n"
" erlang\n"
" exponential\n"
" exppow\n"
" fdist\n"
" flat\n"
" gamma\n"
" gaussian-tail\n"
" gaussian\n"
" geometric\n"
" gumbel1\n"
" gumbel2\n"
" hypergeometric\n"
" laplace\n"
" landau\n"
" levy\n"
" levy-skew\n"
" logarithmic\n"
" logistic\n"
" lognormal\n"
" negative-binomial\n"
" pareto\n"
" pascal\n"
" poisson\n"
" rayleigh-tail\n"
" rayleigh\n"
" tdist\n"
" ugaussian-tail\n"
" ugaussian\n"
" weibull\n") ;
exit (0);
}
argv++ ; seed = atol (argv[0]); argc-- ;
argv++ ; n = atol (argv[0]); argc-- ;
argv++ ; name = argv[0] ; argc-- ; argc-- ;
gsl_rng_env_setup() ;
if (gsl_rng_default_seed != 0) {
fprintf(stderr,
"overriding GSL_RNG_SEED with command line value, seed = %ld\n",
seed) ;
}
gsl_rng_default_seed = seed ;
r = gsl_rng_alloc(gsl_rng_default) ;
#define NAME(x) !strcmp(name,(x))
#define OUTPUT(x) for (i = 0; i < n; i++) { printf("%g\n", (x)) ; }
#define OUTPUT1(a,x) for(i = 0; i < n; i++) { a ; printf("%g\n", x) ; }
#define OUTPUT2(a,x,y) for(i = 0; i < n; i++) { a ; printf("%g %g\n", x, y) ; }
#define OUTPUT3(a,x,y,z) for(i = 0; i < n; i++) { a ; printf("%g %g %g\n", x, y, z) ; }
#define INT_OUTPUT(x) for (i = 0; i < n; i++) { printf("%d\n", (x)) ; }
#define ARGS(x,y) if (argc != x) error(y) ;
#define DBL_ARG(x) if (argc) { x=atof((++argv)[0]);argc--;} else {error( #x);};
#define INT_ARG(x) if (argc) { x=atoi((++argv)[0]);argc--;} else {error( #x);};
if (NAME("bernoulli"))
{
ARGS(1, "p = probability of success");
DBL_ARG(p)
INT_OUTPUT(gsl_ran_bernoulli (r, p));
}
else if (NAME("beta"))
{
ARGS(2, "a,b = shape parameters");
DBL_ARG(a)
DBL_ARG(b)
OUTPUT(gsl_ran_beta (r, a, b));
}
else if (NAME("binomial"))
{
ARGS(2, "p = probability, N = number of trials");
DBL_ARG(p)
INT_ARG(N)
INT_OUTPUT(gsl_ran_binomial (r, p, N));
}
else if (NAME("cauchy"))
{
ARGS(1, "a = scale parameter");
DBL_ARG(a)
OUTPUT(gsl_ran_cauchy (r, a));
}
else if (NAME("chisq"))
{
ARGS(1, "nu = degrees of freedom");
DBL_ARG(nu)
OUTPUT(gsl_ran_chisq (r, nu));
}
else if (NAME("erlang"))
{
ARGS(2, "a = scale parameter, b = order");
DBL_ARG(a)
DBL_ARG(b)
OUTPUT(gsl_ran_erlang (r, a, b));
}
else if (NAME("exponential"))
{
ARGS(1, "mu = mean value");
DBL_ARG(mu) ;
OUTPUT(gsl_ran_exponential (r, mu));
}
else if (NAME("exppow"))
{
ARGS(2, "a = scale parameter, b = power (1=exponential, 2=gaussian)");
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_exppow (r, a, b));
}
else if (NAME("fdist"))
{
ARGS(2, "nu1, nu2 = degrees of freedom parameters");
DBL_ARG(nu1) ;
DBL_ARG(nu2) ;
OUTPUT(gsl_ran_fdist (r, nu1, nu2));
}
else if (NAME("flat"))
{
ARGS(2, "a = lower limit, b = upper limit");
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_flat (r, a, b));
}
else if (NAME("gamma"))
{
ARGS(2, "a = order, b = scale");
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_gamma (r, a, b));
}
else if (NAME("gaussian"))
{
ARGS(1, "sigma = standard deviation");
DBL_ARG(sigma) ;
OUTPUT(gsl_ran_gaussian (r, sigma));
}
else if (NAME("gaussian-tail"))
{
ARGS(2, "a = lower limit, sigma = standard deviation");
DBL_ARG(a) ;
DBL_ARG(sigma) ;
OUTPUT(gsl_ran_gaussian_tail (r, a, sigma));
}
else if (NAME("ugaussian"))
{
ARGS(0, "unit gaussian, no parameters required");
OUTPUT(gsl_ran_ugaussian (r));
}
else if (NAME("ugaussian-tail"))
{
ARGS(1, "a = lower limit");
DBL_ARG(a) ;
OUTPUT(gsl_ran_ugaussian_tail (r, a));
}
else if (NAME("bivariate-gaussian"))
{
ARGS(3, "sigmax = x std.dev., sigmay = y std.dev., rho = correlation");
DBL_ARG(sigmax) ;
DBL_ARG(sigmay) ;
DBL_ARG(rho) ;
OUTPUT2(gsl_ran_bivariate_gaussian (r, sigmax, sigmay, rho, &x, &y),
x, y);
}
else if (NAME("dir-2d"))
{
OUTPUT2(gsl_ran_dir_2d (r, &x, &y), x, y);
}
else if (NAME("dir-3d"))
{
OUTPUT3(gsl_ran_dir_3d (r, &x, &y, &z), x, y, z);
}
else if (NAME("dir-nd"))
{
double *xarr;
ARGS(1, "n1 = number of dimensions of hypersphere");
INT_ARG(n1) ;
xarr = (double *)malloc(n1*sizeof(double));
for(i = 0; i < n; i++) {
gsl_ran_dir_nd (r, n1, xarr) ;
for (j = 0; j < n1; j++) {
if (j) putchar(' ');
printf("%g", xarr[j]) ;
}
putchar('\n');
} ;
free(xarr);
}
else if (NAME("geometric"))
{
ARGS(1, "p = bernoulli trial probability of success");
DBL_ARG(p) ;
INT_OUTPUT(gsl_ran_geometric (r, p));
}
else if (NAME("gumbel1"))
{
ARGS(2, "a = order, b = scale parameter");
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_gumbel1 (r, a, b));
}
else if (NAME("gumbel2"))
{
ARGS(2, "a = order, b = scale parameter");
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_gumbel2 (r, a, b));
}
else if (NAME("hypergeometric"))
{
ARGS(3, "n1 = tagged population, n2 = untagged population, t = number of trials");
INT_ARG(n1) ;
INT_ARG(n2) ;
INT_ARG(t) ;
INT_OUTPUT(gsl_ran_hypergeometric (r, n1, n2, t));
}
else if (NAME("laplace"))
{
ARGS(1, "a = scale parameter");
DBL_ARG(a) ;
OUTPUT(gsl_ran_laplace (r, a));
}
else if (NAME("landau"))
{
ARGS(0, "no arguments required");
OUTPUT(gsl_ran_landau (r));
}
else if (NAME("levy"))
{
ARGS(2, "c = scale, a = power (1=cauchy, 2=gaussian)");
DBL_ARG(c) ;
DBL_ARG(a) ;
OUTPUT(gsl_ran_levy (r, c, a));
}
else if (NAME("levy-skew"))
{
ARGS(3, "c = scale, a = power (1=cauchy, 2=gaussian), b = skew");
DBL_ARG(c) ;
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_levy_skew (r, c, a, b));
}
else if (NAME("logarithmic"))
{
ARGS(1, "p = probability");
DBL_ARG(p) ;
INT_OUTPUT(gsl_ran_logarithmic (r, p));
}
else if (NAME("logistic"))
{
ARGS(1, "a = scale parameter");
DBL_ARG(a) ;
OUTPUT(gsl_ran_logistic (r, a));
}
else if (NAME("lognormal"))
{
ARGS(2, "zeta = location parameter, sigma = scale parameter");
DBL_ARG(zeta) ;
DBL_ARG(sigma) ;
OUTPUT(gsl_ran_lognormal (r, zeta, sigma));
}
else if (NAME("negative-binomial"))
{
ARGS(2, "p = probability, a = order");
DBL_ARG(p) ;
DBL_ARG(a) ;
INT_OUTPUT(gsl_ran_negative_binomial (r, p, a));
}
else if (NAME("pareto"))
{
ARGS(2, "a = power, b = scale parameter");
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_pareto (r, a, b));
}
else if (NAME("pascal"))
{
ARGS(2, "p = probability, n = order (integer)");
DBL_ARG(p) ;
INT_ARG(N) ;
INT_OUTPUT(gsl_ran_pascal (r, p, N));
}
else if (NAME("poisson"))
{
ARGS(1, "mu = scale parameter");
DBL_ARG(mu) ;
INT_OUTPUT(gsl_ran_poisson (r, mu));
}
else if (NAME("rayleigh"))
{
ARGS(1, "sigma = scale parameter");
DBL_ARG(sigma) ;
OUTPUT(gsl_ran_rayleigh (r, sigma));
}
else if (NAME("rayleigh-tail"))
{
ARGS(2, "a = lower limit, sigma = scale parameter");
DBL_ARG(a) ;
DBL_ARG(sigma) ;
OUTPUT(gsl_ran_rayleigh_tail (r, a, sigma));
}
else if (NAME("tdist"))
{
ARGS(1, "nu = degrees of freedom");
DBL_ARG(nu) ;
OUTPUT(gsl_ran_tdist (r, nu));
}
else if (NAME("weibull"))
{
ARGS(2, "a = scale parameter, b = exponent");
DBL_ARG(a) ;
DBL_ARG(b) ;
OUTPUT(gsl_ran_weibull (r, a, b));
}
else
{
fprintf(stderr,"Error: unrecognized distribution: %s\n", name) ;
}
return 0 ;
}
void Model::simulate(std::vector<double> & model_params, std::vector<std::string> & param_names, Trajectory * traj, int start_dt, int end_dt, double step_size, int total_dt, gsl_rng * rng) {
if ((traj->get_state(0)+traj->get_state(1)) < 1.0) {
return;
}
double R0_0=1.0;
double R0_1=1.0;
double R0_2=1.0;
double R0_3=1.0;
double R0_4=1.0;
double R0_5=1.0;
double R0_T0=0.0;
double R0_T1=100000.0;
double R0_T2=100000.0;
double R0_T3=100000.0;
double R0_T4=100000.0;
double k=1.0;
double alpha=1.0;
double scale=1.0;
// /* For slightly faster implementation, call parameters by index
for (int i=0; i!=param_names.size(); ++i) {
if (param_names[i]=="R0_0") R0_0 = model_params[i];
if (param_names[i]=="R0_1") R0_1 = model_params[i];
if (param_names[i]=="R0_2") R0_2 = model_params[i];
if (param_names[i]=="R0_3") R0_0 = model_params[i];
if (param_names[i]=="R0_4") R0_0 = model_params[i];
if (param_names[i]=="R0_5") R0_0 = model_params[i];
if (param_names[i]=="R0_T0") R0_T0 = model_params[i];
if (param_names[i]=="R0_T1") R0_T1 = model_params[i];
if (param_names[i]=="R0_T2") R0_T2 = model_params[i];
if (param_names[i]=="R0_T3") R0_T3 = model_params[i];
if (param_names[i]=="R0_T4") R0_T4 = model_params[i];
if (param_names[i]=="k") k = model_params[i];
if (param_names[i]=="alpha") alpha = model_params[i];
if (param_names[i]=="scale") scale = model_params[i];
}
double R0_now = 0.0;
double recoveries=0.0;
double new_infections=0.0;
double durI = 0.0;
double ran_unif_num1, ran_unif_num2;
if (custom_prob.size()==0) set_custom_prob(alpha, scale);
if (start_dt < step_size) { // Set initial number of infected
traj->resize_recoveries(total_dt);
int init_inf = (int)round(model_params[14]);
traj->set_state(init_inf, 0);
for (int i=0; i!=init_inf; ++i) {
// durI = gsl_ran_gamma(rng, alpha, scale);
ran_unif_num1 = gsl_ran_flat(rng, 0.0000001, 1);
ran_unif_num2 = gsl_ran_flat(rng, 0.0000001, 1);
durI = -log(ran_unif_num1)*scale-log(ran_unif_num2)*scale;
durI = (int)(durI/365.0/step_size);
traj->add_recovery_time(durI);
}
}
double num_infected = traj->get_state(0);
for (int t=start_dt; t<end_dt; ++t) {
//
// Transitions
//
// Recoveries: I --> R
recoveries = traj->num_recover_at(t-start_dt);
if (recoveries > 100000.0) { // If the epidemic is too large, set num_infected to 0, so that likelihood is 0.
num_infected = 0.0;
traj->set_traj(0.0, t-start_dt);
}
else if (recoveries > 0) {
traj->set_traj(recoveries, t-start_dt);
if (t*step_size<(R0_T0)) R0_now = R0_0;
else if (t*step_size<(R0_T1)) R0_now = R0_1;
else if (t*step_size<(R0_T2)) R0_now = R0_2;
else if (t*step_size<(R0_T3)) R0_now = R0_3;
else if (t*step_size<(R0_T4)) R0_now = R0_4;
else {
R0_now = R0_5;
}
new_infections = gsl_ran_negative_binomial(rng, k/(k+R0_now), k*recoveries);
if (new_infections > 1000) {
std::vector <unsigned int> a (106, 0);
gsl_ran_multinomial(rng, 106, (unsigned int)new_infections, &custom_prob[0], &a[0]);
for (int i=0; i!=a.size(); ++i) {
// durI = gsl_ran_gamma(rng, alpha, scale);
// ran_unif_num1 = gsl_rng_uniform_pos(rng);
// ran_unif_num2 = gsl_rng_uniform_pos(rng);
// durI = -log(ran_unif_num1)*scale-log(ran_unif_num2)*scale;
// durI = (int)(durI/365.0/step_size);
// durI = durI_vec[gsl_rng_uniform_int(rng, 1000)];
// traj->add_recovery_time(durI+t-start_dt);
traj->add_recovery_time(i+t-start_dt, a[i]);
}
}
else if (new_infections > 0) {
for (int i=0; i!=new_infections; ++i) {
ran_unif_num1 = gsl_rng_uniform_pos(rng);
ran_unif_num2 = gsl_rng_uniform_pos(rng);
durI = -log(ran_unif_num1)*scale-log(ran_unif_num2)*scale;
durI = (int)(durI/365.0/step_size);
traj->add_recovery_time(durI+t-start_dt);
}
}
num_infected += new_infections - recoveries;
}
double curr_coal_rate = 1.0/num_infected;
// Record 1/N for coalescent rate calculation
if (num_infected > 0.0) {
traj->set_traj2(curr_coal_rate*R0_now/(alpha*scale)*(1.0+1.0/k), t-start_dt);
}
else {
traj->set_traj2(0.0, t-start_dt);
break;
}
}
traj->set_state(num_infected, 0);
traj->delete_recoveries_before(end_dt-start_dt);
}
double
test_negative_binomial (void)
{
return gsl_ran_negative_binomial (r_global, 0.3, 20.0);
}
void SimulEpidNegBin(double VarDivMean, parameters *param, gsl_matrix *Incid, gsl_vector *Incid0)
{
// VarDivMean = Variance/Mean of the negative binomial considered
int k, t, g, i, s;
int tMin, tMax;
double lambda;
double prov;
int poiss;
for (k=0 ; k<param->NbGroups ; k++)
{
gsl_matrix_set(Incid,k,0,gsl_vector_get(Incid0,k));
}
for (i=0 ; i<param->p+1 ; i++)
{
if(i==0)
{
tMin=1;
}else
{
tMin=gsl_vector_get(param->tau,i-1);
}
if(i==param->p)
{
tMax=param->T;
}else
{
tMax=gsl_vector_get(param->tau,i);
}
for (t=tMin ; t<tMax ; t++)
{
//printf("t %d\n",t);
//fflush(stdout);
for(k=0 ; k<param->NbGroups ; k++)
{
//printf("k %d\n",k);
//fflush(stdout);
lambda=0;
for(g=0 ; g<param->NbGroups ; g++)
{
//printf("g %d\n",g);
//fflush(stdout);
prov=0;
for(s=1 ; s<=GSL_MIN(t,param->S) ; s++)
{
prov+=gsl_matrix_get(Incid,g,t-s)*gsl_matrix_get(param->GTdistr,g,s-1);
//printf("s %d %lg\n",s,prov);
//fflush(stdout);
}
prov*=gsl_matrix_get(param->K[i],g,k);
//printf("prov %lg\n",prov);
//fflush(stdout);
lambda+=prov;
//printf("lambda %lg\n",lambda);
//fflush(stdout);
}
poiss=gsl_ran_negative_binomial(rng,1/VarDivMean,lambda/(VarDivMean-1));
//printf("lambda %lg inci %d\n",lambda,poiss);
//fflush(stdout);
gsl_matrix_set(Incid,k,t,poiss);
}
}
}
}
void Model::simulate(std::vector<double> & model_params, std::vector<std::string> & param_names, Trajectory * traj, int start_dt, int end_dt, double step_size, int total_dt, gsl_rng * rng) {
if ((traj->get_state(1)+traj->get_state(2)) < 1.0) {
return;
}
double Beta = model_params[0];
double k=model_params[1];
double rateE2I=model_params[2];
double rateI2R=model_params[3];
double R0_reduce=model_params[6];
int change_T=model_params[7]/step_size;
double Rt = Beta/rateI2R*traj->get_state(0);
double total_infectious=0.0;
double new_infections=0.0;
double divisions = 3.0;
double p1 = rateE2I*step_size/divisions;
double p2 = rateI2R*step_size/divisions;
double S2E = 0.0;
double E2I = 0.0;
double I2R = 0.0;
double currS;
double latent;
double infectious;
double Tg = 1.0/rateE2I + 1.0/rateI2R;
// */
for (int t=start_dt; t<end_dt; ++t) {
double sub_t_I2R = 0.0;
for (int sub_t=0; sub_t<(int) divisions; ++sub_t) {
//
// Transitions
//
// Recoveries: I --> R
currS = traj->get_state(0);
latent = traj->get_state(1);
infectious = traj->get_state(2);
if (infectious > 0) {
if (p2 >= 1.0) I2R = infectious;
else if (use_deterministic) {
I2R = infectious*p2;
}
else {
I2R = gsl_ran_binomial(rng, p2, infectious); // Recoveries
}
}
// Becoming infectious: E --> I
if (latent > 0) {
if (p1 >= 1.0) E2I = latent;
else if (use_deterministic) {
E2I = latent * p1;
}
else {
E2I = gsl_ran_binomial(rng, p1, latent); // Becoming infectious
}
}
traj->set_state(infectious-I2R+E2I, 2); // Infectious
if (use_deterministic) {
S2E = Beta * currS * step_size * infectious;
} else {
// Infections: S --> E
if (I2R > 0.0) {
total_infectious += I2R;
sub_t_I2R += I2R;
// traj->set_traj(I2R, t-start_dt); // People are sampled, i.e. appear in the time-series at the time of recovery
if (currS > 0) {
// Current reproductive number
Rt = Beta / rateI2R * currS;
if (change_T>=t) Rt *= R0_reduce;
// Draw from the negative binomial distribution (gamma-poisson mixture) to determine
// number of secondary infections
S2E = gsl_ran_negative_binomial(rng, k/(k+Rt), k*I2R); // New infections
if (S2E > 0) {
S2E = std::min(currS, S2E);
new_infections += S2E;
traj->set_state(currS-S2E, 0); // Susceptible
}
}
}
}
traj->set_state(latent+S2E-E2I, 1); // Latent
S2E=0.0;
E2I=0.0;
I2R=0.0;
}
traj->set_traj(0, sub_t_I2R, t-start_dt);
double N = traj->get_state(1)+traj->get_state(2);
// Record 1/N for coalescent rate calculation
if (N > 0.0) {
traj->set_traj(1, N, t-start_dt);
traj->set_traj(2, Rt/Tg*(1.0+1.0/k), t-start_dt);
}
else {
traj->set_traj(1, 0.0, t-start_dt);
traj->set_traj(2, 0.0, t-start_dt);
break;
}
}
}
int sock_sim(double prior_r,double prior_p,double alpha,double beta,double obs_paired,double obs_odd,double *BigVector,int iter){
int nthreads;
//variables, gsl rng initiation
int i,j,match_count,n_picked;
unsigned int n_socks;
double prop_pairs,n_pairs,n_odd,prior_n;
double obs_total = obs_paired + obs_odd;
prior_n = prior_r - 1;
match_count = 0;
double temp_paired,temp_odd,temp_pairs;
//setup gsl random seed
const gsl_rng_type * T;
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc(T);
#pragma omp parallel for
for(i=0;i<iter;i++){
//sample, get n_pairs and n_odd
n_socks = gsl_ran_negative_binomial(r,prior_p,prior_n);
prop_pairs = gsl_ran_beta(r,alpha,beta);
n_pairs = round(floor(.5*n_socks)*prop_pairs);
n_odd = n_socks - 2*n_pairs;
//make generated population
double *gen_pop = (double *)malloc(sizeof(double)*n_socks);
for(j=0;j<n_pairs;j++){
gen_pop[2*j] = (double) j;
gen_pop[(2*j)+1] = (double) j;
}
for(j=2*n_pairs;j<n_socks;j++){
gen_pop[j]= (double) j;
}
//get generated sample size
if(obs_total <= n_socks){
n_picked = (int) obs_total;
}else{ n_picked = n_socks; }
//get sample vector
double *gen_samp = (double *)malloc(sizeof(double)*n_picked);
//count pairs
//sample from generated population
gsl_ran_choose(r,gen_samp,n_picked,gen_pop,n_socks,sizeof(double));
//sort sample
gsl_sort(gen_samp,1,n_picked);
//count the number of pairs/odd in sample
temp_pairs = 0.;
temp_odd = 1.;
for(j=1;j<n_picked;j++){
if(gen_samp[j] == gen_samp[j-1]){
temp_pairs = temp_pairs + 1;
temp_odd = temp_odd - 1;
continue;
}else{ temp_odd = temp_odd + 1; }
}
temp_paired = 2*temp_pairs;
//allocate big vector
BigVector[5*i] = (double) n_socks;
BigVector[(5*i) + 1] = n_pairs;
BigVector[(5*i) + 2] = n_odd;
BigVector[(5*i) + 3] = prop_pairs;
//counter
if(temp_odd==obs_odd && temp_paired==obs_paired){
match_count = match_count + 1;
BigVector[(5*i) + 4] = 1.;
continue;
}
else{
BigVector[(5*i) + 4] = 0.;
continue;
}
//free the temp allocated things
free(gen_pop);
free(gen_samp);
}
gsl_rng_free(r);
return(match_count);
}
