void gen_rand_state_synth(double *const x, unsigned int N, gsl_rng *r, TMCMCParams ¶ms) { assert(N == 1 + params.N_DM + 4*params.N_stars); // R_V x[0] = 3.1 + gsl_ran_gaussian_ziggurat(r, 0.2); // Delta_EBV for(size_t i=0; i<params.N_DM; i++) { x[i+1] = params.data->EBV / (double)params.N_DM * gsl_ran_chisq(r, 1.); } // Stars TSED sed_tmp(true); for(size_t i = 1 + params.N_DM; i < 1 + params.N_DM + 4*params.N_stars; i += 4) { // DM x[i] = 5. + 13. * gsl_rng_uniform(r); // Stellar type double logMass, logtau, FeH, tau; bool in_lib = false; while(!in_lib) { logMass = gsl_ran_gaussian_ziggurat(r, 0.5); tau = -1.; while(tau <= 0.) { tau = 1.e9 * (5. + gsl_ran_gaussian_ziggurat(r, 2.)); } logtau = log10(tau); FeH = -1.0 + gsl_ran_gaussian_ziggurat(r, 1.); in_lib = params.synth_stellar_model->get_sed(logMass, logtau, FeH, sed_tmp); } x[i+1] = logMass; x[i+2] = logtau; x[i+3] = FeH; } }
std::vector<double> Random::normal3D() { std::vector<double> randomArray = {0.,0.,0.}; randomArray[0] = gsl_ran_gaussian_ziggurat(this->randomGeneratorHandle,1.0); randomArray[1] = gsl_ran_gaussian_ziggurat(this->randomGeneratorHandle,1.0); randomArray[2] = gsl_ran_gaussian_ziggurat(this->randomGeneratorHandle,1.0); return randomArray; }
int DPMHC_K(struct str_DPMHC *ptr_DPMHC_data) { int i_K = ptr_DPMHC_data->i_K; gsl_vector *v_u = ptr_DPMHC_data->v_u; gsl_vector *v_v = ptr_DPMHC_data->v_v; gsl_vector *v_w = ptr_DPMHC_data->v_w; gsl_matrix *m_DPtheta = ptr_DPMHC_data->m_DPtheta; double d_DPalpha = ptr_DPMHC_data->d_DPalpha; int K_tmp, K_new,j; double a,v_j,w_j,csum,min_u; //gsl_vector_view theta_j; //int k_asset_number = P -> size1; /* number of assets in model */ K_tmp = i_K; min_u = gsl_vector_min ( v_u ); a = 1.0 - min_u; if( a == 1.0 ) printf("**********min_u = %g *************\n",min_u); csum = 0.0; j=0; while ( csum <= a ){ /* check if new v_j,w_j and theta_j should be generated */ if( j >= K_tmp ){ v_j = gsl_ran_beta ( rng , 1.0, d_DPalpha ); vset( v_v, j, v_j); w_j = v_j * (vget( v_w, j-1 )/vget(v_v,j-1))*(1.0-vget(v_v,j-1)); vset( v_w, j, w_j); /* generate new mu, xi, tau from prior G_0 */ mset(m_DPtheta, j, 0, ptr_DPMHC_data->d_m0 + gsl_ran_gaussian_ziggurat(rng, sqrt(ptr_DPMHC_data->d_s2m))); mset(m_DPtheta, j, 1, gsl_ran_gaussian_ziggurat(rng, ptr_DPMHC_data->d_A)); mset(m_DPtheta, j, 2, gsl_ran_gamma(rng, 0.5, 0.5) ); } csum += vget(v_w,j); K_new = j + 1; j++; } ptr_DPMHC_data->i_K = K_new; return 0; }
void gslu_rand_gaussian_matrix (const gsl_rng *r, gsl_matrix *A, const gsl_vector *mu, const gsl_matrix *Sigma, const gsl_matrix *L) { assert (A->size1 == mu->size && (Sigma || L)); for (size_t i=0; i<A->size1; i++) for (size_t j=0; j<A->size2; j++) gsl_matrix_set (A, i, j, gsl_ran_gaussian_ziggurat (r, 1.0)); if (L) { assert (L->size1 == L->size2 && L->size1 == mu->size); gsl_blas_dtrmm (CblasLeft, CblasLower, CblasNoTrans, CblasNonUnit, 1.0, L, A); } else { assert (Sigma->size1 == Sigma->size2 && Sigma->size1 == mu->size); gsl_matrix *_L = gsl_matrix_alloc (Sigma->size1, Sigma->size2); gsl_matrix_memcpy (_L, Sigma); gsl_linalg_cholesky_decomp (_L); gsl_blas_dtrmm (CblasLeft, CblasLower, CblasNoTrans, CblasNonUnit, 1.0, _L, A); gsl_matrix_free (_L); } for (size_t j=0; j<A->size2; j++) { gsl_vector_view a = gsl_matrix_column (A, j); gsl_vector_add (&a.vector, mu); } }
void gen_rand_state_indiv_emp(double *const x, unsigned int N, gsl_rng *r, TMCMCParams ¶ms) { if(params.vary_RV) { assert(N == 5); } else { assert(N == 4); } // Stars TSED sed_tmp(true); // E(B-V) //x[0] = 3. * gsl_rng_uniform(r); x[0] = 1.5 * params.data->EBV * gsl_rng_uniform(r); // DM x[1] = 6. + 12. * gsl_rng_uniform(r); // Stellar type double Mr, FeH; Mr = -0.5 + 15.5 * gsl_rng_uniform(r); FeH = -2.45 + 2.4 * gsl_rng_uniform(r); x[2] = Mr; x[3] = FeH; if(params.vary_RV) { double RV = -1.; while((RV <= 2.1) || (RV >= 5.)) { RV = params.RV_mean + gsl_ran_gaussian_ziggurat(r, 1.5*params.RV_variance*params.RV_variance); } x[4] = RV; } }
// Draw a normal varariate from a covariance matrix. The square-root of the covariance (as defined in sqrt_matrix) must be provided. void draw_from_cov(double* x, const gsl_matrix* sqrt_cov, unsigned int N, gsl_rng* r) { double tmp; for(unsigned int i=0; i<N; i++) { x[i] = 0.; } for(unsigned int j=0; j<N; j++) { tmp = gsl_ran_gaussian_ziggurat(r, 1.); for(unsigned int i=0; i<N; i++) { x[i] += gsl_matrix_get(sqrt_cov, i, j) * tmp; } } }
double randomGauss(double min=0, double max=1, double sigma=C_SIGMA, double miu=C_MIU) { while (true) { double new_random = C_MIU+gsl_ran_gaussian_ziggurat(r, C_SIGMA); if (min <= new_random && new_random <= max) { return new_random; } } }
int DPMHC_mu_smplr(struct str_DPMHC *ptr_DPMHC_data) { int i,j; int i_n = ptr_DPMHC_data->v_y->size; int i_K = ptr_DPMHC_data->i_K; int i_nj; double d_muj,d_s2j,d_yhatj; double d_xij,d_tauj; double d_m0 = ptr_DPMHC_data->d_m0; double d_s2m = ptr_DPMHC_data->d_s2m; gsl_vector *v_y = ptr_DPMHC_data->v_y; gsl_vector_int *vi_S = ptr_DPMHC_data->vi_S; gsl_vector_int *vi_n = ptr_DPMHC_data->vi_n; gsl_matrix *m_theta = ptr_DPMHC_data->m_DPtheta; // printf("\ni_K = %d\n",i_K); for(j=0;j<i_K;j++){ d_yhatj = 0.; i_nj = 0; for(i=0;i<i_n;i++){ if( vget_int(vi_S,i) == j ){ d_yhatj += vget(v_y,i); i_nj++; } } if (vget_int(vi_n,j) != i_nj){ fprintf(stderr,"Error in DPMN_theta_polya_smplr(): vi_n[%d] does not equal i_nj\n", j); exit(1); } d_xij = mget(m_theta,j,1); d_tauj = mget(m_theta,j,2); d_yhatj /= (d_xij * d_xij / d_tauj); d_s2j = 1./( 1./d_s2m + i_nj/ (d_xij * d_xij / d_tauj) ); d_muj = d_s2j * ( d_m0/d_s2m + d_yhatj ); d_muj = d_muj + gsl_ran_gaussian_ziggurat(rng, sqrt(d_s2j)); mset(m_theta,j,0, d_muj); // printf("%d: eta = %g lambda^2 = %g\n",j, mget(m_theta,j,0), mget(m_theta,j,1) ); } return 0; }
/* ORDER: [0] Dxx, [1] Dxy, [2] Dyy, [3] Dxz, [4] Dyz, [5] Dzz */ int RicianNoiseDWIs( float **dwi, int N, int Ngrad, THD_3dim_dataset *D, float NOISE_DWI, float NOISE_B0, MRI_IMAGE *g, byte *M, float S0, float bval, gsl_rng *r) { int i,j,k; float *grad; double sig; double sval; double riced; grad = MRI_FLOAT_PTR(g); for( k=0 ; k<N ; k++) if(M[k]) { sval = 1 + gsl_ran_gaussian_ziggurat(r,1.0) * NOISE_B0; riced = gsl_ran_gaussian_ziggurat(r,1.0) * NOISE_B0; dwi[0][k] = S0 * sqrt(sval*sval + riced*riced); for( i=0 ; i<Ngrad ; i++) { sig = 0; sig+= THD_get_voxel(D,k,0)*grad[3*i]*grad[3*i]; sig+= THD_get_voxel(D,k,2)*grad[3*i+1]*grad[3*i+1]; sig+= THD_get_voxel(D,k,5)*grad[3*i+2]*grad[3*i+2]; sig+= 2*THD_get_voxel(D,k,1)*grad[3*i]*grad[3*i+1]; sig+= 2*THD_get_voxel(D,k,3)*grad[3*i]*grad[3*i+2]; sig+= 2*THD_get_voxel(D,k,4)*grad[3*i+1]*grad[3*i+2]; sval = exp(-bval*sig); sval+= gsl_ran_gaussian_ziggurat(r,1.0) * NOISE_DWI; riced = gsl_ran_gaussian_ziggurat(r,1.0) * NOISE_DWI; dwi[i+1][k] = S0 * sqrt(sval*sval + riced*riced); } } RETURN (1); }
/* Step function */ void S1(const gsl_rng * r, void *xp, double step_size) { block *x = ((block *) xp); int i = (int) round(gsl_rng_uniform(r) * (x->vec->size-1)); gsl_vector_set(x->vec,i, //GSL_MAX(0, gsl_vector_get(x->vec,i) + gsl_ran_gaussian_ziggurat(r,step_size) //) ); }
void UpdateWeinerProcessGSL(parameterStruct *param, double beadDW[][DIM], const gsl_rng *r){ int i=0; int N = param->N; var = sqrt(param->dt); for(i=2;i<N;i++){ beadDW[i][0] = gsl_ran_gaussian_ziggurat(r,var); beadDW[i][1] = gsl_ran_gaussian_ziggurat(r,var); beadDW[i][2] = gsl_ran_gaussian_ziggurat(r,var); } beadDW[0][0] = 0.; beadDW[0][1] = 0.; beadDW[0][2] = 0.; beadDW[1][0] = 0.; beadDW[1][1] = 0.; beadDW[1][2] = 0.; }
int DPMHC_init(struct str_DPMHC *ptr_DPMHC_data, int i_draws){ int j; int i_T = (ptr_DPMHC_data->vi_S)->size; if (i_T == 0){ fprintf(stderr,"Error in DPMHC_init(): DPMHC_alloc() has not been called.\n"); exit(1); } int i_K; gsl_matrix *m_DPtheta = ptr_DPMHC_data->m_DPtheta; ptr_DPMHC_data->m_DPmcmc = gsl_matrix_alloc(i_draws, 2); // for draw of i_K and d_DPalpha // initialize slice truction to K = 4 and one alive cluster, i_m = 1 i_K = ptr_DPMHC_data->i_K = 4; ptr_DPMHC_data->i_m = 1; gsl_vector_int_set_all(ptr_DPMHC_data->vi_S,0); vset_int(ptr_DPMHC_data->vi_n,0,i_T); // draw DP precision parameter d_DPalpha ~ Gamma(a,b) double d_DPalpha; d_DPalpha = ran_gamma(rng, ptr_DPMHC_data->d_a, ptr_DPMHC_data->d_b); ptr_DPMHC_data->d_DPalpha = d_DPalpha; // Draw initial mixture locations for K clusters for(j = 0; j < i_K; j++){ mset(m_DPtheta, j, 0, ptr_DPMHC_data->d_m0 + gsl_ran_gaussian_ziggurat(rng, sqrt(ptr_DPMHC_data->d_s2m))); mset(m_DPtheta, j, 1, gsl_ran_gaussian_ziggurat(rng, ptr_DPMHC_data->d_A)); mset(m_DPtheta, j, 2, gsl_ran_gamma(rng, 0.5, 0.5) ); } return 0; }
//! \brief Update some property of the offspring based on //! properties of the parents virtual void update(const gsl_rng *r, diploid_t &offspring, const diploid_t &, const diploid_t &, const gcont_t &gametes, const mcont_t &mutations, const single_region_fitness_fxn &ff) noexcept { offspring.g = ff(offspring, gametes, mutations); offspring.e = gsl_ran_gaussian_ziggurat(r, sigE); double dev = (offspring.g + offspring.e - optimum); offspring.w = std::exp(-(dev * dev) / (2. * VS)); assert(std::isfinite(offspring.w)); return; }
void update(const gsl_rng *r, diploid_t &offspring, const diploid_t &, const diploid_t &, const gcont_t &gametes, const mcont_t &mutations, const multi_locus_fitness_fxn &genetic_value_fxn) const { offspring[0].g = genetic_value_fxn(offspring, gametes, mutations); offspring[0].e = gsl_ran_gaussian_ziggurat(r, sigE); double dev = (offspring[0].g + offspring[0].e - optimum); offspring[0].w = std::exp(-(dev * dev) / (2. * VS)); assert(std::isfinite(offspring[0].w)); }
int LogisticMap_gene_seq(LogisticMap *self) { int i; double eta; for (i = 1; i < self->num_i; ++i){ eta = gsl_ran_gaussian_ziggurat(self->rng, self->sigma); self->xt[i] = self->mu * self->xt[i-1] * (1 - self->xt[i-1]) + eta; if (self->xt[i] < 0){ self->xt[i] = 0; } } return 0; }
void gen_rand_state_indiv_synth(double *const x, unsigned int N, gsl_rng *r, TMCMCParams ¶ms) { assert(N == 5); // Stars TSED sed_tmp(true); // E(B-V) x[0] = 1.5 * params.data->EBV * gsl_rng_uniform(r); // DM x[1] = 5. + 13. * gsl_rng_uniform(r); // Stellar type double logMass, logtau, FeH, tau; bool in_lib = false; while(!in_lib) { logMass = gsl_ran_gaussian_ziggurat(r, 0.5); //tau = -1.; //while(tau <= 0.) { // tau = 1.e9 * (5. + gsl_ran_gaussian_ziggurat(r, 2.)); //} //logtau = log10(tau); logtau = 8. + gsl_ran_gaussian_ziggurat(r, 1.); FeH = -1.0 + gsl_ran_gaussian_ziggurat(r, 1.); in_lib = params.synth_stellar_model->get_sed(logMass, logtau, FeH, sed_tmp); } x[2] = logMass; x[3] = logtau; x[4] = FeH; if(params.vary_RV) { double RV = -1.; while((RV <= 2.1) || (RV >= 5.)) { RV = params.RV_mean + gsl_ran_gaussian_ziggurat(r, 1.5*params.RV_variance*params.RV_variance); } x[5] = RV; } }
void TGaussianMixture::draw(double* x) { double tmp = gsl_rng_uniform(r); double sum = 0.; for(unsigned int k=0; k<nclusters; k++) { sum += w[k]; if(sum >= tmp) { for(unsigned int i=0; i<ndim; i++) { x[i] = mu[k*ndim + i]; } for(unsigned int j=0; j<ndim; j++) { tmp = gsl_ran_gaussian_ziggurat(r, 1.); for(unsigned int i=0; i<ndim; i++) { x[i] += gsl_matrix_get(sqrt_cov[k], i, j) * tmp; } } break; } } }
static double rhodens_unvisited (const gsl_rng *r, void *dens_data) { // Pointer to the structure: d struct dens_par *d; d=dens_data; // Indicating the rank of the parameter of interest int i=d->pos_rho; // // Draw directly in the posterior distribution int nNeighbors=d->nNeigh[i]; double sumNeighbors=0.0; for (int m=0;m<nNeighbors;m++) { sumNeighbors+=d->rho_run[d->Neigh[i][m]]; } double meanNeighbors=sumNeighbors/nNeighbors; double sample=meanNeighbors+gsl_ran_gaussian_ziggurat(r,sqrt(d->Vrho_run/nNeighbors)); return sample; }
void gen_rand_los_extinction_from_guess(double *const logEBV, unsigned int N, gsl_rng *r, TLOSMCMCParams ¶ms) { assert(params.EBV_prof_guess.size() == N); double EBV_ceil = params.img_stack->rect->max[1]; double EBV_sum = 0.; for(size_t i=0; i<N; i++) { logEBV[i] = params.EBV_prof_guess[i] + gsl_ran_gaussian_ziggurat(r, 1.); EBV_sum += logEBV[i]; } // Ensure that reddening is not more than allowed if(EBV_sum >= 0.95 * EBV_ceil) { double factor = log(0.95 * EBV_ceil / EBV_sum); for(size_t i=0; i<N; i++) { logEBV[i] += factor; } } }
void gen_rand_los_extinction(double *const logEBV, unsigned int N, gsl_rng *r, TLOSMCMCParams ¶ms) { double EBV_ceil = params.img_stack->rect->max[1] / params.subpixel_max; double mu = log(1.5 * params.EBV_guess_max / params.subpixel_max / (double)N); double EBV_sum = 0.; for(size_t i=0; i<N; i++) { logEBV[i] = mu + gsl_ran_gaussian_ziggurat(r, 0.5); EBV_sum += exp(logEBV[i]); } // Ensure that reddening is not more than allowed if(EBV_sum >= 0.95 * EBV_ceil) { double factor = log(0.95 * EBV_ceil / EBV_sum); for(size_t i=0; i<N; i++) { logEBV[i] += factor; } } }
void event_and_rates(gsl_rng * rng, vector<pop> &poplist, double sum, vector<CRow> &cmatrix, par_list * pars) { vector<pop>::iterator p; double threshhold = sum*gsl_rng_uniform(rng); double cumulative = 0; int id = 0; char type='b'; int who=0; for(p=poplist.begin(); p != poplist.end(); p++){ cumulative += p->birth; if( cumulative > threshhold ){ if(gsl_rng_uniform(rng) > pars->mu){ ++p->popsize; type = 'b'; who = id; } else { double y = p->trait + gsl_ran_gaussian_ziggurat(rng,pars->sigma_mu); double c = init_compete(poplist, y, pars); pop pop_i = {1, y, 1., 1., p->trait, c}; poplist.push_back(pop_i); grow_C(poplist, cmatrix, pars); type = 'b'; who = -1; } break; } cumulative += p->death; if( cumulative > threshhold ){ --p->popsize; type = 'd'; who = id; if( p->popsize == 0 ){ poplist.erase( p ); shrink_C(cmatrix, id); // destroy row and column of cmatrix } break; } id++; } fast_update_rates(poplist, cmatrix, who, type, pars); }
void _simulateSDE(const double * abgth, const int N_spikes, const double dt, double * Ss) { const double V_THRESH = 1.0; double alpha, beta, gamma, theta; alpha = abgth[0]; beta= abgth[1]; gamma =abgth[2]; theta = abgth[3]; int recorded_spikes = 0; double v = .0; double sqrt_dt = sqrt(dt); //RNG stuff: const gsl_rng_type * T; gsl_rng * G; /* create a generator chosen by the environment variable GSL_RNG_TYPE */ gsl_rng_env_setup(); T = gsl_rng_default; G = gsl_rng_alloc (T); struct timeval tv; gettimeofday(&tv,NULL); srand((tv.tv_sec * 1000) + (tv.tv_usec / 1000)); unsigned long int S = rand(); // printf("S=%d\n",S); gsl_rng_set (G, S); double dB, dv; double t = .0; while (recorded_spikes < N_spikes){ dB = gsl_ran_gaussian_ziggurat(G, sqrt_dt); dv = ( alpha - v + gamma*sin(theta*t) )*dt + beta*dB; v += dv; t += dt; if (v >= V_THRESH){ Ss [recorded_spikes++] = t; v = .0; } } gsl_rng_free(G); }
void gen_rand_los_extinction_clouds(double *const x, unsigned int N, gsl_rng *r, TLOSMCMCParams ¶ms) { double mu_floor = params.img_stack->rect->min[0]; double mu_ceil = params.img_stack->rect->max[0]; double EBV_ceil = params.img_stack->rect->max[1] / params.subpixel_max; unsigned int N_clouds = N / 2; double logEBV_mean = log(1.5 * params.EBV_guess_max / params.subpixel_max / (double)N_clouds); double mu_mean = (mu_ceil - mu_floor) / N_clouds; double EBV_sum = 0.; double mu_sum = mu_floor; double *Delta_mu = x; double *logDelta_EBV = x + N_clouds; for(size_t i=0; i<N_clouds; i++) { logDelta_EBV[i] = logEBV_mean + gsl_ran_gaussian_ziggurat(r, 0.5); EBV_sum += exp(logDelta_EBV[i]); Delta_mu[i] = mu_mean * gsl_rng_uniform(r); mu_sum += Delta_mu[i]; } Delta_mu[0] += mu_floor; // Ensure that reddening is not more than allowed if(EBV_sum >= 0.95 * EBV_ceil) { double factor = log(0.95 * EBV_ceil / EBV_sum); for(size_t i=0; i<N_clouds; i++) { logDelta_EBV[i] += factor; } } // Ensure that distance to farthest cloud is not more than allowed if(mu_sum >= 0.95 * mu_ceil) { double factor = 0.95 * mu_ceil / mu_sum; for(size_t i=0; i<N_clouds; i++) { Delta_mu[i] *= factor; } } }
/*===========================RANDOM SCALAR/VECTOR/MATRIX=========================*/ void gslu_rand_gaussian_vector (const gsl_rng *r, gsl_vector *a, const gsl_vector *mu, const gsl_matrix *Sigma, const gsl_matrix *L) { assert (a->size == mu->size && (Sigma || L)); for (size_t i=0; i<a->size; i++) gsl_vector_set (a, i, gsl_ran_gaussian_ziggurat (r, 1.0)); if (L) { assert (L->size1 == L->size2 && L->size1 == mu->size); gsl_blas_dtrmv (CblasLower, CblasNoTrans, CblasNonUnit, L, a); } else { assert (Sigma->size1 == Sigma->size2 && Sigma->size1 == mu->size); gsl_matrix *_L = gsl_matrix_alloc (Sigma->size1, Sigma->size2); gsl_matrix_memcpy (_L, Sigma); gsl_linalg_cholesky_decomp (_L); gsl_blas_dtrmv (CblasLower, CblasNoTrans, CblasNonUnit, _L, a); gsl_matrix_free (_L); } gsl_vector_add (a, mu); }
double gsl_ran_gamma_mt (const gsl_rng * r, const double a, const double b) { /* assume a > 0 */ if (a < 1) { double u = gsl_rng_uniform_pos (r); return gsl_ran_gamma_mt (r, 1.0 + a, b) * pow (u, 1.0 / a); } { double x, v, u; double d = a - 1.0 / 3.0; double c = (1.0 / 3.0) / sqrt (d); while (1) { do { x = gsl_ran_gaussian_ziggurat (r, 1.0); v = 1.0 + c * x; } while (v <= 0); v = v * v * v; u = gsl_rng_uniform_pos (r); if (u < 1 - 0.0331 * x * x * x * x) break; if (log (u) < 0.5 * x * x + d * (1 - v + log (v))) break; } return b * d * v; } }
/* s2 is regression model innovation variance */ double sample_gibbs_mean(gsl_vector *y, gsl_vector *x, double m, double v2, double s2) { size_t i,n=y->size; double xt,yt,x2,xy,var_beta,mean_beta; /* x2=0.0; */ /* xy=0.0; */ /* for(i=0;i<n;i++){ */ /* xt=vget(x,i); */ /* yt=vget(y,i); */ /* x2 += xt*xt; */ /* xy += xt*yt; */ /* } */ gsl_blas_ddot(y,x,&xy); gsl_blas_ddot(x,x,&x2); var_beta = s2*v2 / (v2*x2 + s2); mean_beta = var_beta * ( xy/s2 + m/v2 ); return mean_beta + gsl_ran_gaussian_ziggurat(rng,sqrt(var_beta)); }
void gauss_xdat(Search_settings *sett, double amplitude, double sigma, int i){ gsl_rng * r; int j; unsigned long mySeed; mySeed = random_seed(); const gsl_rng_type * T; gsl_rng_env_setup(); T = gsl_rng_default; r = gsl_rng_alloc (T); gsl_rng_set(r, mySeed); // Generate normal distribution (around 0, // with amplitude and sigma as parameters) for(j = 0; j < sett->N; j++) ifo[i].sig.xDat[j] = amplitude*gsl_ran_gaussian_ziggurat(r, sigma); gsl_rng_free(r); }
int main(int argc, char **argv) { int i, N; double *x, amp, sigma; unsigned long mySeed; mySeed = random_seed(); N = atoi(argv[1]); amp = atof(argv[2]); sigma = atof(argv[3]); x = (double *)calloc(N, sizeof(double)); FILE *dataout; dataout = fopen(argv[4], "wb"); const gsl_rng_type * T; gsl_rng_env_setup(); T = gsl_rng_default; r = gsl_rng_alloc (T); gsl_rng_set(r, mySeed); // Generate normal distribution (around 0, // with amplitude amp and sigma) for(i=0; i<N; i++) x[i] = amp*gsl_ran_gaussian_ziggurat(r, sigma); gsl_rng_free(r); fwrite(x, sizeof(*x), N, dataout); fclose(dataout); free(x); return 0; }
double Random::normal() { return gsl_ran_gaussian_ziggurat(this->randomGeneratorHandle, 1.0); }
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, unsigned long int noise_seed) { /*printf("Integration starts...\n");*/ /*printf("D=%d\n",D);*/ /*Temporary variables*/ double *y = (double*) malloc( sizeof(double)*D ); /*state variable at time t-1 (input) and then at time t(output)*/ /*printf("y allocated\n");*/ double *dydt = (double*) malloc( sizeof(double)*D ); /*rate of change at time point t*/ /*double *dydt_in = (double*) malloc( sizeof(double)*D ); /*rate of change at time point t-1*/ /*printf("dydt_in allocated\n");*/ /*double *dydt_out= (double*) malloc( sizeof(double)*D ); /*rate of change at time point t*/ /*printf("dydt_out allocated\n");*/ /*double *yerr = (double*) malloc( sizeof(double)*D );/*error*/ /*printf("yerr allocated\n");*/ double t0,tf,tc,dt=(t[1]-t[0])/10,noise;/*initial time point, final time point, current time point, current time step, noise*/ /*printf("dt=%f\n",dt);*/ int j,ii;/*State variable and iteration indexes*/ int status;/*integrator success flag*/ /*Prepare noise generator*/ const gsl_rng_type *Q; gsl_rng *r; gsl_rng_env_setup(); Q = gsl_rng_default; r = gsl_rng_alloc(Q); gsl_rng_set (r, noise_seed); /*printf("random number generator set\n");*/ /*Initialize*/ /*Calculate dx/dt for x0*/ /*tc=t[0]; /*printf("tc=%f\n",tc);*/ /* initialise dydt_in from system parameters */ /*GSL_ODEIV_FN_EVAL(&sys, t, y, dydt_in);*/ /*printf("x0=[ "); for (j=0; j<D; j++) printf("%f ", x0[j]); /*printf("]\n");*/ /*GSL_ODEIV_FN_EVAL(&sys, tc, x0, dydt_in); /*printf("dydt_in[t0]=[ ");*/ /*for (j=0; j<D; j++) printf(" %f",dydt_in[j]);*/ /*printf(" ]\n");*/ /*printf("y[t0]=[ ");*/ for (j=0;j<D;j++) { y[j] = x[j] = x0[j]; /*printf(" %f",y[j]);*/ } /*printf(" ]\n");*/ /*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);*/ status=System(tc, y, dydt, params); /*Increase current time*/ tc += dt; for (j=0;j<D;j++) { noise=gsl_ran_gaussian_ziggurat(r, s_noise); //dydt[j]+=noise; y[j] += dt*dydt[j] + sqrt(dt)*noise; } } /*Unpack and store result for this time point adding some gaussian noise with sigma s_noise*/ /*if (status != GSL_SUCCESS) break;*/ for (j=0;j<D;j++) { x[ii*D+j] = y[j]; dxdt[(ii-1)*D+j] = dydt[j]; } } /*Get dxdt for the last time point*/ status=System(t[ii], y, dydt, params); for (j=0;j<D;j++) dxdt[(iters-1)*D+j] = dydt[j]; /*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); /*free(dydt_in); /*printf("dydt_in freed\n");*/ free(y); /*printf("y freed\n");*/ }