void random_vector(gsl_vector *vec, double parameter , double (* func)(const gsl_rng *, double )){
//
const gsl_rng_type * T;
gsl_rng * r;
int i;
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc (T);
gsl_rng_set (r, rand());
for (i = 0; i < vec->size; i++)
{
// double u = gsl_rng_uniform (r);
gsl_vector_set(vec, i, func(r, parameter));
}
gsl_rng_free (r);
}
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 unbiasround( double *mat, int *imat, int * imat1, int * rowparity,int *nrow, int *ncol, gsl_rng *r) {
int i,j,k,k1;
int nr,nc;
static int first_use = 1;
gsl_rng *rng;
if (r) rng = r;
else {
if (first_use){
gsl_rng_env_setup();
first_use=0;
}
rng = gsl_rng_alloc(gsl_rng_taus2);
}
gsl_rng_set(rng, 27);
/* Rprintf("Entering unbiasround, nrow = %d , ncol = %d \n",*nrow,*ncol); */
nr = (*nrow) + 1;
nc = (*ncol) + 1;
/* Make an integer array
Also add an extra column so there are an even number of 1's in each row */
for (i=0; i < *nrow; i++) {
k1 = i + nr * *ncol;
imat[k1] = 0;
for (j=0; j < *ncol; j++) {
imat[i + nr * j] = lrint( mat[i + *nrow * j]*(twobits));
}
}
/* Add an extra row so there will be an even number of 1's in each column */
for (j=0; j <= *ncol; j++) { //don't forget the lower-right corner.
k1 = *nrow +j * nr ;
imat[k1] = 0;
}
for (k1=0; k1< bits; k1++) {
roundeven(imat,imat1,rowparity,&nr,&nc, rng);
for (k=0, i=0; i < nr; i++) {
for (j=0; j < nc; j++, k++) {
imat[k] >>= 1; /* Divide entire matrix by 2 using right shift 1 bit */
}
}
}
}
void assign_parameters()
{
extern unsigned long nx0, ny0;
extern double pi, deg2Rad, rad2Deg, strad2Deg, etaOffSet;
extern double surveyCenterRA, surveyCenterDEC, node, etaPole;
const gsl_rng_type *T;
/* With these base resolutions, we can achieve nearly equal area pixels, with
nearly square pixels at lambda = 30 degrees. A resolution factor of
4 gives us pixels as wide as a stripe. The seeing/reddening/sky maps
are made with resolution=256.
YOU MUST CALL assign_parameters() AT THE BEGINNING OF YOUR CODE TO SET
UP THE REQUIRED GLOBAL VARIABLES.
*/
nx0 = 36;
ny0 = 13;
pi = 2.0*asin(1.0);
deg2Rad = pi/180.0;
rad2Deg = 180.0/pi;
strad2Deg = 360.0*360.0/(4.0*pi*pi);
/* These parameters are necessary for translation of LAMBDA-ETA coordinates
into x-y-z vectors in a way consistant with translations from RA-DEC. We
also need etaOffSet to compensate for the fact that the stripes stradle
the ETA = 0 meridian, rather than being bounded by it. */
etaOffSet = 91.25;
surveyCenterRA = 185.0;
surveyCenterDEC = 32.5;
node = deg2Rad*(surveyCenterRA - 90.0);
etaPole = deg2Rad*surveyCenterDEC;
gsl_rng_env_setup();
gsl_rng_default_seed = time(NULL);
T = gsl_rng_default;
mt19937_rand = gsl_rng_alloc(T);
}
AlexSim::AlexSim(double tstart,double tend)
{
qDebug("\n *** ALEX Simulation *** ");
this->tStart=tstart;
tDuration=tend-tstart;
if(tDuration<=0) {
qFatal("enter times tstart<tend");
}
t=0;
burstDuration=3e-3; // 2ms
burstDurationVar=18e-7; // variance of burst duration in seconds^2, estimated from data
rateDemDex=6e4; // 50kHz
rateAemAex=6e4;
rateBackground=1e3; // 1kHz
rateFirst=1e9;
rateBlinking;
rateBleaching=4e3; // per second
lifetimeBleaching=5e-3;
lifetimeBlinking=10e-6; // triplet state lifetime ca 3 micro seconds
crosstalk=0.03;
directExcitation=0.02;
tDex=100e-6;
tAex=80e-6;
tDexBreak=10e-6;
tAexBreak=10e-6;
// photonArrivalTimeChannel1.reserve();
/* create a generator chosen by the environment variable GSL_RNG_TYPE */
gsl_rng_env_setup();
rngType = gsl_rng_default;
r = gsl_rng_alloc(rngType);
gsl_rng_set(r, 0); // set the seed to 0, i.e. the default value
// approximate burst size distribution as lognormal
sigma=sLogNorm(burstDuration,burstDurationVar);
mu=mLogNorm(burstDuration, burstDurationVar);
qDebug()<<"lognormal mu="<<mu;
qDebug()<<"lognormal sigma="<<sigma;
}
int
main(void)
{
const gsl_rng_type * T;
gsl_rng * r;
double x_initial = 15.5;
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc(T);
gsl_siman_solve(r, &x_initial, E1, S1, M1, P1,
NULL, NULL, NULL,
sizeof(double), params);
gsl_rng_free (r);
return 0;
}
/*
* generating random numbers separately to
* prevent the side effects on hardware counters.
*
* */
void generate_random_numbers(int *sequence) {
const gsl_rng_type * T;
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc (T);
/* seed */
gsl_rng_set(r, seed);
/* default generator type is mt19937, which is what we need */
// printf("generator type: %s\n", gsl_rng_name (r));
int i;
for (i = 0; i < SEQUENCE_CNT; i++) {
sequence[i] = gsl_rng_get(r) % SEQUENCE_CNT; // limit the random numbers to [0, 3999]
// printf("%u\t", sequence[i]);
}
}
int main(void)
{
// prepare GSL random number generator
const gsl_rng_type* T;
gsl_rng* r;
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc(T);
double estim, err;
fprintf(stdout,"# Volume of n-dim ball:\n");
fprintf(stdout,"# DIM\tActual Vol.\tADAPT(Estim.)\tADAPT(counts)\tMC(Estim.)\tMC(Counts)\n");
for(dim=1; dim < 7; dim++)
{
fprintf(stdout,"%d\t%g",dim,volume(dim));
counter = 0;
estim = adapt_nd_speclim(f,d,u,dim,ACC,EPS,&err);
fprintf(stdout,"\t%g\t%llu",estim,counter);
counter = 0;
estim = monte_carlo_speclim(f,d,u,dim,ACC,EPS,100,&err,r);
fprintf(stdout,"\t%g\t%llu\n",estim,counter);
}
fprintf(stdout,"\n\n# Integral of exp(sum_i x_i) in n-ball\n");
fprintf(stdout,"# Dim\tADAPT\tMonte Carlo\n");
for(dim=1; dim < 7; dim++)
{
fprintf(stdout,"%d",dim);
counter = 0;
estim = adapt_nd_speclim(fexp,d,u,dim,ACC,EPS,&err);
fprintf(stdout,"\t%llu",counter);
counter = 0;
estim = monte_carlo_speclim(fexp,d,u,dim,ACC,EPS,100,&err,r);
fprintf(stdout,"\t%llu\n",counter);
}
gsl_rng_free(r);
return 0;
}
int main(int argc, char** argv) {
int size = 10000;
double sx = 1.0;
double sy = 1.0;
int opt;
while ((opt = getopt(argc, argv, "s:x:y:")) != -1) {
switch (opt) {
case 's':
size = atoi(optarg);
break;
case 'x':
sx = atof(optarg);
break;
case 'y':
sy = atof(optarg);
break;
}
}
gsl_rng_env_setup();
gsl_rng* rng = gsl_rng_alloc(gsl_rng_default);
double px[4] = {0.0, 0.0, 1.0, 1.0};
double py[4] = {0.0, 1.0, 0.0, 1.0};
double x = gsl_rng_uniform(rng);
double y = gsl_rng_uniform(rng);
printf("%g %g\n", x, y);
int i, d;
for (i = 0; i < size; i++) {
d = gsl_rng_uniform_int(rng, 4);
x = (x * sx + px[d]) / (1.0 + sx);
y = (y * sy + py[d]) / (1.0 + sy);
printf("%g %g\n", x, y);
}
gsl_rng_free(rng);
}
// [[Rcpp::export]]
Rcpp::List genData() {
const size_t n = N;
size_t i;
double dy;
gsl_rng *r;
RcppGSL::vector<double> w(n), x(n), y(n);
gsl_rng_env_setup();
r = gsl_rng_alloc(gsl_rng_default);
//printf("#m=0,S=0\n");
/* this is the data to be fitted */
for (i = 0; i < n; ++i) {
double sigma;
double xi = (15.0 / (N - 1)) * i;
double yi = cos(xi) * exp(-0.1 * xi);
sigma = 0.1 * yi;
dy = gsl_ran_gaussian(r, sigma);
yi += dy;
gsl_vector_set(x, i, xi);
gsl_vector_set(y, i, yi);
gsl_vector_set(w, i, 1.0 / (sigma * sigma));
//printf("%f %f\n", xi, yi);
}
Rcpp::DataFrame res = Rcpp::DataFrame::create(Rcpp::Named("x") = x,
Rcpp::Named("y") = y,
Rcpp::Named("w") = w);
x.free();
y.free();
w.free();
gsl_rng_free(r);
return(res);
}
int main(int argc, char **argv)
{
int ret;
params p = { /*<<< ___default___ */
4.2, /* amp */
4.9, /* omega */
0.0, /* force */
0.9, /* gamma */
0.001, /* Dg */
0.0, /* Dp */
0.0, /* lambda */
false, /* biased */
32, /* paths */
10000, /* periods */
99, /* trans */
200, /* spp */
true, /* 2nd order */
};/*>>>*/
tic = clock();
set_parameters(argc,argv,&p);
/*<<< GSL */
const gsl_rng_type * R;
gsl_rng * rg;
gsl_rng_env_setup();
if (!getenv("GSL_RNG_SEED")){
gsl_rng_default_seed = time(NULL);
fprintf(stderr,"#seed:%ld\n",gsl_rng_default_seed);
}
R = gsl_rng_default;
rg = gsl_rng_alloc (R);
/*>>>GSL*/
dump_params(&p);
ret = simulate(&p, rg);
gsl_rng_free(rg);
return ret;
}
int main (int argc, char* argv[]){
int nsteps = 2;
int g1[WDEFAULT][HDEFAULT], g2[WDEFAULT][HDEFAULT];
for(int i = 0; i < WDEFAULT; i++)
for(int j = 0; j < HDEFAULT; j++){
g1[i][j] = 0;
g2[i][j] = 0;
}
const gsl_rng_type *T;
gsl_rng *rand;
gsl_rng_env_setup();
T = gsl_rng_default;
rand = gsl_rng_alloc(T);
gsl_rng_set(rand, get_seed_noblock());
randomInit(g1, 0.55, rand);
printGrid(g1);
updateGrid(g1,g2);
printf("# updated \n");
printGrid(g2);
for(int i = 0; i < nsteps; i++){
// blit g2 back into g1
memcpy(g1, g2, sizeof(int)*WDEFAULT*HDEFAULT);
// now update g1
updateGrid(g1,g2);
printGrid(g2);
}
gsl_rng_free(rand);
return EXIT_SUCCESS;
}
couple::couple (int argc, char *argv[] ) {
static const char *optString = "vh";
static const struct option longOpts[] = {
{ "parameter", required_argument, NULL, 'p' },
{ "verbose", no_argument, NULL, 'v' },
{ "help", no_argument, NULL, 'h' },
{ NULL, no_argument, NULL, 0 }
};
d = new data (argc, argv, optString, longOpts);
string pfile;
d->get_string ("parameter",pfile,true);
p = new data (pfile);
p->print_parameters();
p->get_int ("debug", io::debug, 0);
string geno1, snp1, ind1;
string inputformat = "eigenstrat";
p->get_string ("genotypename",geno1,true);
p->get_string ("snpname",snp1,true);
p->get_string ("indivname",ind1,true);
p->get_boolean ("isgenotype", isgenotype, false);
p->get_boolean ("pack", pack, true, false);
string indivfilterfile = "";
givenindivfilterfile = p->get_string ("indivfilterfile", indivfilterfile, false);
g = new genotype (snp1,ind1, geno1, "eigenstrat", isgenotype, indivfilterfile, "", false, pack);
p->get_int ("seed",seed,1,false);
nind = g->nind;
nsnps = g->nsnp;
nchr = g->nchr;
gsl_rng_env_setup();
rng_T = gsl_rng_default;
rng_r = gsl_rng_alloc (rng_T);
gsl_rng_set (rng_r, seed);
}
Random::Random(std::string type)
{
gsl_rng_env_setup();
if (type == "mt19937") {
this->randomGeneratorType = gsl_rng_mt19937;}
else if (type == "taus") {
this->randomGeneratorType = gsl_rng_taus;}
else if (type == "ranlxs0") {
this->randomGeneratorType = gsl_rng_ranlxs0;}
else {
this->randomGeneratorType = gsl_rng_ranlxs0;}
this->randomGeneratorHandle = gsl_rng_alloc(this->randomGeneratorType);
this->toSeed();
gsl_rng_set(this->randomGeneratorHandle, this->seed);
printf(
"Random number generator of type '%s' "
"has been intialized and seeded.\n",
gsl_rng_name(randomGeneratorHandle));
}
int main(int argc, char* argv[])
{
FILE* f_out;
f_out = fopen("output_ROSSLER.dat","w");
FILE* f_in;
f_in = fopen("input_ROSSLER.dat","r");
double pars[4];
double Tspan[2];
Tspan[0] = 0.0;
double dt;
int print_step;
if(!ParseData_ROSSLER(pars,Tspan,&dt,&print_step,f_in)) return 1;
fclose(f_in);
double x0[3] = {1.0, 0.0, 0.0};
// Allocation and Initialization of Random Number Generator
const gsl_rng_type * T;
gsl_rng * r;
gsl_rng * r_lyap;
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc(T);
r_lyap = gsl_rng_alloc(T);
// Parameters for the Calculation of the Maximum LE
double tau = 100*dt;
double alpha = 1e-2;
double lyapexp = 0;
SdeSolverLyapLog(Stepper_RK4,Update_VF_ROSSLER,Update_Diffusion_ROSSLER,Update_Diffusion_Deriv_ROSSLER,Tspan,x0,3,1,dt,pars,r,r_lyap,tau,alpha,&lyapexp,f_out,print_step,1);
printf("Computed value of maximum Lyapunov Exponent: %f\n",lyapexp);
fclose(f_out);
return 0;
}
int init_xrandom(string init)
{
#ifdef HAVE_GSL
char my_gsl_type[64], my_gsl_seed[64], *cp; /* need two strings, bug in putenv? */
string *is;
int nis, iseed;
is = burststring(init,", "); /* parse init as "[seed[,name]]" */
nis = xstrlen(is,sizeof(string))-1;
if (nis > 0) { /* seed is first, but optional */
iseed = natoi(is[0]);
if (iseed > 0 || streq(is[0],"+0")) {
sprintf(my_gsl_seed,"%s=%s",env_seed,is[0]);
} else {
iseed = set_xrandom(iseed);
sprintf(my_gsl_seed,"%s=%u",env_seed,iseed);
}
putenv(my_gsl_seed);
dprintf(1,"putenv: %s\n",my_gsl_seed);
if (nis > 1) { /* name is second, also optional */
sprintf(my_gsl_type,"%s=%s",env_type,is[1]);
putenv(my_gsl_type);
dprintf(1,"putenv: %s\n",my_gsl_type);
}
}
gsl_rng_env_setup(); /* initialize the rng (name/seed) setup */
my_T = gsl_rng_default;
my_r = gsl_rng_alloc(my_T);
dprintf(1,"GSL generator type: %s\n",gsl_rng_name(my_r));
dprintf(1,"GSL seed = %u\n",gsl_rng_default_seed);
dprintf(1,"GSL first value = %u\n",gsl_rng_get(my_r));
return (int) gsl_rng_default_seed;
#else
return set_xrandom(init? natoi(init) : 0); /* 18/06/2008: allow for init=0 WD */
#endif
}
void *operateOnTree(void* tArgs)
{
struct timespec s,e;
int chooseOperation;
unsigned long lseed;
int threadId;
struct threadArgs* tData = (struct threadArgs*) tArgs;
threadId = tData->threadId;
lseed = tData->lseed;
const gsl_rng_type* T;
gsl_rng* r;
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc(T);
gsl_rng_set(r,lseed);
while(!start)
{
}
clock_gettime(CLOCK_REALTIME,&s);
for(int i=0;i< (int)iterations;i++)
{
chooseOperation = gsl_rng_uniform(r)*100;
if(chooseOperation < findPercent)
{
lookup(tData,gsl_rng_get(r)%keyRange + 1);
}
else if (chooseOperation < insertPercent)
{
insert(tData,gsl_rng_get(r)%keyRange + 1);
}
else
{
remove(tData,gsl_rng_get(r)%keyRange + 1);
}
}
clock_gettime(CLOCK_REALTIME,&e);
timeArray[threadId] = (double) (diff(s,e).tv_sec * 1000000000 + diff(s,e).tv_nsec)/1000;
return NULL;
}
void TrainLINE() {
long a;
pthread_t *pt = (pthread_t *)malloc(num_threads * sizeof(pthread_t));
if (order != 1 && order != 2)
{
printf("Error: order should be eighther 1 or 2!\n");
exit(1);
}
printf("--------------------------------\n");
printf("Order: %d\n", order);
printf("Samples: %lldM\n", total_samples / 1000000);
printf("Negative: %d\n", num_negative);
printf("Dimension: %d\n", dim);
printf("Initial rho: %lf\n", init_rho);
printf("--------------------------------\n");
InitHashTable();
ReadData();
InitAliasTable();
InitVector();
InitNegTable();
InitSigmoidTable();
gsl_rng_env_setup();
gsl_T = gsl_rng_rand48;
gsl_r = gsl_rng_alloc(gsl_T);
gsl_rng_set(gsl_r, 314159265);
clock_t start = clock();
printf("--------------------------------\n");
for (a = 0; a < num_threads; a++) pthread_create(&pt[a], NULL, TrainLINEThread, (void *)a);
for (a = 0; a < num_threads; a++) pthread_join(pt[a], NULL);
printf("\n");
clock_t finish = clock();
double duration = (double)(finish - start) / CLOCKS_PER_SEC;
printf("Total CPU time: %lf, real time %.2lf (s)\n", duration, duration / num_threads);
Output();
}
extern void init_math_functions (struct _flow *flow, unsigned long seed)
{
int rc;
#ifndef HAVE_LIBGSL
UNUSED_ARGUMENT(flow);
#endif /* HAVE_LIBGSL */
/* set rounding */
fesetround(FE_TONEAREST);
/* initalize rng */
#ifdef HAVE_LIBGSL
const gsl_rng_type * T;
gsl_rng_env_setup();
T = gsl_rng_default;
flow->r = gsl_rng_alloc (T);
#endif /* HAVE_LIBGSL */
if (!seed) {
/* if no seed supplied use urandom */
DEBUG_MSG(LOG_WARNING, "client did not supply random seed "
"value");
int data = open("/dev/urandom", O_RDONLY);
rc = read(data, &seed, sizeof (long) );
close(data);
if(rc == -1)
crit("read /dev/urandom failed");
}
#ifdef HAVE_LIBGSL
gsl_rng_set (flow->r, seed);
DEBUG_MSG(LOG_WARNING, "initalized local libgsl random functions for "
"flow %d with seed %lu, gsl generator is: %s",
flow->id,seed,gsl_rng_name (flow->r));
#else
srand((unsigned int)seed);
DEBUG_MSG(LOG_WARNING, "initalized posix random functions with seed "
"%u", (unsigned int)seed);
#endif /* HAVE_LIBGSL */
}
int main(){
int i;
const int M = 5e7;
time_t t1, t2, t;
double mu= 1e-7;
int L=3e6, T, N;
/* INIT GSL RNG*/
t = time(NULL); // time in seconds, used to change the seed of the random generator
gsl_rng * rng;
const gsl_rng_type *typ;
gsl_rng_env_setup();
typ=gsl_rng_default;
rng=gsl_rng_alloc(typ);
gsl_rng_set(rng,t); // changes the seed of the random generator
printf("\n - performing %d computations of Bernoulli prob mass fct - ", M);
time(&t1);
for(i=0;i<M;i++){
T=gsl_rng_uniform_int(rng,100); /* time */
N=gsl_rng_uniform_int(rng, 20); /* nb of mutations*/
gsl_ran_binomial_pdf((unsigned int) N, mu, T*L);
}
time(&t2);
printf("\nTime ellapsed: %d ", (int) (t2-t1));
printf("\n - performing %d computations of Poisson prob mass fct- ", M);
time(&t1);
for(i=0;i<M;i++){
T=gsl_rng_uniform_int(rng,100); /* time */
N=gsl_rng_uniform_int(rng, 20); /* nb of mutations*/
gsl_ran_poisson_pdf((unsigned int) N, mu*T*L);
}
time(&t2);
printf("\nTime ellapsed: %d \n", (int) (t2-t1));
}
void
init_rng( long unsigned int Seed )
{
gsl_rng_env_setup( ) ;
const gsl_rng_type *type = gsl_rng_default ;
r = gsl_rng_alloc (type) ;
if( Seed == 0 ) {
FILE *urandom = fopen( "/dev/urandom" , "r" ) ;
if( urandom == NULL ) exit( 1 ) ;
if( fread( &Seed , sizeof( Seed ) , 1 , urandom ) != 1 ) exit(1) ;
fclose( urandom ) ;
}
SEED = Seed ;
printf( "USING GSL seed %lu \n" , SEED ) ;
gsl_rng_set( r , Seed ) ;
return ;
}
gsl_rng *ini_gsl_rng(Args *args) {
const gsl_rng_type *t;
gsl_rng *r;
int idum;
FILE *fp;
gsl_rng_env_setup();
t = gsl_rng_default;
r = gsl_rng_alloc(t);
/* seed for random number generation */
if(args->s != 0) {
idum = args->s;
} else if((fp = fopen("randomSeed.dat","r")) != NULL) {
if(!fscanf(fp,"%d",&idum))
printf("WARNING[gsl_rng]: Something went wrong when trying to read the the seed for the random number generator from randomSeed.dat.\n");
fclose(fp);
} else
idum = -time(NULL);
gsl_rng_set(r,idum);
return r;
}
/**
* @brief Construct
*
* @param k K-Space points
* @param maxit Max search iterations
* @param st Start temperature
* @param ft Final temperature
* @param cr Cooling rate
* @param verb Verbosity
* @param accworse Accept worse solutions with a certain probability
*/
SimulatedAnnealing (const Matrix<double>& k, const size_t& maxit = 1000, const double& st = 300.0,
const double& ft = 0.0, const double& cr = 0.95, const bool& verb = true,
const bool& accworse = false) {
m_maxit = maxit;
m_st = st;
m_ft = ft;
m_cr = cr;
m_verb = verb;
m_accworse = accworse;
m_k = k;
gsl_rng_env_setup();
m_rng = gsl_rng_alloc (gsl_rng_taus2);
gsl_rng_set (m_rng, time(0));
Initialise ();
m_ct = m_st;
printf ("Simulated annealing set up\n");
}
int
main (void)
{
double res, err;
double a= 0.;
double b= 2.;
int dim=9;
double xl[9] = { a,a,a,a,a,a,a,a,a};
double xu[9] = { b,b,b,b,b,b,b,b,b};
gsl_monte_function G = { &f, dim, 0 };
size_t calls =1e6*dim;
gsl_rng_env_setup ();
gsl_rng *r = gsl_rng_alloc (gsl_rng_taus2);
gsl_rng_set (r, 30776);
gsl_monte_vegas_state *s = gsl_monte_vegas_alloc (dim);
gsl_monte_vegas_integrate (&G, xl, xu, dim, 1e4, r, s,
&res, &err);
//display_results ("vegas warm-up", res, err,0);
//printf ("converging...\n");
int i=0;
do
{
gsl_monte_vegas_integrate (&G, xl, xu, dim, calls/5, r, s,
&res, &err);
//printf ("result = % .6f sigma = % .6f chisq/dof = %.1f\n",
// res, err, gsl_monte_vegas_chisq (s));
i=i+1;
}
while (fabs (gsl_monte_vegas_chisq (s) - 1.0) > 0.5);
display_results ("vegas final", res, err, i);
gsl_monte_vegas_free (s);
return 0;
}
int main(int argc, char *argv[])
{
//Make stack size unlimited
system("ulimit -s unlimited");
int ii;
const long N = 1000;
double x[N],y[N],dx ,dy;
const gsl_rng_type * T;
gsl_rng *r;
FILE *fp1;
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc(T);
x[0] = 0;
y[0] = 0;
fp1 = fopen("./data/random_walk.dat","w");
for (ii = 1; ii < N; ii++)
{
gsl_ran_dir_2d(r,&dx,&dy);
x[ii] = x[ii-1]+dx;
y[ii] = y[ii-1]+dy;
//printf("%f\n",dx);
//printf("%f\n",dy);
fprintf(fp1,"%f %f\n",x[ii],y[ii]);
}
gsl_rng_free(r);
fclose(fp1);
//Call gnuplot
system("gnuplot random_walk.plt");
return 0;
}
int main(int argc, char* argv[])
{
/* initialize the CUnit test registry */
if (CUE_SUCCESS != CU_initialize_registry()) {
return CU_get_error();
}
#ifdef HAVE_LIBGSL
gsl_rng_env_setup();
#endif
registerUtilsTests();
registerPopulationTests();
registerEnvironmentTests();
/* Run all tests using the CUnit Basic interface */
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
CU_cleanup_registry();
return CU_get_error();
}
/* Estimate the coefficient on the independent variable in an AR(1) model */
double ar1_ols_est (double * params, int n, unsigned long int seed){
double beta = params[0];
double alpha = params[1];
double s = params[2];
/* Create a generator chosen by the environment variable GSL_RNG_TYPE */
const gsl_rng_type * T;
gsl_rng * r;
gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc(T);
gsl_rng_set(r, seed);
// Generate the sample path
int i;
double x[n+1]; // Create an array of size n+1 for the data
x[0] = beta / (1 - alpha); // Start at mean of stationary dist
for (i = 1; i <= n; i++) {
x[i] = beta + alpha * x[i-1] + gsl_ran_gaussian(r,s);
}
gsl_rng_free (r); // Setting the random number generator free
// Compute auxiliary variables for estimators
double sum_x = 0;
double sum_y = 0;
double sum_xy = 0;
double sum_xx = 0;
for (i = 1; i <= n; i++) {
sum_x += x[i-1];
sum_y += x[i];
sum_xy += x[i-1] * x[i];
sum_xx += x[i-1] * x[i-1];
}
// Compute the OLS estimate for alpha
double alpha_ols = (sum_xy - ( sum_x * sum_y)/n) / (sum_xx - (sum_x *
sum_x)/n);
return alpha_ols;
}
/* gsl rng stuff */
int ggen_rng_init(gsl_rng **r)
{
const gsl_rng_type *T;
char *seedenv;
unsigned long seedval;
FILE *file;
gsl_rng_env_setup();
T = gsl_rng_default;
*r = gsl_rng_alloc(T);
info("Using %s as RNG.\n",gsl_rng_name(*r));
/* if the user didn't provide a seed, we try to seed the generator
* using something sensible.
* THIS IS NOT INTENDED TO BE USED IN REAL EXPERIMENTS.
* USERS SHOULD BE CAREFUL ABOUT THEIR RNG INIT.
*/
seedenv = getenv("GSL_RNG_SEED");
if(seedenv == NULL)
{
warning("RNG seed not provided by user, will attempt to use /dev/urandom.\n");
file = fopen("/dev/urandom","r");
if(file == NULL)
error("Cannot open /dev/urandom: %s\n",strerror(errno));
if(fread(&seedval,sizeof(seedval),1,file) != 1)
error("Cannot read /dev/urandom: %s\n",
strerror(ferror(file)));
fclose(file);
gsl_rng_set(*r,seedval);
info("Using %lu as RNG seed (provided by urandom).\n", seedval);
}
else
info("Using %lu as RNG seed.\n",gsl_rng_default_seed);
return 0;
}
void test_0(const int n) {
gsl_rng_env_setup();
gsl_rng *r = gsl_rng_alloc(gsl_rng_default);
double *a = gsl_runorm(r, n);
double *b = gsl_runorm(r, n);
gsl_rng_free(r);
double *c = malloc(n * sizeof(double));
clock_t begin = clock();
#pragma omp parallel for schedule(static), num_threads(2)
for (int i = 0; i < n; i++) {
c[i] = a[i] + b[i];
c[i] = c[i] * (a[i] + b[i]);
c[i] = c[i] * (a[i] / 2.0);
c[i] = exp(c[i]);
c[i] = log(c[i]);
}
clock_t end = clock();
printf("Time elapsed: %e s\n", (end - begin) / ((double) CLOCKS_PER_SEC));
}
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);
}
