// pick an individual for reproduction
int studyPop::pickAMom() {
// This value will later be returned to determine the index of mom in "thePop"
int mom;
// this is used for fitness check in this function
double requiredFitness;
// use GSL to generate random numbers
const gsl_rng_type * T;
gsl_rng * r;
// Initialize the random number generator
T = gsl_rng_taus;
r = gsl_rng_alloc (T);
gsl_rng_set (r, gsl_rng_default_seed);
// pick different moms until one it passes fitness check
do {
mom = floor(gsl_ran_flat(r, -0.5, (POPULATION-1)+0.4999) + 0.5);
// change seed for better randomization
gsl_rng_default_seed += time(NULL)^mom;
gsl_rng_set (r, gsl_rng_default_seed);
requiredFitness = gsl_ran_flat(r, 0, 1);
} while(requiredFitness > (thePop.at(mom).get_fitness()/highestW));
gsl_rng_free(r);
return mom;
}
inline std::vector<std::size_t>
sample_individuals(const gsl_rng *r, const std::size_t N,
const uint_t N2, const bool with_replacement)
{
std::vector<std::size_t> rv;
for (std::size_t i = 0; i < N2; ++i)
{
std::size_t ind
= std::size_t(gsl_ran_flat(r, 0., double(N)));
if (!with_replacement)
{
while (std::find(rv.begin(), rv.end(), ind)
!= rv.end())
{
ind = std::size_t(
gsl_ran_flat(r, 0., double(N)));
}
}
rv.push_back(ind);
}
// sort in descending order
std::sort(rv.begin(), rv.end(),
[](size_t i, size_t j) noexcept { return i > j; });
return rv;
}
// pick an individual for reproduction with an outcrossing indiv
int studyPop::pickADad(int chosenMom) {
// This value will be returned to determine the index of dad in "thePop"
int dad;
// perform fitness check for outcrossing in dad
const gsl_rng_type * T;
gsl_rng * r;
gsl_rng_default_seed += time(NULL);
// Initialize the random number generator
T = gsl_rng_default;
r = gsl_rng_alloc (T);
gsl_rng_set (r, gsl_rng_default_seed);
double requiredFitnessToOutcross;
// pick different dad until one it passes fitness check & is also not the same as the mom chosen already
do {
do {
dad = floor(gsl_ran_flat(r, -0.5, (POPULATION-1)+0.4999) + 0.5);
} while(dad == chosenMom);
// change seed for more randomization
gsl_rng_default_seed += time(NULL)^dad;
gsl_rng_set (r, gsl_rng_default_seed);
requiredFitnessToOutcross = gsl_ran_flat(r, 0, 1);
} while(requiredFitnessToOutcross > (((1-K*thePop.at(dad).calcSelfingRate())*thePop.at(dad).get_fitness())/highestDadW));
// free up the memory taken by the random number generator
gsl_rng_free(r);
return dad;
}
int
EvidenceManager::populateRandIntegers(gsl_rng* r, int* randInds, INTINTMAP& populateFrom, int size)
{
double step=1.0/(double)size;
map<int,int> usedInit;
map<int,int> temp;
INTINTMAP_ITER tIter=populateFrom.begin();
for(int i=0;i<size;i++)
{
int tid=tIter->first;
temp[i]=tid;
tIter++;
}
for(int i=0;i<size;i++)
{
double rVal=gsl_ran_flat(r,0,1);
int rind=(int)(rVal/step);
while(usedInit.find(rind)!=usedInit.end())
{
rVal=gsl_ran_flat(r,0,1);
rind=(int)(rVal/step);
}
usedInit[rind]=0;
randInds[i]=temp[rind];
}
usedInit.clear();
return 0;
}
void gendy3_constructor(t_gendyn *x){
x->g_freqMul = 1.f / sys_getsr();
x->g_phase = 1.f; //should immediately decide on new target
x->g_amp = 0.0;
x->g_nextAmp = 0.0;
x->g_nextPhase = 0.0;
x->g_lastPhase = 0.0;
x->g_interpMult = 1.0;
x->g_speed = 100;
x->g_freq = 440.f;
x->g_memorySize = 12;//(int) ZIN0(7);
if(x->g_memorySize < 1) x->g_memorySize = 1;
x->g_index = 0;
x->g_memoryAmp= (float *)calloc(x->g_memorySize, sizeof(float));
x->g_memoryDur= (float *)calloc(x->g_memorySize, sizeof(float));
//one more in amp list for guard (wrap) element
x->g_ampList= (float *)calloc((x->g_memorySize + 1), sizeof(float));
x->g_phaseList= (double *)calloc((x->g_memorySize + 1), sizeof(double));
//initialise to zeroes and separations
int i = 0;
for(i = 0; i < x->g_memorySize; ++i) {
x->g_memoryAmp[i] = 2 * gsl_ran_flat(x->g_rng, 0., 1.) - 1.0;
x->g_memoryDur[i] = gsl_ran_flat(x->g_rng, 0., 1.);
x->g_ampList[i] = 2 * gsl_ran_flat(x->g_rng, 0., 1.) - 1.0;
x->g_phaseList[i] = 1.0; //will be intialised immediately
}
x->g_memoryAmp[0] = 0.0; //always zeroed first BP
}
void gendy2_constructor(t_gendyn *x){
x->g_freqMul = 1.f / sys_getsr();
x->g_phase = 1.f; //should immediately decide on new target
x->g_amp = 0.0;
x->g_nextAmp = 0.0;
x->g_speed = 100;
x->g_memorySize = 12; //default is 12
//printf("memsize %d %f", x->g_MemorySize, ZIN0(8));
if(x->g_memorySize < 1) x->g_memorySize = 1;
x->g_index = 0;
x->g_memoryAmp = (float *)calloc(x->g_memorySize, sizeof(float));
x->g_memoryDur = (float *)calloc(x->g_memorySize, sizeof(float));
x->g_memoryAmpStep = (float *)calloc(x->g_memorySize, sizeof(float));
x->g_memoryDurStep = (float *)calloc(x->g_memorySize, sizeof(float));
//initialise to zeroes and separations
int i = 0;
for(i = 0; i < x->g_memorySize; ++i) {
x->g_memoryAmp[i] = 2 * gsl_ran_flat(x->g_rng, 0, 1) - 1.0;
x->g_memoryDur[i] = gsl_ran_flat(x->g_rng, 0, 1);
x->g_memoryAmpStep[i] = 2 * gsl_ran_flat(x->g_rng, 0, 1) - 1.0;
x->g_memoryDurStep[i] = 2 * gsl_ran_flat(x->g_rng, 0, 1) - 1.0;
}
}
static void spawn_particle(dust_particle_t * particle)
{
// setup new particle
particle->pos.x = gsl_ran_flat(rng, MIN_POS_X, MAX_POS_X);
particle->pos.y = gsl_ran_flat(rng, MIN_POS_Y, MAX_POS_Y);
particle->pos.z = gsl_ran_flat(rng, MIN_POS_Z, MAX_POS_Z);
particle->vel.x = true_wind.x;
particle->vel.y = true_wind.y;
particle->vel.z = true_wind.z;
}
void initialize_prior(PARAM *param, PRIOR *prior, DATA *data, const gsl_rng *r) {
int i;
float mean;
double MAXC = ((double) _MAX_COMP_);
prior->m_beta = 0.0;
prior->v_beta = 100.0;
prior->atrue = 0.1;
prior->afalse = 1.0 - prior->atrue;
prior->rho_alpha_prey = 1.0;
prior->m_alpha_prey = 0.0;
prior->v_alpha_prey = 100.0;
for(i=0;i<_MAX_COMP_;i++) prior->gamma_alpha_prey[i] = 1.0 / MAXC;
for(i=0;i<_MAX_COMP_;i++) prior->theta_alpha_prey[i] = gsl_ran_gaussian(r, 2.0);
for(i=0;i<data->nprey;i++) prior->w_alpha_prey[i] = ((int) gsl_ran_flat(r,0.0,MAXC));
mean = 0.0;
for(i=0;i<_MAX_COMP_;i++) mean += prior->gamma_alpha_prey[i] * prior->theta_alpha_prey[i];
for(i=0;i<_MAX_COMP_;i++) prior->theta_alpha_prey[i] -= mean;
prior->rho_alpha_IP = 1.0;
prior->m_alpha_IP = 0.0;
prior->v_alpha_IP = 100.0;
for(i=0;i<_MAX_COMP_;i++) prior->gamma_alpha_IP[i] = 1.0 / MAXC;
/* for(i=0;i<_MAX_COMP_;i++) prior->theta_alpha_IP[i] = gsl_ran_gaussian(r, 2.0); */
for(i=0;i<_MAX_COMP_;i++) prior->theta_alpha_IP[i] = 0.0;
/* for(i=0;i<data->nIP;i++) prior->w_alpha_IP[i] = ((int) gsl_ran_flat(r,0.0,MAXC)); */
for(i=0;i<data->nIP;i++) prior->w_alpha_IP[i] = 0;
mean = 0.0;
for(i=0;i<_MAX_COMP_;i++) mean += prior->gamma_alpha_IP[i] * prior->theta_alpha_IP[i];
for(i=0;i<_MAX_COMP_;i++) prior->theta_alpha_IP[i] -= mean;
prior->rho_mu = 1.0;
prior->m_mu = 0.0;
prior->v_mu = 100.0;
for(i=0;i<_MAX_COMP_;i++) prior->gamma_mu[i] = 1.0 / MAXC;
for(i=0;i<_MAX_COMP_;i++) prior->theta_mu[i] = gsl_ran_gaussian(r, 2.0);
for(i=0;i<data->nprey;i++) prior->w_mu[i] = ((int) gsl_ran_flat(r,0.0,MAXC));
mean = 0.0;
for(i=0;i<_MAX_COMP_;i++) mean += prior->gamma_mu[i] * prior->theta_mu[i];
for(i=0;i<_MAX_COMP_;i++) prior->theta_mu[i] -= mean;
prior->rho_eta = 1.0;
prior->mean_eta = 0.1;
for(i=0;i<_MAX_COMP_;i++) prior->gamma_eta[i] = 1.0 / MAXC;
for(i=0;i<_MAX_COMP_;i++) prior->theta_eta[i] = gsl_ran_exponential(r, prior->mean_eta) + 1.0;
for(i=0;i<data->nprey;i++) prior->w_eta[i] = ((int) gsl_ran_flat(r,0.0,MAXC));
prior->rho_eta0 = 1.0;
prior->mean_eta0 = 0.1;
for(i=0;i<_MAX_COMP_;i++) prior->gamma_eta0[i] = 1.0 / MAXC;
for(i=0;i<_MAX_COMP_;i++) prior->theta_eta0[i] = gsl_ran_exponential(r, prior->mean_eta0) + 1.0;
for(i=0;i<data->nprey;i++) prior->w_eta0[i] = ((int) gsl_ran_flat(r,0.0,MAXC));
}
void studyPop::addMutationToImmunityGenes(int whichLocus) {
int avgNumberOfHostMutations = 2*POPULATION*U_HOST_IMMUNITY;
int numOfHostMutations;
// GSL objects to generate random numbers
const gsl_rng_type * T;
gsl_rng * r;
gsl_rng_default_seed += time(NULL);
T = gsl_rng_default;
r = gsl_rng_alloc (T);
gsl_rng_set(r, gsl_rng_default_seed);
numOfHostMutations = gsl_ran_poisson(r,avgNumberOfHostMutations);
// Find the alleles in the population to be mutated
vector<int> indexOfMutations;
for(int i=0; i<numOfHostMutations ;) {
gsl_rng_default_seed += time(NULL);
gsl_rng_set(r, gsl_rng_default_seed);
int tempIndex = floor(gsl_ran_flat(r, -0.5, (POPULATION-1)+0.4999) + 0.5);
int q=0;
for(; q<indexOfMutations.size() ; q++) {
if(indexOfMutations.at(q) == tempIndex)
break;
}
if(q==indexOfMutations.size()) {
indexOfMutations.push_back(tempIndex);
i++;
}
}
// Now we apply mutations to indiv with indices found above
for(int i=0; i<indexOfMutations.size() ; i++) {
gsl_rng_default_seed += time(NULL);
gsl_rng_set(r, gsl_rng_default_seed);
int whichAllele = floor(gsl_ran_flat(r, -0.5, 1.4999) + 0.5);
if(whichLocus == 1) {
thePop.at(indexOfMutations.at(i)).immunityGeneA[(int) whichAllele] += 1;
thePop.at(indexOfMutations.at(i)).immunityGeneA[(int) whichAllele] %= 2;
}
else if(whichLocus == 2) {
thePop.at(indexOfMutations.at(i)).immunityGeneB[(int) whichAllele] += 1;
thePop.at(indexOfMutations.at(i)).immunityGeneB[(int) whichAllele] %= 2;
}
}
gsl_rng_default_seed += time(NULL);
// free up the space taken by the random number generator
gsl_rng_free(r);
}
void AlexSim::burstCoincidenceDonor(double scale)
{
double tstart=t;
double burstDurationSample=gsl_ran_lognormal(r, mu, sigma);
double tend = tstart + burstDurationSample;
double tCoincidenceStart=gsl_ran_flat(r, tstart, tend);
double tCoincidenceEnd=gsl_ran_flat(r, tCoincidenceStart, tend);
qDebug()<<"burst at"<<t*1e3<<"ms for"<<burstDurationSample*1e3<<"ms. Donor coincidence after"<<(tCoincidenceStart-tstart)*1e3<<"ms for"<<(tCoincidenceEnd-tCoincidenceStart)*1e3<<"ms with scale parameter"<<scale;
Photons photonsTemp;
photonsTemp<<burst(tstart, tend);
photonsTemp<<donorOnly(tCoincidenceStart,tCoincidenceEnd);
photonsTemp.sort();
photons<<photonsTemp;
}
static int WARN_UNUSED
mutgen_generate_record_mutations(mutgen_t *self, coalescence_record_t *cr)
{
int ret = -1;
size_t k, l, branch_mutations;
double branch_length, position, mu;
double distance = cr->right - cr->left;
uint32_t child;
self->times[cr->node] = cr->time;
for (k = 0; k < cr->num_children; k++) {
child = cr->children[k];
branch_length = cr->time - self->times[child];
mu = branch_length * distance * self->mutation_rate;
branch_mutations = gsl_ran_poisson(self->rng, mu);
for (l = 0; l < branch_mutations; l++) {
position = gsl_ran_flat(self->rng, cr->left, cr->right);
assert(cr->left <= position && position < cr->right);
ret = mutgen_add_mutation(self, child, position);
if (ret != 0) {
goto out;
}
}
}
ret = 0;
out:
return ret;
}
double checkReactions(gsl_vector *haz, gsl_vector *residuals, gsl_vector *fast_params,
double deltat, gsl_vector *sps, gsl_matrix *PostPre)
{
int i;
double small_residual = -1000000.0;
double total_hazard = 0.0;
for(i=0; i < fast_params->size; i++) {
if(checkHazard(haz, PostPre, sps, i, deltat) &&
checkSpecies(PostPre, sps, i)) {
VSET(residuals, i, small_residual);
} else if(VGET(residuals, i) < (small_residual + 10000)) {
total_hazard += VGET(haz, i);
VSET(residuals, i, log(gsl_ran_flat(r, 0.0, 1.0)));
VSET(fast_params, i, 0.0);
// running_totals1[i]++;
} else {
total_hazard += VGET(haz, i);
VSET(fast_params, i, 0.0);
// running_totals1[i]++;
}
//printf("%d ", running_totals1[i]);
}
// printf("\n");
return total_hazard;
}
int gslalg_rng_flat_VM ( Word* args, Word& result,
int message, Word& local, Supplier s )
{
result = qp->ResultStorage( s );
CcReal *res = ((CcReal*) result.addr);
double resD = 0;
CcReal *cA = (CcReal*) args[0].addr;
CcReal *cB = (CcReal*) args[1].addr;
if( cA->IsDefined() && cB->IsDefined() )
{
double a = cA->GetRealval();
double b = cB->GetRealval();
if( a <= b )
{
resD = gsl_ran_flat(the_gsl_randomgenerator.GetGenerator(), a, b);
res->Set(true, resD);
}
else
{
res->Set(false, 0);
}
}
else
res->Set(false, 0);
return (0);
}
static PyObject *
uniform(PyObject *self, PyObject *args, PyObject *kwrds)
{
matrix *obj;
int i, nrows, ncols = 1;
double a = 0, b = 1;
char *kwlist[] = {"nrows", "ncols", "a", "b", NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwrds, "i|idd", kwlist,
&nrows, &ncols, &a, &b)) return NULL;
if (a>b) PY_ERR(PyExc_ValueError, "a must be less than b");
if ((nrows<0) || (ncols<0))
PY_ERR_TYPE("dimensions must be non-negative");
if (!(obj = (matrix *)Matrix_New(nrows, ncols, DOUBLE)))
return PyErr_NoMemory();
gsl_rng_env_setup();
rng_type = gsl_rng_default;
rng = gsl_rng_alloc (rng_type);
gsl_rng_set(rng, seed);
for (i= 0; i < nrows*ncols; i++)
MAT_BUFD(obj)[i] = gsl_ran_flat (rng, a, b);
seed = gsl_rng_get (rng);
gsl_rng_free(rng);
return (PyObject *)obj;
}
double RandomNumberGenerator::triangular(double min, double max, double fmin, double fmax){
double u = gsl_ran_flat(r,0,1);
double ratio = (fmax/fmin);
double slope = (sqrt(1.0+(pow(ratio,2.0)-1.0)*u)-1.0)/(ratio-1.0);
return slope*(max-min)+min;
}
std::vector<int> sfs_from_sample(GSLrng_t * rng,const singlepop_t * pop,const unsigned & nsam)
{
map<double,unsigned> mutfreqs;
unsigned twoN = 2*pop->N;
for( unsigned i = 0 ; i < nsam ; ++i )
{
//pick a random chrom (w/replacement...)
unsigned chrom = unsigned(gsl_ran_flat(rng->get(),0.,double(twoN)));
//get pointer to that chrom from the individual
auto gamete = (chrom%2==0.) ? pop->diploids[chrom/2].first : pop->diploids[chrom/2].second;
//In this example, there are only neutral mutations, so that's what we'll iterate over
for( auto m = gamete->mutations.begin() ; m != gamete->mutations.end() ; ++m )
{
auto pos_itr = mutfreqs.find( (*m)->pos );
if( pos_itr == mutfreqs.end() )
{
mutfreqs.insert(std::make_pair((*m)->pos,1));
}
else
{
pos_itr->second++;
}
}
}
//Now, fill in the SFS, omitting positions that are fixed in the sample
std::vector<int> __rv(nsam-1,0u);
for( const auto & __x : mutfreqs )
{
if (__x.second < nsam) __rv[__x.second-1]++;
}
return __rv;
}
void DP_eta_theta(PARAM *param, PRIOR *prior, DATA *data, const gsl_rng *r, int pid, int *inuse) {
int i, j, id, accept;
float Delta, mhratio, newval, scale, tmp_lambda, tmp;
scale = prior->gamma_eta[pid] / (1.0 - prior->gamma_eta[pid]);
if(inuse[pid] == 0) {
newval = gsl_ran_exponential(r, prior->mean_eta) + 1.0;
Delta = newval - prior->theta_eta[pid];
prior->theta_eta[pid] = newval;
}
else {
/* metropolis-hastings */
mhratio = 0.0;
Delta = gsl_ran_gaussian(r, 1.0);
if(prior->theta_eta[pid] + Delta <= 1.0 || prior->theta_eta[pid] + Delta > 100.0) {
accept = 0;
}
else {
for(i=0;i<data->nprey;i++) {
if(prior->w_eta[i] == pid) {
for(j=0;j<data->preyNinter[i];j++) {
id = data->p2i[i][j];
if(param->Z[data->a2u[id]] && data->d[id] > 0.0) {
tmp_lambda = param->lambda_true[id];
// else tmp_lambda = param->lambda_false[id];
/* if(param->Z[data->a2u[id]]) */
tmp = data->d[id] < exp(param->lambda_false[id]) && param->lambda_false[id] < param->lambda_true[id] ? exp(param->lambda_false[id]) : data->d[id];
if(lowMode) {
mhratio += log_poisson_g_prop(GSL_MIN(_LM_,data->d[id]), exp(tmp_lambda), prior->theta_eta[pid]+Delta)
- log_poisson_g_prop(GSL_MIN(_LM_,data->d[id]), exp(tmp_lambda), prior->theta_eta[pid]);
}
else {
mhratio += log_poisson_g_prop(data->d[id], exp(tmp_lambda), prior->theta_eta[pid]+Delta)
- log_poisson_g_prop(data->d[id], exp(tmp_lambda), prior->theta_eta[pid]);
}
/* mhratio += log_poisson_g_prop(tmp, exp(tmp_lambda), prior->theta_eta[pid]+Delta)
- log_poisson_g_prop(tmp, exp(tmp_lambda), prior->theta_eta[pid]); */
}
}
}
}
mhratio += log(gsl_ran_exponential_pdf(prior->theta_eta[pid]+Delta-1.0, prior->mean_eta))
- log(gsl_ran_exponential_pdf(prior->theta_eta[pid]-1.0, prior->mean_eta));
// mhratio += -2.0 * (log(prior->theta_eta[pid]+ Delta) - log(prior->theta_eta[pid]));
accept = gsl_ran_flat(r, 0.0, 1.0) <= GSL_MIN(1.0, exp(mhratio)) ? 1 : 0 ;
}
/* if accepted, update param and lambda */
if(accept) {
prior->theta_eta[pid] += Delta;
for(i=0;i<data->nprey;i++) {
if(prior->w_eta[i] == pid) {
param->eta[i] += Delta;
}
}
}
}
}
double sample_lambda_doublepareto(const gsl_rng *random, double *beta,
int dk_rows, int *dk_rowbreaks, int *dk_cols, double *dk_vals,
double a, double b,
double lam0, double gamma, double lam_walk_stdev)
{
int i;
double lam1;
double sum_term;
double dotprod;
double accept_ratio;
double log_accept_ratio;
int prev_break;
lam1 = gsl_sf_exp(gsl_ran_gaussian(random, lam_walk_stdev) + gsl_sf_log(lam0));
/* Lambda as an inverse scale parameter */
sum_term = 0;
prev_break = 0;
for (i = 0; i < dk_rows; i++){
dotprod = fabs(vec_dot_beta(dk_rowbreaks[i] - prev_break, dk_cols + prev_break, dk_vals + prev_break, beta));
sum_term += gsl_sf_log(1 + lam1 * dotprod / gamma) - gsl_sf_log(1 + lam0 * dotprod / gamma);
prev_break = dk_rowbreaks[i];
}
log_accept_ratio = (a - 1 + dk_rows) * (gsl_sf_log(lam1) - gsl_sf_log(lam0)) - b * (lam1 - lam0) - (gamma + 1) * sum_term;
if(log_accept_ratio < -20)
return lam0;
else if(log_accept_ratio > 0)
return lam1;
accept_ratio = gsl_sf_exp(log_accept_ratio);
if (gsl_ran_flat(random, 0, 1) <= accept_ratio)
return lam1;
return lam0;
}
void ic(double *x, double a, double b, params *p, gsl_rng *rg)
//initial conditions
{
int i;
for (i = 0; i < p->paths; ++i)
x[i] = gsl_ran_flat(rg, a, b);
}
double adapted_jump(int *pcd, double dt, params *p, gsl_rng *rg)
{
double ret = 0.0;
if (p->Dp != 0.0) {
double comp = sqrt((p->Dp)*(p->lambda))*dt;
if (*pcd <= 0) {
double ampmean = sqrt((p->lambda)/(p->Dp));
double r = gsl_ran_flat(rg,0,1);
//magic...
//npcd = (int) floor( -log( curand_uniform(l_state) )/lambda/dt + 0.5 );
*pcd = (int)roundf(-log(r)/(p->lambda)/dt);
if (p->biased)
ret = -log(r)/ampmean - comp;
else
ret = -log(r)/ampmean;
}
else{
*pcd--;
if (p->biased)
ret = -comp;
else
ret = 0.0;
}
}
return ret;
}
int
EvidenceManager::populateRandIntegers(gsl_rng* r, INTINTMAP& randInds,int size, int subsetsize)
{
double step=1.0/(double)size;
for(int i=0;i<subsetsize;i++)
{
double rVal=gsl_ran_flat(r,0,1);
int rind=(int)(rVal/step);
while(randInds.find(rind)!=randInds.end())
{
rVal=gsl_ran_flat(r,0,1);
rind=(int)(rVal/step);
}
randInds[rind]=0;
}
return 0;
}
static double random_string_cusp_fhigh(double flow, double fhigh, gsl_rng *rng)
{
const double thetasqmin = pow(fhigh, -2.0 / 3.0);
const double thetasqmax = pow(flow, -2.0 / 3.0);
const double thetasq = gsl_ran_flat(rng, thetasqmin, thetasqmax);
return pow(thetasq, -3.0 / 2.0);
}
void sample_likelihood_poisson(const gsl_rng *random,
int n, int *obs,
int *dk_rowbreaks, int *dk_cols, double *dk_vals,
double *s, int **coefs, int *coef_breaks,
double *beta)
{
int i;
int j;
int k;
int row;
int j_idx;
double a;
double lower;
double upper;
double left;
double right;
for(j = 0; j < n; j++)
{
if (obs[j] > 0){
lower = lex_ran_flat(random, 0, gsl_sf_exp(obs[j]*beta[j]));
lower = gsl_sf_log(lower) / (double)obs[j];
} else {
lower = -INFINITY;
}
upper = lex_ran_flat(random, 0, beta[j] < -160 ? 1 : gsl_sf_exp(-gsl_sf_exp(beta[j])));
upper = gsl_sf_log(-gsl_sf_log(upper));
/* Bound the sampling range */
for (i = 0; i < coef_breaks[j]; i++)
{
/* current row that has a non-zero value for column j */
row = coefs[j][i];
/* Calculate Dk[i].dot(b_notj), the inner product of the i'th row
and the beta vector, excluding the j'th column. */
a = 0;
for (k = row == 0 ? 0 : dk_rowbreaks[row-1]; k < dk_rowbreaks[row]; k++){
if (dk_cols[k] == j){
j_idx = k;
} else{
a += dk_vals[k] * beta[dk_cols[k]];
}
}
/* Find the left and right bounds */
left = (-s[row] - a) / dk_vals[j_idx];
right = (s[row] - a) / dk_vals[j_idx];
if (dk_vals[j_idx] >= 0){
lower = MAX(lower, left);
upper = MIN(upper, right);
} else {
lower = MAX(lower, right);
upper = MIN(upper, left);
}
}
beta[j] = gsl_ran_flat(random, lower, upper);
}
}
/**
* The key is to understand that: X_resampled[j] = X[select[j]] so select
* give the index of the resample ancestor...
* The ancestor of particle j is select[j]
*
* With n index: X[n+1][j] = X[n][select[n][j]]
*
* Other caveat: D_J_p_X are in [N_DATA+1] ([0] contains the initial conditions)
* select is in [N_DATA], times is in [N_DATA]
*/
void ssm_sample_traj_print(FILE *stream, ssm_X_t ***D_J_X, ssm_par_t *par, ssm_nav_t *nav, ssm_calc_t *calc, ssm_data_t *data, ssm_fitness_t *fitness, const int index)
{
int j_sel;
int n, nn, indn;
double ran, cum_weights;
ssm_X_t *X_sel;
ran=gsl_ran_flat(calc->randgsl, 0.0, 1.0);
j_sel=0;
cum_weights=fitness->weights[0];
while (cum_weights < ran) {
cum_weights += fitness->weights[++j_sel];
}
//print traj of ancestors of particle j_sel;
//!!! we assume that the last data point contain information'
X_sel = D_J_X[data->n_obs][j_sel]; // N_DATA-1 <=> data->indn_data_nonan[N_DATA_NONAN-1]
ssm_print_X(stream, X_sel, par, nav, calc, data->rows[data->n_obs-1], index);
//printing all ancesters up to previous observation time
for(nn = (data->ind_nonan[data->n_obs_nonan-1]-1); nn > data->ind_nonan[data->n_obs_nonan-2]; nn--) {
X_sel = D_J_X[ nn + 1 ][j_sel];
ssm_print_X(stream, X_sel, par, nav, calc, data->rows[nn], index);
}
for(n = (data->n_obs_nonan-2); n >= 1; n--) {
//indentifying index of the path that led to sampled particule
indn = data->ind_nonan[n];
j_sel = fitness->select[indn][j_sel];
X_sel = D_J_X[ indn + 1 ][j_sel];
ssm_print_X(stream, X_sel, par, nav, calc, data->rows[indn], index);
//printing all ancesters up to previous observation time
for(nn= (indn-1); nn > data->ind_nonan[n-1]; nn--) {
X_sel = D_J_X[ nn + 1 ][j_sel];
ssm_print_X(stream, X_sel, par, nav, calc, data->rows[nn], index);
}
}
indn = data->ind_nonan[0];
j_sel = fitness->select[indn][j_sel];
X_sel = D_J_X[indn+1][j_sel];
for(nn=indn; nn>=0; nn--) {
X_sel = D_J_X[ nn + 1 ][j_sel];
ssm_print_X(stream, X_sel, par, nav, calc, data->rows[nn], index);
}
//TODO nn=-1 (for initial conditions)
}
void fill_random_vector(gsl_rng* rgen)
{
for (int i = 0; i< _size ; i++) {
float tmp =float(gsl_ran_flat(rgen, 0, 1));
setValue(i, tmp);
std::cout << tmp << " ";
}
std::cout << std::endl;
}
double* rough_box_prepareAdditionalParams(gsl_rng* rng, double roughness, double shift){
const int order = 20;
double* res = new double[order * 2 + 2];
for (int i = 0; i < 2 * order; i++){
res[i] = gsl_ran_flat(rng, 0.0, 2.0*M_PI);
}
res[2 * order] = roughness;
res[2 * order + 1] = shift;
return res;
}
int
EvidenceManager::populateRandIntegers(gsl_rng* r, vector<int>& randInds,int size, int subsetsize)
{
double step=1.0/(double)size;
map<int,int> usedInit;
for(int i=0;i<subsetsize;i++)
{
double rVal=gsl_ran_flat(r,0,1);
int rind=(int)(rVal/step);
while(usedInit.find(rind)!=usedInit.end())
{
rVal=gsl_ran_flat(r,0,1);
rind=(int)(rVal/step);
}
usedInit[rind]=0;
randInds.push_back(rind);
}
return 0;
}
double draw_gamma_or_uniform(const gsl_rng * rng, double shape, double scale) {
double draw;
if ((shape > 0.0) && (scale > 0.0)) {
draw = gsl_ran_gamma(rng, shape,
scale);
}
else {
double tau_a, tau_b;
tau_a = fabs(shape);
tau_b = fabs(scale);
if (tau_a < tau_b) {
draw = gsl_ran_flat(rng, tau_a, tau_b);
}
else {
draw = gsl_ran_flat(rng, tau_b, tau_a);
}
}
return draw;
}
void librdist_uniform(gsl_rng *rng, int argc, void *argv, int bufc, float *buf){
t_atom *av = (t_atom *)argv;
if(argc != librdist_getnargs(ps_uniform)){
return;
}
const double a = librdist_atom_getfloat(av);
const double b = librdist_atom_getfloat(av + 1);
int i;
for(i = 0; i < bufc; i++)
buf[i] = (float)gsl_ran_flat(rng, a, b);
}
extern double dist_uniform(struct _flow *flow, const double minval,
const double maxval)
{
#ifdef HAVE_LIBGSL
gsl_rng * r = flow->r;
return gsl_ran_flat(r, minval, maxval);
#else
const double x = rn_uniform_zero_to_one(flow);
return ((maxval-minval) * x) + minval;
#endif /* HAVE_LIBGSL */
}
