/// Initialize \ref sim_poisson void sim_poisson_init(void) { // just pick on generator and do not worry about seed rng_ = gsl_rng_alloc(gsl_rng_taus); assert( rng_ != NULL ); }
int main(int argc, char ** argv){ gsl_rng * r = gsl_rng_alloc (gsl_rng_taus2); // gsl_rng_set(r,time(NULL)); FILE * log = fopen("recover_shanon.log","w"); #ifdef MPI MPI_Init(&argc, &argv); #endif int n_samples = 500; if(argc != 2 && argc != 3 && argc != 4 ){ printf("recover_shanon <input_image> [total n photons scattered] [n samples]\n"); printf("The defaults are n photons = n pixels and n samples = 500\n"); exit(0); } if(argc >= 4){ n_samples = atoi(argv[3]); } Image * a = sp_image_read(argv[1],0); double image_photons = 0; for(int i = 0;i<sp_image_size(a);i++){ image_photons += sp_real(a->image->data[i]); } int n_photons = sp_image_size(a); if(argc >= 3){ n_photons = atoi(argv[2]); } sp_image_scale(a,n_photons/image_photons); image_photons = 0; for(int i = 0;i<sp_image_size(a);i++){ image_photons += sp_real(a->image->data[i]); } printf("Total photons %f\n",image_photons); printf("Average photon count %f\n",image_photons/sp_image_size(a)); printf("Creating rotated samples..."); fflush(stdout); Image * avg_samples = sp_image_alloc(sp_image_x(a),sp_image_y(a),sp_image_z(a)); sp_matrix ** random_orient_samples = get_rotated_samples(a,n_samples,r,avg_samples); // Image ** orient_samples = get_orient_samples(a,n_samples,r); printf("done\n"); image_photons = 0; for(int i = 0;i<sp_image_size(a);i++){ image_photons += random_orient_samples[0]->data[i]; } printf("Total photons in sample 1 - %f\n",image_photons); // Image * avg_samples = get_image_avg(orient_samples,n_samples); /* printf("Rotating samples..."); fflush(stdout); sp_matrix ** random_orient_samples = get_random_orient_samples(orient_samples,n_samples,r); printf("done\n");*/ // sp_image_write(random_orient_samples[1],"sample.png",COLOR_GRAYSCALE); /* for(int i = 0;i<n_samples;i++){ sp_image_free(orient_samples[i]); } free(orient_samples);*/ Image * avg_random_samples = sp_image_alloc(sp_image_x(a),sp_image_y(a),sp_image_z(a)); for(int i = 0;i<n_samples;i++){ for(int k = 0;k<sp_image_size(avg_random_samples);k++){ sp_real(avg_random_samples->image->data[k]) += random_orient_samples[i]->data[k]; } } /* Create rotation list */ /* printf("Creating rotation list..."); fflush(stdout); sp_matrix *** rotated_random_orient_samples = get_rotation_list(random_orient_samples, n_samples); printf("done\n");*/ /* Initialize with uniform distribution in [0,1) */ Image * restore = sp_image_alloc(sp_image_x(a),sp_image_y(a),sp_image_z(a)); Image * after = sp_image_alloc(sp_image_x(a),sp_image_y(a),sp_image_z(a)); for(int i = 0;i<sp_image_size(a);i++){ restore->image->data[i] = sp_cinit(gsl_rng_uniform(r),0); } image_normalize(restore); sp_image_write(a,"orig.png",COLOR_GRAYSCALE); sp_image_write(avg_samples,"avg_sample.png",COLOR_GRAYSCALE); sp_image_write(avg_random_samples,"avg_random_sample.png",COLOR_GRAYSCALE); for(int iter = 0;;iter++){ tomas_iteration(restore,after,random_orient_samples,n_samples); Image * tmp = restore; restore = after; after = tmp; for(int i = 0;i<sp_image_size(a);i++){ sp_real(after->image->data[i]) = 0; } output_result(a,restore,log,iter); } return 0; }
int main(int argc, char **argv) { gsl_rng_env_setup(); T = gsl_rng_default; r = gsl_rng_alloc (T); gsl_rng_set(r, time(NULL)); Graph *g = new Graph(); g->addVertex(Vertex(1, "v1", 0, 0, 0, 1.0, 1.0, 1.0)); g->addVertex(Vertex(2, "v2", 0, 0, 0, 1.0, 0.2, 0.2)); g->addVertex(Vertex(3, "v3", 0, 0, 0, 0.2, 1.0, 0.2)); g->addVertex(Vertex(4, "v4", 0, 0, 0, 0.2, 0.2, 1.0)); g->addEdge(1, 2); g->addEdge(1, 3); g->addEdge(3, 4); ptr population(new std::vector<Graph>(4, *g)); /* std::cout << "Population" << std::endl; printgraph(population); ptr reproduced = reproduce(population); std::cout << "Reproduced" << std::endl; printgraph(reproduced); ptr offsprings = genetic(reproduced); std::cout << "Offsprings" << std::endl; printgraph(offsprings); population = succession(population, offsprings); std::cout << "After one iteration" << std::endl; printgraph(population); */ int iterationcount = 0; double bestv = best(population); double bestvold = bestv * 2; std::cout << "best " << bestv << "; bestvold " << bestvold << std::endl; while (fabs(bestvold - bestv)/bestvold > 0.00000001) { ++iterationcount; ptr offsprings = genetic(reproduce(population)); population = succession(population, offsprings); bestvold = bestv; bestv = best(population); } std::cout << "Possible result found after " << iterationcount << "iterations: " << std::endl; printgraph(population); const Graph *bestgraph = bestg(population); for (Graph::vertices_const_iterator i = bestgraph->vertices.begin(); i != bestgraph->vertices.end(); ++i) { const Vertex &v = i->second; std::cout << "\"" << v.name << "\""; std::cout << "\t@" << v.x << " " << v.y << " " << v.z; std::cout << "\tcolor" << v.r << " " << v.g << " " << v.b; std::cout << "\tfrozen light size 1.0" << std::endl; } gsl_rng_free (r); return 0; }
//=============================================================== // MAIN Program //=============================================================== int main(int argc, char *argv[]) { printf("numbead %d \n",NUMBEAD); setbuf(stdout,NULL); //=============================================================== // Declare variables and print to std output for reference //=============================================================== //define the Config sturcts. Example: configOld[n].pos[i][j] //where n->Bead i->Particle j->dimension //configOld and configCurrent are switched between when doing MD config *configOld = calloc(NUMBEAD,sizeof(config)); config *configCurrent = calloc(NUMBEAD,sizeof(config)); config *configNew = calloc(NUMBEAD,sizeof(config)); //Used to save positions for MHMC rejection position *savePos = calloc(NUMBEAD,sizeof(position)); //averages averages *tubeAve = calloc(NUMBEAD,sizeof(averages)); double doubleNUMu=(double)NUMu; double doubleNUMl=(double)NUMl; //Parameters double du=DU; double dt=PREDT*DU*DU; double h=sqrt(2.0l*dt); //Incrimenter Declarations int i,j,acc,rej; int MDloopi,MCloopi; int tau=0; //Vectors for doing the L Inverse double *vecdg = calloc(NUMl,sizeof(double));; double *veci0 = calloc(NUMl,sizeof(double));; double *veci1 = calloc(NUMl,sizeof(double));; //double veci1[NUMBEAD-2]; //double veci0[NUMBEAD-2]; // array to store rand nums in double *GaussRandArray = calloc(NUMu,sizeof(double)); //double GaussRandArray[NUMu]; // ratio for incrimenting the MH-MC test double ratio; // storage for brownian bridge double *bb = calloc(NUMu,sizeof(double)); //double bb[NUMBEAD]; // array plot of the average path //int xBinMax=300; //int yBinMax=200; int arrayPlot[300][200]; for(i=0;i<300;i++){ for(j=0;j<200;j++){ arrayPlot[i][j]=0; } } //Print parameters for the run in stdout printf("=======================================================\n"); printf("HMC method for 2D potentials \n"); printf("=======================================================\n"); printf("TEMPERATURE = %f \n",TEMP); printf("=======================================================\n"); printf("Number of Metropolis Hastings steps: %i\n",NUMMC); printf("Number of MD steps: %i \n",NUMMD); printf("=======================================================\n"); printf("Number of Dimensions: %i \n",NUMDIM); printf("Number of Beads: %i \n",NUMBEAD); printf("Path grid: du = %+.8e \n", DU); printf("Sampling Parameters: dt=%f \n",dt); printf("=======================================================\n"); printf("MD step: h=%+.8e \n",h); printf("MD time (n*h): %+.8e \n",NUMMD*h); printf("=======================================================\n"); //=============================================================== // Reading the input configuration file into savepos //=============================================================== //Input file to be read as first command line argument if(argv[1]==NULL) { printf("No input file. Exiting!\n"); exit(-1); } else { printf("Input Configuratrion File: %s\n",argv[1]); } int lineNum = 0; FILE *fptr = fopen(argv[1],"r"); switch(NUMDIM){ case 3: //For 3 Dimensions while( EOF != fscanf(fptr,"%lf %lf %lf", &(savePos[lineNum].pos[0]), &(savePos[lineNum].pos[1]), &(savePos[lineNum].pos[2])) ) { lineNum++; } break; case 2: //For 2 Dimensions while( EOF != fscanf(fptr,"%lf %lf", &(savePos[lineNum].pos[0]), &(savePos[lineNum].pos[1])) ) { lineNum++; } break; case 1: //For 1 Dimension while( EOF != fscanf(fptr,"%lf", &(savePos[lineNum].pos[0])) ) { lineNum++; } break; default: printf("ERROR: NUMDIM incorrectly defined. Exiting!\n"); exit(-1); } //=============================================================== // GNU Scientific Library Random Number Setup //=============================================================== // Example shell command$ GSL_RNG_SEED=123 ./a.out printf("=======================================================\n"); const gsl_rng_type * RanNumType; gsl_rng *RanNumPointer; gsl_rng_env_setup(); RanNumType = gsl_rng_default; RanNumPointer= gsl_rng_alloc (RanNumType); printf("Random Number Generator Type: %s \n", gsl_rng_name(RanNumPointer)); printf("RNG Seed: %li \n", gsl_rng_default_seed); printf("=======================================================\n"); double randUniform; renorm(savePos, DU, doubleNUMu); //=============================================================== // Start of HMC Loop (loops over Metropolis Hastings - MC steps) //=============================================================== printf("START Hybrid Monte Carlo MAIN LOOP\n"); printf("=======================================================\n"); acc=0; rej=0; zeroAverages(tubeAve,&tau); for(MCloopi=1; MCloopi<=NUMMC; MCloopi++) { //zero ratio for MH MC test ratio=0.0l; //=============================================================== // Perform one SPDE step //=============================================================== //store savePos.pos values to configCurrent.pos // savePos.pos stores the positions in case of rejection of the MHMC savePostoConfig(savePos, configCurrent); //(calculates potentials in config given the positions) #pragma omp parallel for for(i=0;i<NUMBEAD;i++) {calcPotentials(configCurrent,i);} //calculate LinvG for the config LInverse(configCurrent, doubleNUMl, du, vecdg, veci1, veci0); //do the preconditioned form of the SPDE preconditionSPDE(configCurrent, configNew, du, dt, doubleNUMu, bb, GaussRandArray, RanNumPointer); //(calculates potentials in config given the positions) #pragma omp parallel for for(i=0;i<NUMBEAD;i++) {calcPotentials(configNew,i);} //calculate LinvG for the config LInverse(configNew, doubleNUMl, du, vecdg, veci1, veci0); //acc ratio of newconfig ProbAccRatio(configCurrent, configNew, dt, du, &ratio); //calculate the averages for the tubes estimator accumulateAverages(tubeAve,configNew,&tau); accumulateArrayPlot(arrayPlot, configNew); printf("SPDE ratio: %+0.10f \n",ratio); //=============================================================== // Start of MD Loop // This loop needs to be focused on for parallelization //=============================================================== for(MDloopi=1;MDloopi<=NUMMD; MDloopi++) { //rotate the configuration rotateConfig(&configOld, &configCurrent, &configNew); //do the MD position update MolecularDynamics(configOld, configCurrent, configNew, du, dt); //(calculates potentials in config given the positions) #pragma omp parallel for for(i=0;i<NUMBEAD;i++) {calcPotentials(configNew,i);} //calculate LinvG for the config LInverse(configNew, doubleNUMl, du, vecdg, veci1, veci0); //calculate the average distance moved in the step and print to std out if(MDloopi%WRITESTDOUT==0){ printf("MDi: %.5d | MDi*h: %0.5f | MD ratio: %+0.5f | distance: ",MDloopi,MDloopi*sqrt(2*dt),ratio); printDistance(configNew, savePos); } //acc ratio of newconfig ProbAccRatio(configCurrent, configNew, dt, du, &ratio); //printf("%i ProbAcc= %+.15e QV Vel= %0.15e \n", MDloopi, ratio, qvvel); //calculate the averages for the tubes estimator accumulateAverages(tubeAve,configNew,&tau); accumulateArrayPlot(arrayPlot, configNew); } //=============================================================== //Metropolis Hastings Monte-Carlo test //=============================================================== randUniform = gsl_rng_uniform(RanNumPointer); if( exp(ratio/SIGMA2) > randUniform ){ acc++; saveConfigtoPos(configNew, savePos); } else{ rej++; } printf("rand=%+0.6f Exp[ratio]=%+0.6f dt= %+0.5e acc= %i rej= %i \n",randUniform,exp(ratio/SIGMA2),dt,acc,rej); // Write the configuration to file if(MCloopi % WRITECONFIGS==0){ normalizeAverages(tubeAve,&tau); writeConfig(configNew,tubeAve,MCloopi); zeroAverages(tubeAve,&tau); writeArrayPlot(arrayPlot, MCloopi); for(i=0;i<300;i++){ for(j=0;j<200;j++){ arrayPlot[i][j]=0; } } } } // GSL random number generator release memory gsl_rng_free (RanNumPointer); return(0); }
int main(void) { double x_min = 1.36312999455315182 ; double x ; gsl_rng * r = gsl_rng_alloc (gsl_rng_env_setup()) ; gsl_ieee_env_setup (); /* The function tested here has multiple mimima. The global minimum is at x = 1.36312999, (f = -0.87287) There is a local minimum at x = 0.60146196, (f = -0.84893) */ x = -10.0 ; gsl_siman_solve(r, &x, E1, S1, M1, NULL, NULL, NULL, NULL, sizeof(double), params); gsl_test_rel(x, x_min, 1e-3, "f(x)= exp(-(x-1)^2) sin(8x), x0=-10") ; x = +10.0 ; gsl_siman_solve(r, &x, E1, S1, M1, NULL, NULL, NULL, NULL, sizeof(double), params); gsl_test_rel(x, x_min, 1e-3, "f(x)= exp(-(x-1)^2) sin(8x), x0=10") ; /* Start at the false minimum */ x = +0.6 ; gsl_siman_solve(r, &x, E1, S1, M1, NULL, NULL, NULL, NULL, sizeof(double), params); gsl_test_rel(x, x_min, 1e-3, "f(x)= exp(-(x-1)^2) sin(8x), x0=0.6") ; x = +0.5 ; gsl_siman_solve(r, &x, E1, S1, M1, NULL, NULL, NULL, NULL, sizeof(double), params); gsl_test_rel(x, x_min, 1e-3, "f(x)= exp(-(x-1)^2) sin(8x), x0=0.5") ; x = +0.4 ; gsl_siman_solve(r, &x, E1, S1, M1, NULL, NULL, NULL, NULL, sizeof(double), params); gsl_test_rel(x, x_min, 1e-3, "f(x)= exp(-(x-1)^2) sin(8x), x0=0.4") ; exit (gsl_test_summary ()); #ifdef JUNK x0.D1 = 12.0; printf("#one dimensional problem, x0 = %f\n", x0.D1); gsl_siman_Usolve(r, &x0, test_E_1D, test_step_1D, distance_1D, print_pos_1D, params); x0.D2[0] = 12.0; x0.D2[1] = 5.5; printf("#two dimensional problem, (x0,y0) = (%f,%f)\n", x0.D2[0], x0.D2[1]); gsl_siman_Usolve(r, &x0, test_E_2D, test_step_2D, distance_2D, print_pos_2D, params); x0.D3[0] = 12.2; x0.D3[1] = 5.5; x0.D3[2] = -15.5; printf("#three dimensional problem, (x0,y0,z0) = (%f,%f,%f)\n", x0.D3[0], x0.D3[1], x0.D3[2]); gsl_siman_Usolve(r, &x0, test_E_3D, test_step_3D, distance_3D, print_pos_3D, params); x0.D2[0] = 12.2; x0.D2[1] = 5.5; gsl_siman_solve(r, &x0, test_E_2D, test_step_2D, distance_2D, print_pos_2D, params); x0.D3[0] = 12.2; x0.D3[1] = 5.5; x0.D3[2] = -15.5; gsl_siman_solve(r, &x0, test_E_3D, test_step_3D, distance_3D, print_pos_3D, params); return 0; #endif }
double thermo_sa(double temp_init, double temp_end, double temp_sig, double initstate, double bm_sigma, double k, FILE * log) { double energy, energy_new, energy_delta, energy_variation; int *path; double temp, temp_old; double prob; double rot_old, best_rot; double entropy_variation; double energy_best; gsl_rng *acpt_rng; unsigned long time = 0; double BM; /* * Initialize the random number generators. */ _bm_rng = gsl_rng_alloc(gsl_rng_taus); acpt_rng = gsl_rng_alloc(gsl_rng_taus); temp = temp_init; rotation = initstate; /* * Compute the first path. */ path = renormalize(); energy = route_length(path, tsp->dimension); free(path); energy_best = energy; entropy_variation = 0; energy_variation = 0; /* * Print the log headers. */ if (log != NULL) (void) fprintf(log, "time T E_n E_d E_v E_b S_v rb r rv bm\n"); do { temp_old = temp; rot_old = rotation; if (log != NULL) (void) fprintf(log, "%lu ", time); BM = neighbour_rot(temp, temp_end, temp_init, bm_sigma); if(fpclassify(rotation) == FP_NAN) errx(EX_DATAERR, "Rotation can not be NaN"); path = renormalize(); energy_new = route_length(path, tsp->dimension); free(path); energy_delta = energy_new - energy; prob = exp(-energy_delta / temp); if (log != NULL) (void)fprintf(log, "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf\n", temp, energy_new, energy_delta, energy_variation, energy_best, entropy_variation, best_rot, rotation, (rotation - rot_old), BM); if (gsl_rng_uniform(acpt_rng) < prob) { if (energy_best > energy) { energy_best = energy; best_rot = rot_old; } energy = energy_new; energy_variation += energy_delta; } else rotation = rot_old; if (energy_delta > 0) entropy_variation -= energy_delta / temp; if ((energy_variation >= 0) || fabs(entropy_variation) < 0.000001) temp = temp_init; else { temp = k * (energy_variation / entropy_variation); //rotation = best_rot; } time++; } while ((temp > temp_end) || (fabs(temp - temp_old) > temp_sig)); gsl_rng_free(acpt_rng); gsl_rng_free(_bm_rng); return energy_best; }
void test(int max, int size) { std::vector<double> a; std::vector<int> b; double d[size]; for(int i = 0; i<size; i++) { a.push_back(1.0/size); b.push_back(1); d[i] = rand();; } //s += std::to_string(max); //s += "\t"; s += std::to_string(size); s += "\t"; int sum = 0; std::cout << std::endl << "Max: " << max << ";\t Size: " << size << std::endl << std::endl; boost::mt19937 gen; const gsl_rng_type * T; gsl_rng * r; gsl_rng_env_setup(); T = gsl_rng_default; r = gsl_rng_alloc(T); RandomLib::Random r2; sum = 0; clock_t startTime = clock(); //RandomLib sum = 0; startTime = clock(); RandomLib::RandomSelect<int> sel(b.begin(), b.end()); s += std::to_string(clock() - startTime); s += "\t"; std::cout << "\t RandomLib: " << std::endl << "\t\t Initiate: " << clock() - startTime << std::endl; startTime = clock(); for(int i = 0; i < max; i++) { sum += sel(r2); } s += std::to_string(clock() - startTime); s += "\t"; std::cout << "\t\t Generate: " << clock() - startTime << std::endl << "\t\t Sum: " << sum << std::endl; //gnu science sum = 0; startTime = clock(); gsl_ran_discrete_t * table = gsl_ran_discrete_preproc(size, d); s += std::to_string(clock() - startTime); s += "\t"; std::cout << "\t Gnu Science: " << std::endl << "\t\t Initiate: " << clock() - startTime << std::endl; startTime = clock(); for(int i = 0; i < max; i++) { sum += gsl_ran_discrete(r, table); } s += std::to_string(clock() - startTime); s += "\t"; std::cout << "\t\t Generate: " << clock() - startTime << std::endl << "\t\t Sum: " << sum << std::endl; gsl_rng_free(r); //boost sum = 0; startTime = clock(); boost::random::discrete_distribution<> dist(a.begin(), a.end()); //boost::random::discrete_distribution<> dist(b, b+size); s += std::to_string(clock() - startTime); s += "\t"; std::cout << "\t Boost: " << std::endl << "\t\t Initiate: " << clock() - startTime << std::endl; startTime = clock(); for(int i = 0; i < max; i++) { sum += dist(gen); } s += std::to_string(clock() - startTime); s += "\t"; std::cout << "\t\t Generate: " << clock() - startTime << std::endl << "\t\t Sum: " << sum << std::endl; //std::dsicrete_distribution sum = 0; startTime = clock(); std::discrete_distribution<int> std_dist(b.begin(), b.end()); s += std::to_string(clock() - startTime); s += "\t"; std::cout << "\t std::discrete_distribution: " << std::endl << "\t\t Initiate: " << clock() - startTime << std::endl; startTime = clock(); for(int i = 0; i < max; i++) { sum += std_dist(gen); } s += std::to_string(clock() - startTime); s += "\t"; std::cout << "\t\t Generate: " << clock() - startTime << std::endl << "\t\t Sum: " << sum << std::endl; /* //table-lookup sum = 0; startTime = clock(); random_distribution q(a); s += std::to_string(clock() - startTime); s += "\t"; std::cout << "\t Method 1: " << std::endl << "\t\t Initiate: " << clock() - startTime << std::endl; startTime = clock(); for(int i = 0; i < max; i++) { sum += q.dist(); } s += std::to_string(clock() - startTime); s += "\t"; std::cout << "\t\t Generate: " << clock() - startTime << std::endl << "\t\t Sum: " << sum << std::endl; //std::cout << "\t\t i0: " << q.i0 << "\t i1: " << q.i1 << "\t i2: " << q.i2 << "\t i3: " << q.i3 << std::endl; //table-lookup + histogram sum = 0; startTime = clock(); random_distribution q2(a,2); s += std::to_string(clock() - startTime); s += "\t"; std::cout << "\t Method 2: " << std::endl << "\t\t Initiate: " << clock() - startTime << std::endl; startTime = clock(); for(int i = 0; i < max; i++) { sum += q2.dist2(); } s += std::to_string(clock() - startTime); s += "\t"; std::cout << "\t\t Generate: " << clock() - startTime << std::endl << "\t\t Sum: " << sum << std::endl; //binary search sum = 0; startTime = clock(); random_distribution q3(a,3); s += std::to_string(clock() - startTime); s += "\t"; std::cout << "\t Method 3: " << std::endl << "\t\t Initiate: " << clock() - startTime << std::endl; startTime = clock(); for(int i = 0; i < max; i++) { sum += q3.dist3(); } s += std::to_string(clock() - startTime); s += "\t"; std::cout << "\t\t Generate: " << clock() - startTime << std::endl << "\t\t Sum: " << sum << std::endl; */ s += "\n"; }
int main (void) { const gsl_multifit_fdfsolver_type *T; gsl_multifit_fdfsolver *s; int status; unsigned int i, iter = 0; const size_t n = N; const size_t p = 3; gsl_matrix *covar = gsl_matrix_alloc (p, p); double y[N], sigma[N]; struct data d = { n, y, sigma}; gsl_multifit_function_fdf f; double x_init[3] = { 1.0, 0.0, 0.0 }; gsl_vector_view x = gsl_vector_view_array (x_init, p); const gsl_rng_type * type; gsl_rng * r; gsl_rng_env_setup(); type = gsl_rng_default; r = gsl_rng_alloc (type); f.f = &expb_f; f.df = &expb_df; f.fdf = &expb_fdf; f.n = n; f.p = p; f.params = &d; /* This is the data to be fitted */ for (i = 0; i < n; i++) { double t = i; y[i] = 1.0 + 5 * exp (-0.1 * t) + gsl_ran_gaussian (r, 0.1); sigma[i] = 0.1; printf ("data: %u %g %g\n", i, y[i], sigma[i]); }; T = gsl_multifit_fdfsolver_lmsder; s = gsl_multifit_fdfsolver_alloc (T, n, p); gsl_multifit_fdfsolver_set (s, &f, &x.vector); print_state (iter, s); do { iter++; status = gsl_multifit_fdfsolver_iterate (s); printf ("status = %s\n", gsl_strerror (status)); print_state (iter, s); if (status) break; status = gsl_multifit_test_delta (s->dx, s->x, 1e-4, 1e-4); } while (status == GSL_CONTINUE && iter < 500); gsl_multifit_covar (s->J, 0.0, covar); #define FIT(i) gsl_vector_get(s->x, i) #define ERR(i) sqrt(gsl_matrix_get(covar,i,i)) { double chi = gsl_blas_dnrm2(s->f); double dof = n - p; double c = GSL_MAX_DBL(1, chi / sqrt(dof)); printf("chisq/dof = %g\n", pow(chi, 2.0) / dof); printf ("A = %.5f +/- %.5f\n", FIT(0), c*ERR(0)); printf ("lambda = %.5f +/- %.5f\n", FIT(1), c*ERR(1)); printf ("b = %.5f +/- %.5f\n", FIT(2), c*ERR(2)); } printf ("status = %s\n", gsl_strerror (status)); gsl_multifit_fdfsolver_free (s); gsl_matrix_free (covar); gsl_rng_free (r); return 0; }
/** * @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; float **ref_histos, histo_aux[1][HTAM]; CvCapture *video; particle **particles, **aux, **nuevas_particulas; CvScalar color_rojo = CV_RGB(255,0,0), color_azul = CV_RGB(0,0,255); float factor = 1.0 / 255.0, sum = 0.0f; CvRect *regions; int num_objects = 0; int 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); } int nFrames = (int) cvGetCaptureProperty( video , CV_CAP_PROP_FRAME_COUNT ); first_frame = cvQueryFrame( video ); num_objects = get_regions( ®ions, MAX_OBJECTS, argv[1] ); if( num_objects == 0 ) exit(-1); t_ini = clock(); // 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)); hsv_frame = bgr2hsv( first_frame ); 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( "RGB", 1 ); cvShowImage( "RGB", 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"); exit(-1);; } fprintf( datos, "%d\t%f\t%f\n", 0, particles[k][0].x, particles[k][0].y ); fclose( datos ); } } // Bucle principal!! for(int i = 1; i < nFrames; ++i) { // Recordar que frame no se puede liberar debido al cvQueryFrame frame = cvQueryFrame( video ); for( int f = 0 ; f < hsv_frame->height; ++f ) { float *ptrHSV = (float*) ( hsv_frame->imageData + hsv_frame->widthStep*f ); unsigned char *ptrRGB = (unsigned char*) ( frame->imageData + frame->widthStep*f ); float h; for( int col = 0, despH = 0; col < hsv_frame->width; ++col, despH+=3 ) { int despS = despH+1; int despV = despH+2; float b = ptrRGB[despH] * factor; float g = ptrRGB[despS] * factor; float r = ptrRGB[despV] * factor; float min = MIN(MIN(b, g), r); float max = MAX(MAX(b, g), r); ptrHSV[despV] = max; // v if( max != min ) { float delta = max - min; ptrHSV[despS] = delta / max; // s = (max - min) / max = 1.0 - (min / max) if( r == max ) h = ( g - b ) / delta; else if( g == max ) h = 2.0f + (( b - r ) / delta); else h = 4.0f + (( r - g ) / delta); h *= 60.0f; if(h < 0.0f) h += 360.0f; ptrHSV[despH] = h; // h } else { ptrHSV[despH] = 0.0f; // h ptrHSV[despS] = 0.0f; // s } } } // Realizamos la predicción y medición de probabilidad para cada partícula for( int k = 0; k < num_objects; ++k ) { sum = 0.0f; 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[0] ); sum += particles[k][j].w; } // Normalizamos los pesos y remuestreamos un conjunto de partículas no ponderadas for( int j = 0; j < PARTICLES; ++j ) particles[k][j].w /= sum; } // Remuestreamos un conjunto de partículas no ponderadas 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( "RGB", 1 ); cvShowImage( "RGB", 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"); exit(-1); } fprintf( datos, "%d\t%f\t%f\n", i, particles[k][0].x, particles[k][0].y ); fclose( datos ); } } } // Liberamos todos los recursos usados (mallocs, gsl y frames) cvReleaseImage( &hsv_frame ); cvReleaseCapture( &video ); gsl_rng_free( rng ); 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); }
int main(int argc, char** argv) { if (argc < 2 || !strcmp(argv[1], "-help") || !strcmp(argv[1], "--help") || !strcmp(argv[1], "-h") || !strcmp(argv[1], "--usage")) { print_usage_and_exit(); } double gamma_a = 1.0, gamma_b = 1.0, alpha_a = 1.0, alpha_b = 1.0, eta = 0.5; int max_iter = 1000, save_lag = 100, init_topics = 0; bool sample_hyperparameter = false; bool split_merge = false; int num_restricted_scan = 5; time_t t; time(&t); long seed = (long) t; char* directory = NULL;; char* algorithm = NULL;; char* data_path = NULL; char* model_path = NULL; for (int i = 1; i < argc; i++) { if (!strcmp(argv[i], "--algorithm")) algorithm = argv[++i]; else if (!strcmp(argv[i], "--data")) data_path = argv[++i]; else if (!strcmp(argv[i], "--max_iter")) max_iter = atoi(argv[++i]); else if (!strcmp(argv[i], "--save_lag")) save_lag = atoi(argv[++i]); else if (!strcmp(argv[i], "--init_topics")) init_topics = atoi(argv[++i]); else if (!strcmp(argv[i], "--directory")) directory = argv[++i]; else if (!strcmp(argv[i], "--random_seed")) seed = atoi(argv[++i]); else if (!strcmp(argv[i], "--gamma_a")) gamma_a = atof(argv[++i]); else if (!strcmp(argv[i], "--gamma_b")) gamma_b = atof(argv[++i]); else if (!strcmp(argv[i], "--alpha_a")) alpha_a = atof(argv[++i]); else if (!strcmp(argv[i], "--alpha_b")) alpha_b = atof(argv[++i]); else if (!strcmp(argv[i], "--eta")) eta = atof(argv[++i]); else if (!strcmp(argv[i], "--restrict_scan")) num_restricted_scan = atoi(argv[++i]); else if (!strcmp(argv[i], "--saved_model")) model_path = argv[++i]; else if (!strcmp(argv[i], "--split_merge")) { ++i; if (!strcmp(argv[i], "yes") || !strcmp(argv[i], "YES")) split_merge = true; } else if (!strcmp(argv[i], "--sample_hyper")) { ++i; if (!strcmp(argv[i], "yes") || !strcmp(argv[i], "YES")) sample_hyperparameter = true; } else { printf("%s, unknown parameters, exit\n", argv[i]); exit(0); } } if (algorithm == NULL || directory == NULL || data_path == NULL) { printf("Note that algorithm, directory and data are not optional!\n"); exit(0); } if (VERBOSE && !strcmp(algorithm, "train")) { printf("\nProgram starts with following parameters:\n"); printf("algorithm: = %s\n", algorithm); printf("data_path: = %s\n", data_path); printf("directory: = %s\n", directory); printf("max_iter = %d\n", max_iter); printf("save_lag = %d\n", save_lag); printf("init_topics = %d\n", init_topics); printf("random_seed = %d\n", seed); printf("gamma_a = %.2f\n", gamma_a); printf("gamma_b = %.2f\n", gamma_b); printf("alpha_a = %.2f\n", alpha_a); printf("alpha_b = %.2f\n", alpha_b); printf("eta = %.2f\n", eta); printf("#restricted_scans = %d\n", num_restricted_scan); if (model_path != NULL) printf("saved model_path = %s\n", model_path); if (split_merge) printf("split-merge = yes\n"); else printf("split-merge = no\n"); if (sample_hyperparameter) printf("sampling hyperparam = yes\n"); else printf("sampling hyperparam = no\n"); } if (!dir_exists(directory)) mkdir(directory, S_IRUSR | S_IWUSR | S_IXUSR); // allocate the random number structure RANDOM_NUMBER = gsl_rng_alloc(gsl_rng_taus); gsl_rng_set(RANDOM_NUMBER, (long) seed); // init the seed if (!strcmp(algorithm, "train")) { // read data corpus * c = new corpus(); c->read_data(data_path); // read hyperparameters hdp_hyperparameter * hdp_hyperparam = new hdp_hyperparameter(); hdp_hyperparam->setup_parameters(gamma_a, gamma_b, alpha_a, alpha_b, max_iter, save_lag, num_restricted_scan, sample_hyperparameter, split_merge); hdp * hdp_instance = new hdp(); hdp_instance->setup_state(c, eta, init_topics, hdp_hyperparam); hdp_instance->run(directory); // free resources delete hdp_instance; delete c; delete hdp_hyperparam; } if (!strcmp(algorithm, "test")) { corpus* c = new corpus(); c->read_data(data_path); hdp_hyperparameter * hdp_hyperparam = new hdp_hyperparameter(); hdp_hyperparam->setup_parameters(gamma_a, gamma_b, alpha_a, alpha_b, max_iter, save_lag, num_restricted_scan, sample_hyperparameter, split_merge); hdp * hdp_instance = new hdp(); hdp_instance->load(model_path); hdp_instance->setup_state(c, hdp_hyperparam); hdp_instance->run_test(directory); delete hdp_hyperparam; delete hdp_instance; delete c; } gsl_rng_free(RANDOM_NUMBER); }
int main(int argc, char *argv[]) { struct options options; INT8 tinj, jitter; gsl_rng *rng; ProcessTable *process_table_head = NULL, *process; ProcessParamsTable *process_params_table_head = NULL; SearchSummaryTable *search_summary_table_head = NULL, *search_summary; TimeSlide *time_slide_table_head = NULL; SimBurst *sim_burst_table_head = NULL; SimBurst **sim_burst = &sim_burst_table_head; /* * Initialize debug handler */ lal_errhandler = LAL_ERR_EXIT; /* * Process table */ process_table_head = process = XLALCreateProcessTableRow(); if(XLALPopulateProcessTable(process, PROGRAM_NAME, lalAppsVCSIdentId, lalAppsVCSIdentStatus, lalAppsVCSIdentDate, 0)) exit(1); XLALGPSTimeNow(&process->start_time); /* * Command line and process params table. */ options = parse_command_line(&argc, &argv, process, &process_params_table_head); if(options.user_tag) snprintf(process->comment, sizeof(process->comment), "%s", options.user_tag); /* * Search summary table */ search_summary_table_head = search_summary = XLALCreateSearchSummaryTableRow(process); if(options.user_tag) snprintf(search_summary->comment, sizeof(search_summary->comment), "%s", options.user_tag); search_summary->nnodes = 1; search_summary->out_start_time = *XLALINT8NSToGPS(&search_summary->in_start_time, options.gps_start_time); search_summary->out_end_time = *XLALINT8NSToGPS(&search_summary->in_end_time, options.gps_end_time); /* * Initialize random number generator */ rng = gsl_rng_alloc(gsl_rng_mt19937); if(options.seed) gsl_rng_set(rng, options.seed); /* * Main loop */ for(tinj = options.gps_start_time; tinj <= options.gps_end_time; tinj += options.time_step * 1e9) { /* * Progress bar. */ XLALPrintInfo("%s: ", argv[0]); XLALPrintProgressBar((tinj - options.gps_start_time) / (double) (options.gps_end_time - options.gps_start_time)); XLALPrintInfo(" complete\n"); /* * Create an injection */ switch(options.population) { case POPULATION_TARGETED: *sim_burst = random_directed_btlwnb(options.ra, options.dec, gsl_ran_flat(rng, 0, LAL_TWOPI), options.minf, options.maxf, options.minbandwidth, options.maxbandwidth, options.minduration, options.maxduration, options.minEoverr2, options.maxEoverr2, rng); break; case POPULATION_ALL_SKY_SINEGAUSSIAN: *sim_burst = random_all_sky_sineGaussian(options.minf, options.maxf, options.q, options.minhrss, options.maxhrss, rng); break; case POPULATION_ALL_SKY_BTLWNB: *sim_burst = random_all_sky_btlwnb(options.minf, options.maxf, options.minbandwidth, options.maxbandwidth, options.minduration, options.maxduration, options.minEoverr2, options.maxEoverr2, rng); break; case POPULATION_STRING_CUSP: *sim_burst = random_string_cusp(options.minf, options.maxf, options.minA, options.maxA, rng); break; default: /* shouldn't get here, command line parsing code * should prevent it */ XLALPrintError("internal error\n"); exit(1); } if(!*sim_burst) { XLALPrintError("can't make injection\n"); exit(1); } /* * Peak time at geocentre in GPS seconds */ /* Add "jitter" to the injection if user requests it */ if(options.jitter > 0) { jitter = gsl_ran_flat(rng, -options.jitter/2, options.jitter/2)*1e9; } else { jitter = 0; } XLALINT8NSToGPS(&(*sim_burst)->time_geocent_gps, tinj + jitter); /* * Peak time at geocentre in GMST radians */ (*sim_burst)->time_geocent_gmst = XLALGreenwichMeanSiderealTime(&(*sim_burst)->time_geocent_gps); /* * Move to next injection */ sim_burst = &(*sim_burst)->next; } XLALPrintInfo("%s: ", argv[0]); XLALPrintProgressBar(1.0); XLALPrintInfo(" complete\n"); /* load time slide document and merge our table rows with its */ if(load_tisl_file_and_merge(options.time_slide_file, &process_table_head, &process_params_table_head, &time_slide_table_head, &search_summary_table_head, &sim_burst_table_head)) exit(1); if(set_instruments(process, time_slide_table_head)) exit(1); snprintf(search_summary->ifos, sizeof(search_summary->ifos), "%s", process->ifos); /* output */ XLALGPSTimeNow(&process->end_time); search_summary->nevents = XLALSimBurstAssignIDs(sim_burst_table_head, process->process_id, time_slide_table_head->time_slide_id, 0); write_xml(options.output, process_table_head, process_params_table_head, search_summary_table_head, time_slide_table_head, sim_burst_table_head); /* done */ gsl_rng_free(rng); XLALDestroyProcessTable(process_table_head); XLALDestroyProcessParamsTable(process_params_table_head); XLALDestroyTimeSlideTable(time_slide_table_head); XLALDestroySearchSummaryTable(search_summary_table_head); XLALDestroySimBurstTable(sim_burst_table_head); exit(0); }
int main(int argc, char *argv[]) { if (argc != 2) { cout << "Usage: setup outfilename" << endl; return(-1); } string filename = argv[1]; vector<Cparticle> ps; Cparticle p; cout << "Creating box with sides: rmax = ["<<RMAX[0]<<" "<<RMAX[1]<<"] rmin = ["<<RMIN[0]<<" "<<RMIN[1]<<"]"<<endl; cout << "Reynolds Number = "<<REYNOLDS_NUMBER<<endl; cout << "Density = "<<DENS<<endl; cout << "number of particles on side = "<<NX<<endl; cout << "alpha = "<<ALPHA<<endl; cout << "viscosity = "<<VISCOSITY<<endl; cout << "maxtime = "<<MAXTIME<<endl; double tsc = Nsph::courantCondition(H,2*SPSOUND); double tsv = Nsph::viscDiffusionCondition(H,VISCOSITY); cout <<"simulation will take "<<int((MAXTIME/tsc)+1)<<" steps according to Courant condition, "<<int((MAXTIME/tsv)+1)<<" steps according to visc diffusion condition"<<endl; gsl_rng *rng = gsl_rng_alloc(gsl_rng_ranlxd1); gsl_rng_set(rng,1); //gsl_rng_set(rng,time(NULL)); for (int i=0;i<NX;i++) { cout << "\rParticle ("<<i<<","<<"0"<<"). Generation "<<((i+2)*(NY+4))/double((NX+4)*(NY+4))*100<<"\% complete"<<flush; for (int j=0;j<NY;j++) { p.tag = ps.size()+1; p.r = (i+0.5)*PSEP+RMIN[0],(j+0.5)*PSEP+RMIN[1]; p.dens = DENS; p.mass = PSEP*PSEP*DENS; p.h = H; p.v = -VREF*cos(2.0*PI*p.r[0])*sin(2.0*PI*p.r[1]),VREF*sin(2.0*PI*p.r[0])*cos(2.0*PI*p.r[1]); p.v[0] += gsl_ran_gaussian(rng,VREF/20); p.v[1] += gsl_ran_gaussian(rng,VREF/20); p.v[2] += gsl_ran_gaussian(rng,VREF/20); p.vhat = p.v; p.iam = sph; ps.push_back(p); } } cout << "Total number of particles = " << ps.size() << endl; CglobalVars globals; vector<vector<double> > vprocDomain(globals.mpiSize); vector<Array<int,NDIM> > vprocNeighbrs(globals.mpiSize); vector<particleContainer > vps; vectInt split; split = 1,1; particleContainer pps; for (int i=0;i<ps.size();i++) { pps.push_back(ps[i]); } Nmisc::splitDomain(pps,split,vps,vprocDomain,vprocNeighbrs); cout << "Opening files for writing..."<<endl; Cio_data_vtk ioFile(filename.c_str(),&globals); cout << "Writing Restart data to file..."<<endl; int nProc = product(split); for (int i=0;i<nProc;i++) { globals.mpiRank = i; for (int j=0;j<NDIM*2;j++) globals.procDomain[j] = vprocDomain[i][j]; globals.procNeighbrs = vprocNeighbrs[i]; ioFile.setFilename(filename.c_str(),&globals); ioFile.writeGlobals(0,&globals); ioFile.writeRestart(0,vps[i],&globals); ioFile.writeDomain(0,&globals); globals.mpiRank = 0; } }
int main() { // setup random number generator gRandomGenerator = gsl_rng_alloc(gsl_rng_taus); gsl_rng_set (gRandomGenerator, 0.0); // created a rapidity cut named "eta", which returns true if the passed track has a // pseudo-rapidity greater than 0.1 Cut c0("eta", new eta_greator(0.1)); // add some other cuts acting on different ranges c0.AddCut("zab>2", new eta_greator(2.0))(new eta_greator(5.0))(new eta_greator(8.0)); // Create a pt cut Cut pt_cut("pt>3", new pt_greator(3.0)); // Create a pt cut Cut pt_cut("pt>3.0", new pt_greator(3.0)); // add some more cuts to the pt-cut group // (Cut::AddCut returns an inserter with operator() which // continues to insert if given a name + function pair) pt_cut.AddCut("pt>4.0", new pt_greator(4.0)) ("pt>6.0", new pt_greator(6.0)) ("pt>2.0", new pt_greator(2.0)) ("pt>1.0", new pt_greator(1.0)); // create a cutlist CutList cuts; cuts.AddCut(pt_cut); // cuts.AddAction("eta", add_to_histogram_eta_1); // cuts.AddAction("pt>3 zab>2", add_to_histogram_1); // cuts.AddAction("pt>3 eta", add_to_histogram_4); cuts.AddAction("pt>3.0", action_pt_3_0); cuts.AddAction("pt>4.0", action_pt_4_0); cuts.AddAction("pt>1.0", action_pt_1_0); cuts.AddAction("pt>2.0", action_pt_2_0); cuts.AddAction("pt>6.0", action_pt_6_0); cuts.AddAction("pt>4.0 pt>2.0", action_pt_4_AND_2); // cuts.Print(); // generate a random cut Track track = Generate(); track.print(); std::cout << "Testing Random : " << cuts.Run(track) << std::endl; for (int i = 0; i < 50; i++) { Track t = Generate(); // std::cout << "Mass : " << t.m << std::endl; cuts.Run(t); } // std::cout << c0.Run(1.0f) << ' ' << c0.Run(9.0f) << std::endl; puts(""); std::cout << "Pt > 1.0 Count : " << pt_1_count << std::endl << "Pt > 2.0 Count : " << pt_2_count << std::endl << "Pt > 3.0 Count : " << pt_3_count << std::endl << "Pt > 4.0 Count : " << pt_4_count << std::endl << "Pt > 6.0 Count : " << pt_6_count << std::endl; std::cout << "It works!" << std::endl; return 0; }
int main() { gsl_rng *r = gsl_rng_alloc(gsl_rng_default); const double tol1 = 1.0e-8; const double tol2 = 1.0e-3; gsl_ieee_env_setup(); { const size_t N = 2000000; double *data = random_data(N, r); double data2[] = { 4.0, 7.0, 13.0, 16.0 }; size_t i; test_basic(2, data, tol1); test_basic(100, data, tol1); test_basic(1000, data, tol1); test_basic(10000, data, tol1); test_basic(50000, data, tol1); test_basic(80000, data, tol1); test_basic(1500000, data, tol1); test_basic(2000000, data, tol1); for (i = 0; i < 4; ++i) data2[i] += 1.0e9; test_basic(4, data2, tol1); free(data); } { /* dataset from Jain and Chlamtac paper */ const size_t n_jain = 20; const double data_jain[] = { 0.02, 0.15, 0.74, 3.39, 0.83, 22.37, 10.15, 15.43, 38.62, 15.92, 34.60, 10.28, 1.47, 0.40, 0.05, 11.39, 0.27, 0.42, 0.09, 11.37 }; double expected_jain = 4.44063435326; test_quantile(0.5, data_jain, n_jain, expected_jain, tol1, "jain"); } { size_t n = 1000000; double *data = malloc(n * sizeof(double)); double *sorted_data = malloc(n * sizeof(double)); gsl_rstat_workspace *rstat_workspace_p = gsl_rstat_alloc(); double p; size_t i; for (i = 0; i < n; ++i) { data[i] = gsl_ran_gaussian_tail(r, 1.3, 1.0); gsl_rstat_add(data[i], rstat_workspace_p); } memcpy(sorted_data, data, n * sizeof(double)); gsl_sort(sorted_data, 1, n); /* test quantile calculation */ for (p = 0.1; p <= 0.9; p += 0.1) { double expected = gsl_stats_quantile_from_sorted_data(sorted_data, 1, n, p); test_quantile(p, data, n, expected, tol2, "gauss"); } /* test mean, variance */ { const double expected_mean = gsl_stats_mean(data, 1, n); const double expected_var = gsl_stats_variance(data, 1, n); const double expected_sd = gsl_stats_sd(data, 1, n); const double expected_skew = gsl_stats_skew(data, 1, n); const double expected_kurtosis = gsl_stats_kurtosis(data, 1, n); const double expected_median = gsl_stats_quantile_from_sorted_data(sorted_data, 1, n, 0.5); const double mean = gsl_rstat_mean(rstat_workspace_p); const double var = gsl_rstat_variance(rstat_workspace_p); const double sd = gsl_rstat_sd(rstat_workspace_p); const double skew = gsl_rstat_skew(rstat_workspace_p); const double kurtosis = gsl_rstat_kurtosis(rstat_workspace_p); const double median = gsl_rstat_median(rstat_workspace_p); gsl_test_rel(mean, expected_mean, tol1, "mean"); gsl_test_rel(var, expected_var, tol1, "variance"); gsl_test_rel(sd, expected_sd, tol1, "stddev"); gsl_test_rel(skew, expected_skew, tol1, "skew"); gsl_test_rel(kurtosis, expected_kurtosis, tol1, "kurtosis"); gsl_test_abs(median, expected_median, tol2, "median"); } free(data); free(sorted_data); gsl_rstat_free(rstat_workspace_p); } gsl_rng_free(r); exit (gsl_test_summary()); }
int main (int argc, char *argv[]) { double ratio,ns; // 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[10]={4.5,0.0,-2000.0,-2000.0,-2000.0,-550.0,-450.0,-350.0,-3.1415926, -5.0*3.1415926/180.0}; double xl_x[10]={4.5,0.0,-2000.0,-2000.0,-2000.0,-550.0,-450.0,-350.0,0.0001, -5.0*3.1415926/180.0}; double xu_x[10]={11.5,8.0,2000.0,2000.0,2000.0,550.0,450.0,350.0,3.1415926, 5.0*3.1415926/180.0}; const gsl_rng_type *T_x; gsl_rng *r_x; gsl_monte_function G_x={&g_psr,10,0}; size_t calls_x=50000000; gsl_rng_env_setup (); T_x=gsl_rng_default; // neutron stars, pulsar to disk double res_xd,err_xd; //double xl_x[4]={3.0,0.0,-2000.0,-2000.0}; //double xu_x[4]={13.0,13.0,2000.0,2000.0}; //double xl_xd[10]={0.0,0.0,-2000.0,-2000.0,-2000.0,-100.0,-150.0,-100.0,-3.1415926, -5.0*3.1415926/180.0}; double xl_xd[10]={0.0,0.0,-2000.0,-2000.0,-2000.0,-100.0,-150.0,-100.0,0.0001, -5.0*3.1415926/180.0}; double xu_xd[10]={11.5,8.0,2000.0,2000.0,2000.0,100.0,150.0,100.0,3.1415926, 5.0*3.1415926/180.0}; const gsl_rng_type *T_xd; gsl_rng *r_xd; gsl_monte_function G_xd={&g_psr_disk,10,0}; size_t calls_xd=50000000; T_xd=gsl_rng_default; //////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////// // source bulge double res_s,err_s; double xl_s[3]={4.5,-3.1415926, -5.0*3.1415926/180.0}; double xu_s[3]={11.5,3.1415926, 5.0*3.1415926/180.0}; const gsl_rng_type *T_s; gsl_rng *r_s; gsl_monte_function G_s={&source,3,0}; size_t calls_s=50000000; T_s=gsl_rng_default; r_s = gsl_rng_alloc (T_s); gsl_monte_vegas_state *s_s = gsl_monte_vegas_alloc (3); gsl_monte_vegas_integrate (&G_s, xl_s, xu_s, 3, 10000, r_s, s_s, &res_s, &err_s); do { gsl_monte_vegas_integrate (&G_s, xl_s, xu_s, 3, 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); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// // source disk double res_sd,err_sd; double xl_sd[3]={0.0,-3.1415926, -5.0*3.1415926/180.0}; double xu_sd[3]={11.5,3.1415926, 5.0*3.1415926/180.0}; const gsl_rng_type *T_sd; gsl_rng *r_sd; gsl_monte_function G_sd={&source_d,3,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 (3); gsl_monte_vegas_integrate (&G_sd, xl_sd, xu_sd, 3, 10000, r_sd, s_sd, &res_sd, &err_sd); do { gsl_monte_vegas_integrate (&G_sd, xl_sd, xu_sd, 3, 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); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// r_x=gsl_rng_alloc(T_x); gsl_monte_vegas_state *s_x = gsl_monte_vegas_alloc (10); r_xd=gsl_rng_alloc(T_xd); gsl_monte_vegas_state *s_xd = gsl_monte_vegas_alloc (10); // calculation gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 10, 10000, r_x, s_x,&res_x, &err_x); do { gsl_monte_vegas_integrate (&G_x, xl_x, xu_x, 10, calls_x/5, r_x, s_x,&res_x, &err_x); } while (fabs (gsl_monte_vegas_chisq (s_x) - 1.0) > 0.5); ///////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////// gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 10, 10000, r_xd, s_xd, &res_xd, &err_xd); do { gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 10, calls_xd/5, r_xd, s_xd, &res_xd, &err_xd); } while (fabs (gsl_monte_vegas_chisq (s_xd) - 1.0) > 0.5); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// ns = res_x+res_xd; ratio = ns/(res_s+res_sd); printf ("%e\n", ratio); gsl_monte_vegas_free (s_x); gsl_rng_free (r_x); gsl_monte_vegas_free (s_xd); gsl_rng_free (r_xd); return 0; }
int main (int argc, char *argv[]) { double ns; int i; int id; // process rank int p; // number of processes MPI_Init (&argc, &argv); MPI_Comm_rank (MPI_COMM_WORLD, &id); MPI_Comm_size (MPI_COMM_WORLD, &p); // 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]={3.0,0.0,-2000.0,-2000.0,-2000.0,-550.0,-450.0,-350.0}; double xu_x[8]={13.0,13.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=500000000; T_x=gsl_rng_default; // neutron stars, pulsar to disk double res_xd,err_xd; //double xl_x[4]={3.0,0.0,-2000.0,-2000.0}; //double xu_x[4]={13.0,13.0,2000.0,2000.0}; double xl_xd[8]={0.0,0.0,-2000.0,-2000.0,-2000.0,-100.0,-150.0,-100.0}; double xu_xd[8]={13.0,13.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_disk,8,0}; size_t calls_xd=500000000; T_xd=gsl_rng_default; //////////////////////////////////////////////////////////////////////////////////////////// // source double res_s,err_s; double xl_s[1]={3.0}; double xu_s[1]={13.0}; const gsl_rng_type *T_s; gsl_rng *r_s; gsl_monte_function G_s={&source,1,0}; size_t calls_s=500000000; 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); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// // source disk double res_sd,err_sd; double xl_sd[1]={0.0}; double xu_sd[1]={13.0}; const gsl_rng_type *T_sd; gsl_rng *r_sd; gsl_monte_function G_sd={&source_disk,1,0}; size_t calls_sd=500000000; 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); ////////////////////////////////////////////////////////////////////////////////////////////////////// r_x=gsl_rng_alloc(T_x); gsl_monte_vegas_state *s_x = gsl_monte_vegas_alloc (8); r_xd=gsl_rng_alloc(T_xd); gsl_monte_vegas_state *s_xd = gsl_monte_vegas_alloc (8); // calculation for (i=id;i<=200;i+=p) { //t=pow(10.0,0.015*i); t=-0.5+0.0175*i; 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); ///////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////// gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 8, 10000, r_xd, s_xd, &res_xd, &err_xd); // display_results ("vegas warm-up", res, err); // printf ("converging...\n"); do { gsl_monte_vegas_integrate (&G_xd, xl_xd, xu_xd, 8, calls_xd/5, r_xd, s_xd, &res_xd, &err_xd); //printf ("result = % .6ef sigma = % .6ef chisq/dof = %.1f\n", res, err, gsl_monte_vegas_chisq (s)); } while (fabs (gsl_monte_vegas_chisq (s_xd) - 1.0) > 0.5); // display_results ("vegas final", res, err); ////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////// ns = (fabs(res_x)+fabs(res_xd))/(fabs(res_s)+fabs(res_sd)); printf ("%e %e\n", t, ns); fflush(stdout); } gsl_monte_vegas_free (s_x); gsl_rng_free (r_x); gsl_monte_vegas_free (s_xd); gsl_rng_free (r_xd); fflush (stdout); MPI_Finalize (); return 0; }
void cpuoptical_(int *gpusize) { // command line arguments float xdetector, ydetector, radius, height, n_C, n_IC, top_absfrac, bulk_abscoeff, beta, d_min, lbound_x, lbound_y, ubound_x, ubound_y, d_max, yield, sensorRefl; int pixelsize, num_primary, min_optphotons, max_optphotons, num_bins; float dcos[3]={0}; // directional cosines float normal[3]={0}; // normal to surface in case of TIR float pos[3] = {0}; // intersecting point coordinates float old_pos[3] = {0}; // source coordinates int nbytes = (optical_.myctropt - (*gpusize))*sizeof(struct start_info); struct start_info *structa; structa = (struct start_info*) malloc(nbytes); if( structa == NULL ) printf("\n Struct start_info array CANNOT BE ALLOCATED - %d !!", (optical_.myctropt-(*gpusize))); // get cpu time clock_t start, end; float num_sec; // get current time stamp to initialize seed input for RNG time_t seconds; seconds = time (NULL); struct timeval tv; gettimeofday(&tv,NULL); float rr=0.0f, theta=0.0f; float r=0.0f; // random number float norm=0.0f; int jj=0; int my_index=0; int penindex = 0; // equal to *gpusize int result_algo = 0; unsigned long long int *num_rebound; // initialize random number generator (RANECU) int seed_input = 271828182 ; // ranecu seed input int seed[2]; // GNU scientific library (gsl) variables const gsl_rng_type * Tgsl; gsl_rng * rgsl; double mu_gsl; // output image variables int xdim = 0; int ydim = 0; int indexi=0, indexj=0; // copy to local variables from PENELOPE buffers xdetector = inputargs_.detx; // x dimension of detector (in um). x in (0,xdetector) ydetector = inputargs_.dety; // y dimension of detector (in um). y in (0,ydetector) height = inputargs_.detheight; // height of column and thickness of detector (in um). z in range (-H/2, H/2) radius = inputargs_.detradius; // radius of column (in um). n_C = inputargs_.detnC; // refractive index of columns n_IC = inputargs_.detnIC; // refractive index of intercolumnar material top_absfrac = inputargs_.dettop; // column's top surface absorption fraction (0.0, 0.5, 0.98) bulk_abscoeff = inputargs_.detbulk; // column's bulk absorption coefficient (in um^-1) (0.001, 0.1 cm^-1) beta = inputargs_.detbeta; // roughness coefficient of column walls d_min = inputargs_.detdmin; // minimum distance a photon can travel when transmitted from a column d_max = inputargs_.detdmax; lbound_x = inputargs_.detlboundx; // x lower bound of region of interest of output image (in um) lbound_y = inputargs_.detlboundy; // y lower bound (in um) ubound_x = inputargs_.detuboundx; // x upper bound (in um) ubound_y = inputargs_.detuboundy; // y upper bound (in um) yield = inputargs_.detyield; // yield (/eV) pixelsize = inputargs_.detpixel; // 1 pixel = pixelsize microns (in um) sensorRefl = inputargs_.detsensorRefl; // Non-Ideal sensor reflectivity (%) num_primary = inputargs_.mynumhist; // total number of primaries to be simulated min_optphotons = inputargs_.minphotons; // minimum number of optical photons detected to be included in PHS max_optphotons = inputargs_.maxphotons; // maximum number of optical photons detected to be included in PHS num_bins = inputargs_.mynumbins; // number of bins for genrating PHS // create a generator chosen by the environment variable GSL_RNG_TYPE gsl_rng_env_setup(); Tgsl = gsl_rng_default; rgsl = gsl_rng_alloc (Tgsl); // dimensions of PRF image xdim = ceil((ubound_x - lbound_x)/pixelsize); ydim = ceil((ubound_y - lbound_y)/pixelsize); unsigned long long int myimage[xdim][ydim]; //initialize the output image 2D array for(indexi = 0; indexi < xdim; indexi++) { for(indexj = 0; indexj < ydim; indexj++) { myimage[indexi][indexj] = 0; } } // memory for storing histogram of # photons detected/primary int *h_num_detected_prim = 0; h_num_detected_prim = (int*)malloc(sizeof(int)*num_primary); for(indexj=0; indexj < num_primary; indexj++) h_num_detected_prim[indexj] = 0; // memory for storing histogram of # photons detected/primary int *h_histogram = 0; h_histogram = (int*)malloc(sizeof(int)*num_bins); for(indexj=0; indexj < num_bins; indexj++) h_histogram[indexj] = 0; penindex = *gpusize; for(my_index = 0; my_index < (optical_.myctropt-(*gpusize)); my_index++) // iterate over x-rays { // reset the global counters num_generated = 0; num_detect=0; num_abs_top=0; num_abs_bulk=0; num_lost=0; num_outofcol=0; num_theta1=0; photon_distance=0.0f; //re-initialize the output image 2D array for(indexi = 0; indexi < xdim; indexi++) for(indexj = 0; indexj < ydim; indexj++) myimage[indexi][indexj] = 0; // copying PENELOPE buffer into *structa // units in the penelope output file are in cm. Convert them to microns. structa[my_index].str_x = optical_.xbufopt[penindex+my_index] * 10000.0f; // x-coordinate of interaction event structa[my_index].str_y = optical_.ybufopt[penindex+my_index] * 10000.0f; // y-coordinate structa[my_index].str_z = optical_.zbufopt[penindex+my_index] * 10000.0f; // z-coordinate structa[my_index].str_E = optical_.debufopt[penindex+my_index]; // energy deposited structa[my_index].str_histnum = optical_.nbufopt[penindex+my_index]; // x-ray history // sample # optical photons based on light yield and energy deposited for this interaction event (using Poisson distribution) mu_gsl = (double)structa[my_index].str_E * yield; structa[my_index].str_N = gsl_ran_poisson(rgsl,mu_gsl); if(structa[my_index].str_N > max_photon_per_EDE) { printf("\n\n str_n exceeds max photons. program is exiting - %d !! \n\n",structa[my_index].str_N); exit(0); } num_rebound = (unsigned long long int*) malloc(structa[my_index].str_N*sizeof(unsigned long long int)); if(num_rebound == NULL) printf("\n Error allocating num_rebound memory !\n"); // start the clock start = clock(); // initialize the RANECU generator in a position far away from the previous history: seed_input = (int)(seconds/3600+tv.tv_usec); // seed input=seconds passed since 1970+current time in micro secs init_PRNG(my_index, 50000, seed_input, seed); // intialize RNG for(jj=0; jj<structa[my_index].str_N; jj++) num_rebound[jj] = 0; // reset the directional cosine and normal vectors dcos[0]=0.0f; dcos[1]=0.0f; dcos[2]=0.0f; normal[0]=0.0f; normal[1]=0.0f; normal[2]=0.0f; // re-initialize myimage for(indexi = 0; indexi < xdim; indexi++) for(indexj = 0; indexj < ydim; indexj++) myimage[indexi][indexj] = 0; // set starting location of photon pos[0] = structa[my_index].str_x; pos[1] = structa[my_index].str_y; pos[2] = structa[my_index].str_z; old_pos[0] = structa[my_index].str_x; old_pos[1] = structa[my_index].str_y; old_pos[2] = structa[my_index].str_z; // initializing the direction cosines for the first particle in each core r = (ranecu(seed) * 2.0f) - 1.0f; // random number between (-1,1) while(fabs(r) <= 0.01f) { r = (ranecu(seed) * 2.0f) - 1.0f; } dcos[2] = r; // random number between (-1,1) rr = sqrt(1.0f-r*r); theta=ranecu(seed)*twopipen; dcos[0]=rr*cos(theta); dcos[1]=rr*sin(theta); norm = sqrt(dcos[0]*dcos[0] + dcos[1]*dcos[1] + dcos[2]*dcos[2]); if ((norm < (1.0f - epsilon)) || (norm > (1.0f + epsilon))) // normalize { dcos[0] = dcos[0]/norm; dcos[1] = dcos[1]/norm; dcos[2] = dcos[2]/norm; } local_counter=0; // total number of photons terminated (either detected at sensor, absorbed at the top or in the bulk) [global variable] while(local_counter < structa[my_index].str_N) // until all the optical photons are not transported { absorbed = 0; detect = 0; bulk_abs = 0; // set starting location of photon pos[0] = structa[my_index].str_x; pos[1] = structa[my_index].str_y; pos[2] = structa[my_index].str_z; old_pos[0] = structa[my_index].str_x; old_pos[1] = structa[my_index].str_y; old_pos[2] = structa[my_index].str_z; num_generated++; result_algo = 0; while(result_algo == 0) { result_algo = algo(normal, old_pos, pos, dcos, num_rebound, seed, structa[my_index], &myimage[0][0], xdetector, ydetector, radius, height, n_C, n_IC, top_absfrac, bulk_abscoeff, beta, d_min, pixelsize, lbound_x, lbound_y, ubound_x, ubound_y, sensorRefl, d_max, ydim, h_num_detected_prim); } } // end the clock end = clock(); num_sec = (((float)end - start)/CLOCKS_PER_SEC); // type cast unsigned long long int to double double cast_num_generated; double cast_num_detect; double cast_num_abs_top; double cast_num_abs_bulk; double cast_num_lost; double cast_num_outofcol; double cast_num_theta1; double cast_gputime; cast_num_generated = (double)num_generated; cast_num_detect = (double)num_detect; cast_num_abs_top = (double)num_abs_top; cast_num_abs_bulk = (double)num_abs_bulk; cast_num_lost = (double)num_lost; cast_num_outofcol = (double)num_outofcol; cast_num_theta1 = (double)num_theta1; cast_gputime = (double)(num_sec*1000.0); // convert in millisecond // save to global counters optstats_.glgen = optstats_.glgen + cast_num_generated; optstats_.gldetect = optstats_.gldetect + cast_num_detect; optstats_.glabstop = optstats_.glabstop + cast_num_abs_top; optstats_.glabsbulk = optstats_.glabsbulk + cast_num_abs_bulk; optstats_.gllost = optstats_.gllost + cast_num_lost; optstats_.gloutofcol = optstats_.gloutofcol + cast_num_outofcol; optstats_.gltheta1 = optstats_.gltheta1 + cast_num_theta1; optstats_.glgputime = optstats_.glgputime + cast_gputime; // release resources free(num_rebound); } // my_index loop ends // make histogram of number of detected photons/primary for num_bins int binsize=0, newbin=0; int bincorr=0; binsize = floor((max_optphotons-min_optphotons)/num_bins); // calculate size of each bin. Assuming equally spaced bins. bincorr = floor(min_optphotons/binsize); // correction in bin number if min_optphotons > 0. for(indexi = 0; indexi < num_primary; indexi++) { newbin = floor(h_num_detected_prim[indexi]/binsize) - bincorr; // find bin # if(h_num_detected_prim[indexi] > 0) // store only non-zero bins { if(h_num_detected_prim[indexi] <= min_optphotons) // # detected < minimum photons given by user, add to the first bin h_histogram[0]++; else if(h_num_detected_prim[indexi] >= max_optphotons) // # detected > maximum photons given by user, then add to the last bin h_histogram[num_bins-1]++; else h_histogram[newbin]++; } } // add num_detected_primary to gldetprimary array in PENELOPE for(indexi = 0; indexi < num_bins; indexi++) outputdetprim_.gldetprimary[indexi] = outputdetprim_.gldetprimary[indexi] + h_histogram[indexi]; // release resources free(structa); free(h_num_detected_prim); free(h_histogram); return; } // C main() ends
int main(int argc, char *argv[]) { clock_t start, stop; // Initiate the GSL random number generator gsl_rng *rng = gsl_rng_alloc(gsl_rng_taus2); gsl_rng_set(rng, time(NULL)); unsigned int S; S = atoi(argv[1]); double C; C = atof(argv[2]); // Pointers to output file FILE *splist; start = clock(); // Let's generate three arrays of n, r, and c double *n = (double*) malloc(S * sizeof(double)); double *r = (double*) malloc(S * sizeof(double)); double *c = (double*) malloc(S * sizeof(double)); int *pop = (int*) malloc(S * sizeof(int)); int *K = (int*) malloc(S * sizeof(int)); // We then generate random values of n for (int sp = 0; sp < S; ++sp) { n[sp] = gsl_ran_flat (rng, 0.0, 1.0); r[sp] = n[sp]*gsl_ran_beta(rng, 1, 1/(2*C)-1); c[sp] = gsl_ran_flat(rng, r[sp]/2, n[sp]); K[sp] = gsl_rng_uniform_int(rng, (int) 500 - 500*n[sp])+100; pop[sp] = gsl_rng_uniform_int(rng, (int) K[sp]-10)+10; } // The species with the smallest n has a r of 0 double min_n = 1000; // We start by getting the min value for (int sp = 0; sp > S; ++sp){ if (n[sp] < min_n){ min_n = n[sp]; } } // Then we update the r value accordingly for (int sp = 0; sp < S; ++sp){ if (n[sp] == min_n){ r[sp] = 0; } } // Finally we write to a file char tfname[FNSIZE]; snprintf(tfname, sizeof(char) * FNSIZE, "splist.txt"); splist = fopen(tfname, "w"); for (int sp = 0; sp < S; ++sp){ fprintf(splist, "%d %.4f %.4f %.4f %d %d\n", sp+1, n[sp], r[sp], c[sp], K[sp], pop[sp]); } fclose(splist); gsl_rng_free(rng); stop = clock(); printf("%d species, expected connectance of %.2f, generated in %.2f seconds\n", S, C, (stop - start) / (float) CLOCKS_PER_SEC); return EXIT_SUCCESS; }
void MAIAllocator::Setup() { //////// initialization of dynamic data structures Hmat = gsl_matrix_complex_alloc(N(),M()); Hchan = gsl_vector_complex_alloc(N()); Hperm = gsl_matrix_uint_alloc(N(),M()); p = gsl_permutation_alloc(N()); huserabs = gsl_vector_alloc(N()); nextcarr = gsl_vector_uint_alloc(M()); usedcarr = gsl_vector_uint_alloc(N()); errs = gsl_vector_uint_alloc(M()); habs = gsl_matrix_alloc(N(),M()); huu = gsl_matrix_complex_alloc(N(),M()); framecount = 0; ericount = 0; csicount = 0; noDecisions = 0; ostringstream cmd; // // time // time(&reporttime); // // Random Generator // ran = gsl_rng_alloc( gsl_rng_default ); // SIGNATURE FREQUENCIES INITIAL SETUP signature_frequencies = gsl_matrix_uint_alloc(M(),J()); signature_frequencies_init = gsl_matrix_uint_alloc(M(),J()); signature_powers = gsl_matrix_alloc(M(),J()); for (int i=0; i<M(); i++) for (int j=0; j<J(); j++) gsl_matrix_uint_set(signature_frequencies_init,i,j,(j*M()+i) % N()); // // INITIAL ALLOCATION // gsl_matrix_uint_memcpy(signature_frequencies, signature_frequencies_init); // maximum initial powers for all carriers gsl_matrix_set_all(signature_powers,INIT_CARR_POWER); gsl_vector_uint_set_zero(errs); // // // FFT Transform Matrix // // transform_mat = gsl_matrix_complex_calloc(N(),N()); double fftarg=-2.0*double(M_PI/N()); double fftamp=1.0/sqrt(double(N())); for (int i=0; i<N(); i++) for (int j=0; j<N(); j++) gsl_matrix_complex_set(transform_mat,i,j, gsl_complex_polar(fftamp,fftarg*i*j) ); switch (Mode()) { case 0: cout << BlockName << " - Allocator type FIXED_ALLOCATION selected" << endl; break; case 1: cout << BlockName << " - Allocator type GIVE_BEST_CARR selected" << endl; break; case 2: cout << BlockName << " - Allocator type SWAP_BAD_GOOD selected" << endl; break; case 3: cout << BlockName << " - Allocator type BEST_OVERLAP selected" << endl; break; case 4: cout << BlockName << " - Allocator type SOAR_AI selected" << endl; // // SOAR INITIALIZATION // max_errors = MAX_ERROR_RATE * ERROR_REPORT_INTERVAL * Nb() * K(); cout << BlockName << " - Max errors tuned to " << max_errors << " errors/frame." << endl; // // first we initialize the vectors and matrices // in the order of appearance in the header file. // umapUserVec = vector < Identifier * > (M()); umapUserUidVec = vector < IntElement * > (M()); umapUserErrsVec = vector < IntElement * > (M()); umapUserPowerVec = vector < FloatElement * > (M()); umapUserCarrMat = vector < Identifier * > (M()*J()); umapUserCarrCidMat = vector < IntElement * > (M()*J()); umapUserCarrPowerMat = vector < FloatElement * > (M()*J()); chansCoeffMat = vector < Identifier * > (M()*N()); chansCoeffUserMat = vector < IntElement * > (M()*N()); chansCoeffCarrMat = vector < IntElement * > (M()*N()); chansCoeffValueMat = vector < FloatElement * > (M()*N()); carmapCarrVec = vector < Identifier * > (N()); carmapCarrCidVec = vector < IntElement * > (N()); // // then we create an instance of the Soar kernel in our process // pKernel = Kernel::CreateKernelInNewThread() ; //pKernel = Kernel::CreateRemoteConnection() ; // Check that nothing went wrong. We will always get back a kernel object // even if something went wrong and we have to abort. if (pKernel->HadError()) { cerr << BlockName << ".SOAR - " << pKernel->GetLastErrorDescription() << endl ; exit(1); } // We check if an agent has been prevoiusly created, otherwise we create it // NOTE: We don't delete the agent pointer. It's owned by the kernel pAgent = pKernel->GetAgent("AIAllocator") ; if (! pKernel->IsAgentValid(pAgent)) { pAgent = pKernel->CreateAgent("AIAllocator") ; } // Check that nothing went wrong // NOTE: No agent gets created if there's a problem, so we have to check for // errors through the kernel object. if (pKernel->HadError()) { cerr << BlockName << ".SOAR - " << pKernel->GetLastErrorDescription() << endl ; exit(1); } // // load productions // pAgent->LoadProductions(SoarFn()); // spawn debugger #ifdef SPAWN_DEBUGGER pAgent->SpawnDebugger(); #endif // Check that nothing went wrong // NOTE: No agent gets created if there's a problem, so we have to check for // errors through the kernel object. if (pKernel->HadError()) { cerr << BlockName << ".SOAR - " << pKernel->GetLastErrorDescription() << endl ; exit(1); } // keypress //cout << "pause maillocator:203 ... (press ENTER key)" << endl; //cin.ignore(); // // we can now generate initial input link structure // // NO MORE adjust max-nil-output-cycle //cmd << "max-nil-output-cycles " << 120; //pAgent->ExecuteCommandLine(cmd.str().c_str()); // the input-link pInputLink = pAgent->GetInputLink(); // input-time input_time = 0; inputTime = pAgent->CreateIntWME(pInputLink,"input-time",input_time); // the usrmap structure (common wmes) umap = pAgent->CreateIdWME(pInputLink,"usrmap"); // BITS_PER_REPORT = ERROR_REPORT_INTERVAL * Nb() * K() // MAX_ERRORS = MAX_ERROR_RATE * BITS_PER_REPORT umapMaxerr = pAgent->CreateIntWME(umap,"maxerr",max_errors); umapPstep = pAgent->CreateFloatWME(umap,"pstep",POWER_STEP); umapPmax = pAgent->CreateFloatWME(umap,"pmax",MAX_POWER); // the channels chans = pAgent->CreateIdWME(pInputLink,"channels"); // the carmap carmap = pAgent->CreateIdWME(pInputLink,"carmap"); // the usrmap structure (users substructure) for (int i=0;i<M();i++) { // user loop umapUserVec[i] = pAgent->CreateIdWME(umap,"user"); umapUserUidVec[i] = pAgent->CreateIntWME(umapUserVec[i],"uid",i); umapUserErrsVec[i] = pAgent->CreateIntWME(umapUserVec[i],"errs",int(0)); umapUserPowerVec[i] = pAgent->CreateFloatWME(umapUserVec[i],"power",J()); // update the current allocation for (int j=0;j<J();j++) { // allocated carriers loop unsigned int usedcarr = gsl_matrix_uint_get(signature_frequencies,i,j); double usedpow = gsl_matrix_get(signature_powers,i,j); umapUserCarrMat[i*J()+j] = pAgent->CreateIdWME(umapUserVec[i],"carr"); umapUserCarrCidMat[i*J()+j] = pAgent->CreateIntWME(umapUserCarrMat[i*J()+j],"cid",usedcarr); umapUserCarrPowerMat[i*J()+j] = pAgent->CreateFloatWME(umapUserCarrMat[i*J()+j],"power",usedpow); } // allocated carriers loop // the channels for (int j=0;j<N();j++) { // all channels loop chansCoeffMat[i*N()+j] = pAgent->CreateIdWME(chans,"coeff"); chansCoeffUserMat[i*N()+j] = pAgent->CreateIntWME(chansCoeffMat[i*N()+j],"user",i); chansCoeffCarrMat[i*N()+j] = pAgent->CreateIntWME(chansCoeffMat[i*N()+j],"carr",j); chansCoeffValueMat[i*N()+j] = pAgent->CreateFloatWME(chansCoeffMat[i*N()+j],"value",0.0); } // all channels loop } // user loop // the carmap structure for (int j=0;j<N();j++) { // all carriers loop carmapCarrVec[j] = pAgent->CreateIdWME(carmap,"carr"); carmapCarrCidVec[j] = pAgent->CreateIntWME(carmapCarrVec[j],"cid",j); } // all carriers loop // // END OF SOAR INITIALIZAZION // break; default: cerr << BlockName << " - Unhandled allocator type !" << endl; exit(1); } //////// rate declaration for ports }
double fit_n(set_const* Init, double n0){ const gsl_multifit_fdfsolver_type *T; gsl_multifit_fdfsolver *s; int status; unsigned int i, iter = 0; const size_t n = 11; const size_t p = 5; double k = n0/0.16; gsl_matrix *covar = gsl_matrix_alloc (p, p); double y[11] = {4.45, 6.45 , 9.65, 13.29, 17.94, 22.92, 27.49, 38.82, 54.95, 75.13, 99.75}; double t[11] = {k*0.02,k*0.04, k*0.08,k*0.12,k*0.16,k*0.2,k*0.24, k*0.32, k*0.4,k*0.48, k*0.56}; struct data d = { n, y, t, Init}; gsl_multifit_function_fdf f; double x_init[5] = {Init->C_s,Init->C_o, Init->b,Init->c, Init->C_r}; //double x_init[6] = {11.56279437,7.49931859,0.00871711,0.00267620,0.86859184,0.5}; //double x_init[4] = { sqrt(130.746),sqrt(120.7244),1.0,10.0}; gsl_vector_view x = gsl_vector_view_array (x_init, p); const gsl_rng_type * type; gsl_rng * r; gsl_rng_env_setup(); type = gsl_rng_default; r = gsl_rng_alloc (type); f.f = &func_fit_n; f.df = NULL; f.fdf = NULL; f.n = n; f.p = p; f.params = &d; /* This is the data to be fitted */ /*for (i = 0; i < n; i++) { double t = i; y[i] = 1.0 + 5 * exp (-0.1 * t) + gsl_ran_gaussian (r, 0.1); sigma[i] = 0.1; printf ("data: %u %g %g\n", i, y[i], sigma[i]); };*/ T = gsl_multifit_fdfsolver_lmsder; s = gsl_multifit_fdfsolver_alloc (T, n, p); gsl_multifit_fdfsolver_set (s, &f, &x.vector); print_state (iter, s); do { iter++; status = gsl_multifit_fdfsolver_iterate (s); //printf ("status = %s\n", gsl_strerror (status)); print_state (iter, s); if (status) break; status = gsl_multifit_test_delta (s->dx, s->x, 1e-15, 0.0); } while (status == GSL_CONTINUE && iter < 2000); gsl_multifit_covar (s->J, 0.0, covar); #define FIT(i) gsl_vector_get(s->x, i) #define ERR(i) sqrt(gsl_matrix_get(covar,i,i)) cond(Init, FIT(0), FIT(1), FIT(2), FIT(3), FIT(4)); { double chi = gsl_blas_dnrm2(s->f); double dof = n - p; double c = GSL_MAX_DBL(1, chi / sqrt(dof)); //double c = 1.0; /*printf("chisq/dof = %g\n", pow(chi, 2.0) / dof); printf ("Cs = %.5f +/- %.5f\n", Init->C_s, c*ERR(0)); printf ("Co = %.5f +/- %.5f\n", Init->C_o, c*ERR(1)); printf ("b = %.5f +/- %.5f\n", Init->c, c*ERR(2)); printf ("c = %.5f +/- %.5f\n", Init->b, c*ERR(3)); printf ("Cr = %.5f +/- %.5f\n", Init->C_r, c*ERR(4));*/ } // printf ("status = %s\n", gsl_strerror (status)); double z = 0.65; gsl_matrix_free (covar); gsl_rng_free (r); double yi = 0; /*for (int i = 0; i < 11; i++){ double yi = EoS::t_E(t[i],0, Init)/(D*t[i]) - m_n ; printf("n = %.3f, %.3f %.3f %.3f \n", t[i], yi, y[i], yi-y[i]); }*/ /*return *(new set_const("APR_fit return constant set",FIT(0), FIT(1), 10.0, FIT(2),abs(FIT(3)), z, [](double f){return (1-f);}, [](double f){return 1.0;}, [=](double f){return eta_o(f);}, [](double f){return 1.0;}));*/ double rr = gsl_blas_dnrm2(s->x); gsl_multifit_fdfsolver_free (s); return rr; }
int initialize() { int i; if(read_from_file) { if(noise == 0) { read_popdens(1); flat_constraint(1.); } if(noise == 1) { read_popdens(1); flat_constraint(populationsize); } if(noise == 2) { read_constraint(1); read_popdens(0); } if(noise == 3) { read_popdens(1); flat_constraint(1.); read_timetrace(); } }else{ if(noise == 0)flat_constraint(1.); if(noise == 1)flat_constraint(populationsize); if(noise == 2)read_constraint(1); if(noise == 3) { flat_constraint(1.); read_timetrace(); } nn = (double*)calloc(space,sizeof(double)); initialize_with_gaussian_popdens(); } tmp = (double*)malloc(space*sizeof(double)); gsl_rng_env_setup(); T = gsl_rng_default; rg = gsl_rng_alloc(T); gsl_rng_set(rg, randseed); twoepssqrt = sqrt(2.*epsilon); speedprefactor = wavespeed/dx*epsilon; x = (double*)malloc(space*sizeof(double)); for(i=0;i<space;i++)x[i] = (i-space0)*dx; mutation_diff2dx = epsilon*mutationrate/(dx*dx); if(quiet<2) { printf("###############################################################################\n"); printf("# stochastic simulation of adapting population with diffusion mutation kernel #\n"); printf("###############################################################################\n"); printf("# mutationrate = %e\n",mutationrate); if(noise==0) { printf("# constraint = deterministic\n"); } if(noise==1) { printf("# constraint = fixedN\n"); printf("# populationsize = %e\n",populationsize); } if(noise==2) { printf("# constraint = ustar\n"); printf("# ufile = %s\n",u_infile); printf("# wavespeed = %e\n",wavespeed); } if(noise==3) { printf("# constraint = fluctN\n"); printf("# N trajectory file= %s\n",timetrace_filename); } printf("# (lattice) space = %d\n",space); printf("# (lattice) space0 = %d\n",space0); printf("# (lattice) dx = %e\n",dx); printf("# randseed = %d\n",randseed); } }
/* Random Number Generation */ void FC_FUNC_(oct_ran_init, OCT_RAN_INIT) (gsl_rng **r) { gsl_rng_env_setup(); *r = gsl_rng_alloc(gsl_rng_default); }
int main(void) { gsl_matrix *TS; /* the training set of real waveforms */ gsl_matrix_complex *cTS; /* the training set of complex waveforms */ size_t TSsize; /* the size of the training set (number of waveforms) */ size_t wl; /* the length of each waveform */ size_t k = 0, j = 0, i = 0, nbases = 0, cnbases = 0; REAL8 *RB = NULL; /* the real reduced basis set */ COMPLEX16 *cRB = NULL; /* the complex reduced basis set */ LALInferenceREALROQInterpolant *interp = NULL; LALInferenceCOMPLEXROQInterpolant *cinterp = NULL; gsl_vector *freqs; double tolerance = TOLERANCE; /* tolerance for reduced basis generation loop */ TSsize = TSSIZE; wl = WL; /* allocate memory for training set */ TS = gsl_matrix_calloc(TSsize, wl); cTS = gsl_matrix_complex_calloc(TSsize, wl); /* the waveform model is just a simple chirp so set up chirp mass range for training set */ double fmin0 = 48, fmax0 = 256, f0 = 0., m0 = 0.; double df = (fmax0-fmin0)/(wl-1.); /* model time steps */ freqs = gsl_vector_alloc(wl); /* times at which to calculate the model */ double Mcmax = 2., Mcmin = 1.5, Mc = 0.; gsl_vector_view fweights = gsl_vector_view_array(&df, 1); /* set up training sets (one real and one complex) */ for ( k=0; k < TSsize; k++ ){ Mc = pow(pow(Mcmin, 5./3.) + (double)k*(pow(Mcmax, 5./3.)-pow(Mcmin, 5./3.))/((double)TSsize-1), 3./5.); for ( j=0; j < wl; j++ ){ f0 = fmin0 + (double)j*(fmax0-fmin0)/((double)wl-1.); gsl_complex gctmp; COMPLEX16 ctmp; m0 = real_model(f0, Mc); ctmp = imag_model(f0, Mc); GSL_SET_COMPLEX(&gctmp, creal(ctmp), cimag(ctmp)); gsl_vector_set(freqs, j, f0); gsl_matrix_set(TS, k, j, m0); gsl_matrix_complex_set(cTS, k, j, gctmp); } } /* create reduced orthonormal basis from training set */ if ( (RB = LALInferenceGenerateREAL8OrthonormalBasis(&fweights.vector, tolerance, TS, &nbases)) == NULL){ fprintf(stderr, "Error... problem producing basis\n"); return 1; } if ( (cRB = LALInferenceGenerateCOMPLEX16OrthonormalBasis(&fweights.vector, tolerance, cTS, &cnbases)) == NULL){ fprintf(stderr, "Error... problem producing basis\n"); return 1; } /* free the training set */ gsl_matrix_free(TS); gsl_matrix_complex_free(cTS); gsl_matrix_view RBview = gsl_matrix_view_array(RB, nbases, wl); gsl_matrix_complex_view cRBview = gsl_matrix_complex_view_array((double*)cRB, cnbases, wl); fprintf(stderr, "No. nodes (real) = %zu, %zu x %zu\n", nbases, RBview.matrix.size1, RBview.matrix.size2); fprintf(stderr, "No. nodes (complex) = %zu, %zu x %zu\n", cnbases, cRBview.matrix.size1, cRBview.matrix.size2); /* get the interpolant */ interp = LALInferenceGenerateREALROQInterpolant(&RBview.matrix); cinterp = LALInferenceGenerateCOMPLEXROQInterpolant(&cRBview.matrix); /* free the reduced basis */ XLALFree(RB); XLALFree(cRB); /* now get the terms for the likelihood with and without the reduced order quadrature * and do some timing tests */ /* create the model dot model weights */ REAL8 varval = 1.; gsl_vector_view vars = gsl_vector_view_array(&varval, 1); gsl_matrix *mmw = LALInferenceGenerateREALModelModelWeights(interp->B, &vars.vector); gsl_matrix_complex *cmmw = LALInferenceGenerateCOMPLEXModelModelWeights(cinterp->B, &vars.vector); /* let's create some Gaussian random data */ const gsl_rng_type *T; gsl_rng *r; gsl_rng_env_setup(); T = gsl_rng_default; r = gsl_rng_alloc(T); REAL8 *data = XLALCalloc(wl, sizeof(REAL8)); COMPLEX16 *cdata = XLALCalloc(wl, sizeof(COMPLEX16)); for ( i=0; i<wl; i++ ){ data[i] = gsl_ran_gaussian(r, 1.0); /* real data */ cdata[i] = gsl_ran_gaussian(r, 1.0) + I*gsl_ran_gaussian(r, 1.0); /* complex data */ } /* create the data dot model weights */ gsl_vector_view dataview = gsl_vector_view_array(data, wl); gsl_vector *dmw = LALInferenceGenerateREAL8DataModelWeights(interp->B, &dataview.vector, &vars.vector); gsl_vector_complex_view cdataview = gsl_vector_complex_view_array((double*)cdata, wl); gsl_vector_complex *cdmw = LALInferenceGenerateCOMPLEX16DataModelWeights(cinterp->B, &cdataview.vector, &vars.vector); /* pick a chirp mass and generate a model to compare likelihoods */ double randMc = 1.873; /* a random frequency to create a model */ gsl_vector *modelfull = gsl_vector_alloc(wl); gsl_vector *modelreduced = gsl_vector_alloc(nbases); gsl_vector_complex *cmodelfull = gsl_vector_complex_alloc(wl); gsl_vector_complex *cmodelreduced = gsl_vector_complex_alloc(cnbases); /* create models */ for ( i=0; i<wl; i++ ){ /* models at all frequencies */ gsl_vector_set(modelfull, i, real_model(gsl_vector_get(freqs, i), randMc)); COMPLEX16 cval = imag_model(gsl_vector_get(freqs, i), randMc); gsl_complex gcval; GSL_SET_COMPLEX(&gcval, creal(cval), cimag(cval)); gsl_vector_complex_set(cmodelfull, i, gcval); } /* models at interpolant nodes */ for ( i=0; i<nbases; i++ ){ /* real model */ gsl_vector_set(modelreduced, i, real_model(gsl_vector_get(freqs, interp->nodes[i]), randMc)); } for ( i=0; i<cnbases; i++ ){ /* complex model */ COMPLEX16 cval = imag_model(gsl_vector_get(freqs, cinterp->nodes[i]), randMc); gsl_complex gcval; GSL_SET_COMPLEX(&gcval, creal(cval), cimag(cval)); gsl_vector_complex_set(cmodelreduced, i, gcval); } /* timing variables */ struct timeval t1, t2, t3, t4; double dt1, dt2; /* start with the real model */ /* get the model model term with the full model */ REAL8 mmfull, mmred; gettimeofday(&t1, NULL); XLAL_CALLGSL( gsl_blas_ddot(modelfull, modelfull, &mmfull) ); /* real model */ gettimeofday(&t2, NULL); /* now get it with the reduced order quadrature */ gettimeofday(&t3, NULL); mmred = LALInferenceROQREAL8ModelDotModel(mmw, modelreduced); gettimeofday(&t4, NULL); dt1 = (double)((t2.tv_sec + t2.tv_usec*1.e-6) - (t1.tv_sec + t1.tv_usec*1.e-6)); dt2 = (double)((t4.tv_sec + t4.tv_usec*1.e-6) - (t3.tv_sec + t3.tv_usec*1.e-6)); fprintf(stderr, "Real Signal:\n - M dot M (full) = %le [%.9lf s], M dot M (reduced) = %le [%.9lf s], time ratio = %lf\n", mmfull, dt1, mmred, dt2, dt1/dt2); /* get the data model term with the full model */ REAL8 dmfull, dmred; gettimeofday(&t1, NULL); XLAL_CALLGSL( gsl_blas_ddot(&dataview.vector, modelfull, &dmfull) ); gettimeofday(&t2, NULL); /* now get it with the reduced order quadrature */ gettimeofday(&t3, NULL); dmred = LALInferenceROQREAL8DataDotModel(dmw, modelreduced); gettimeofday(&t4, NULL); dt1 = (double)((t2.tv_sec + t2.tv_usec*1.e-6) - (t1.tv_sec + t1.tv_usec*1.e-6)); dt2 = (double)((t4.tv_sec + t4.tv_usec*1.e-6) - (t3.tv_sec + t3.tv_usec*1.e-6)); fprintf(stderr, " - D dot M (full) = %le [%.9lf s], D dot M (reduced) = %le [%.9lf s], time ratio = %lf\n", dmfull, dt1, dmred, dt2, dt1/dt2); /* check difference in log likelihoods */ double Lfull, Lred, Lfrac; Lfull = mmfull - 2.*dmfull; Lred = mmred - 2.*dmred; Lfrac = 100.*fabs(Lfull-Lred)/fabs(Lfull); /* fractional log likelihood difference (in %) */ fprintf(stderr, " - Fractional difference in log likelihoods = %lf%%\n", Lfrac); XLALFree(data); gsl_vector_free(modelfull); gsl_vector_free(modelreduced); gsl_matrix_free(mmw); gsl_vector_free(dmw); /* check log likelihood difference is within tolerance */ if ( Lfrac > LTOL ) { return 1; } /* now do the same with the complex model */ /* get the model model term with the full model */ COMPLEX16 cmmred, cmmfull; gsl_complex cmmfulltmp; gettimeofday(&t1, NULL); XLAL_CALLGSL( gsl_blas_zdotc(cmodelfull, cmodelfull, &cmmfulltmp) ); /* complex model */ cmmfull = GSL_REAL(cmmfulltmp) + I*GSL_IMAG(cmmfulltmp); gettimeofday(&t2, NULL); gettimeofday(&t3, NULL); cmmred = LALInferenceROQCOMPLEX16ModelDotModel(cmmw, cmodelreduced); gettimeofday(&t4, NULL); dt1 = (double)((t2.tv_sec + t2.tv_usec*1.e-6) - (t1.tv_sec + t1.tv_usec*1.e-6)); dt2 = (double)((t4.tv_sec + t4.tv_usec*1.e-6) - (t3.tv_sec + t3.tv_usec*1.e-6)); fprintf(stderr, "Complex Signal:\n - M dot M (full) = %le [%.9lf s], M dot M (reduced) = %le [%.9lf s], time ratio = %lf\n", creal(cmmfull), dt1, creal(cmmred), dt2, dt1/dt2); COMPLEX16 cdmfull, cdmred; gsl_complex cdmfulltmp; gettimeofday(&t1, NULL); XLAL_CALLGSL( gsl_blas_zdotc(&cdataview.vector, cmodelfull, &cdmfulltmp) ); cdmfull = GSL_REAL(cdmfulltmp) + I*GSL_IMAG(cdmfulltmp); gettimeofday(&t2, NULL); gettimeofday(&t3, NULL); cdmred = LALInferenceROQCOMPLEX16DataDotModel(cdmw, cmodelreduced); gettimeofday(&t4, NULL); dt1 = (double)((t2.tv_sec + t2.tv_usec*1.e-6) - (t1.tv_sec + t1.tv_usec*1.e-6)); dt2 = (double)((t4.tv_sec + t4.tv_usec*1.e-6) - (t3.tv_sec + t3.tv_usec*1.e-6)); fprintf(stderr, " - D dot M (full) = %le [%.9lf s], D dot M (reduced) = %le [%.9lf s], time ratio = %lf\n", creal(cdmfull), dt1, creal(cdmred), dt2, dt1/dt2); /* check difference in log likelihoods */ Lfull = creal(cmmfull) - 2.*creal(cdmfull); Lred = creal(cmmred) - 2.*creal(cdmred); Lfrac = 100.*fabs(Lfull-Lred)/fabs(Lfull); /* fractional log likelihood difference (in %) */ fprintf(stderr, " - Fractional difference in log likelihoods = %lf%%\n", Lfrac); XLALFree(cdata); gsl_vector_complex_free(cmodelfull); gsl_vector_complex_free(cmodelreduced); gsl_matrix_complex_free(cmmw); gsl_vector_complex_free(cdmw); LALInferenceRemoveREALROQInterpolant( interp ); LALInferenceRemoveCOMPLEXROQInterpolant( cinterp ); /* check log likelihood difference is within tolerance */ if ( Lfrac > LTOL ) { return 1; } return 0; }
static void uvag_set (void *vstate, unsigned long int s) { /* Initialize automaton using specified seed. */ uvag_state_t *state = (uvag_state_t *) vstate; uint i, array_len = 255 + WORD, tot, seed_seed, tmp8; unsigned char key[256], *kp, temp; gsl_rng *seed_rng; /* random number generator used to seed uvag */ /* * Preload the array with 1-byte integers */ for (i=0; i<array_len; i++){ svec[i]=i; } /* * OK, here we have to modify Alex's algorithm. The GSL requires a * single seed, unsigned long int in type. Alex requires a key string * 256 characters long (that is, 64 uints long). We therefore have to * bootstrap off of an existing, deterministic GSL RNG to fill the seed * string from a single permitted seed. Note that type 12 is the * mt19937_1999 generator, basically one of the best in the world -- not * that it matters. */ seed_rng = gsl_rng_alloc(dh_rng_types[14]); seed_seed = s; gsl_rng_set(seed_rng,seed_seed); random_max = gsl_rng_max(seed_rng); rmax = random_max; rmax_bits = 0; rmax_mask = 0; while(rmax){ rmax >>= 1; rmax_mask = rmax_mask << 1; rmax_mask++; rmax_bits++; } for(i=0;i<256;i++){ /* if(i%32 == 0) printf("\n"); */ get_rand_bits(&tmp8,sizeof(uint),8,seed_rng); if(i!=255){ key[i] = tmp8; } else { key[i] = 0; } /* printf("%02x",key[i]); */ } /* printf("\n"); */ kp = key; tot = 0; for(i=0; i<array_len; i++) { /* shuffle seeds */ tot += *kp++; tot%=array_len; temp = svec[tot]; svec[tot] = svec[i]; svec[i] = temp; /* wrap around key[] */ if(*kp == '\0') { kp = key; } } /* For debugging of the original load'n'shuffle printf("svec = "); for(i=0;i<256;i++){ if(i%32 == 0) printf("\n"); printf("%02x|",svec[i]); } printf("\n"); */ sindex = 0; rndint = 0; }
/*Numero de objetos sin leer en el subcatalogo: N*/ int LAE_catalog_generator(int model,int N_laes,double mass[],double x[],double y[],double z[],double *mass_min,double halo_m_dev,int *N,int *T,double *mass_max,double *duty_cycle,double x_cat[],double y_cat[],double z_cat[],int *catalog) { //1-DECLARA const gsl_rng_type *tipo; gsl_rng *generador; //2-ALOCA E INICIALIZA tipo=gsl_rng_mt19937; generador=gsl_rng_alloc(tipo); gsl_rng_set(generador,time(NULL)); int rand; int k,l; double exp_mass_min; double mass1; l=1; while( mass[*N-l]<=*mass_min) { l++; } *mass_min=mass[*N-l]; exp_mass_min=pow(10,*mass_min); *N=*N-l; *T=*N; //printf("N=%d \n",*N); if(*N-N_laes>0) { // printf("N-N_LAES>0, m_min=%lf m_max=%lf \n",*mass_min,*mass_max); *catalog=1; if(model==0) { printf("model=0 \n"); if( ( pow(10,mass[*N-N_laes]) - exp_mass_min ) <= halo_m_dev ) { *mass_max=log10( exp_mass_min + halo_m_dev ); } else { *mass_max=mass[*N-N_laes]; } l=1; while( mass[*T-l]<=(*mass_max) ) { l++; } for(k=0;k<N_laes;k++) { rand=gsl_rng_uniform_int(generador, l ); x_cat[k]=x[*N-rand]; y_cat[k]=y[*N-rand]; z_cat[k]=z[*N-rand]; } *duty_cycle=((double)N_laes)/((double)l); } if(model==1) { //printf("model=1 \n"); l=1; *duty_cycle=2; //k=0; while( mass[*T-l]<=(*mass_max) ) { l++; } *duty_cycle=((double)N_laes)/((double)l); if(*duty_cycle>1.0) *catalog=0; //*mass_max+=k*0.1; //k++; } //printf("l=%d \n",l); for(k=0;k<N_laes;k++) { rand=gsl_rng_uniform_int(generador, l ); //printf("x[N-rand]=%lf y[N-rand]=%lf z[N-rand]=%lf \n",x[*N-rand],y[*N-rand],z[*N-rand]); //printf("rand=%d \n",rand); x_cat[k]=x[*N-rand]; //printf("x[N-l]=%lf \n",x[*N-rand]); y_cat[k]=y[*N-rand]; //printf("y[N-l]=%lf \n",y[*N-rand]); z_cat[k]=z[*N-rand]; //printf("x[N-l]=%lf y[N-l]=%lf z[N-l]=%lf \n",x[*N-rand],y[*N-rand],z[*N-rand]); } // printf("x[N-l]=%lf y[N-l]=%lf z[N-l]=%lf \n",x[*N-l],y[*N-l],z[*N-l]); *duty_cycle=((double)N_laes)/((double)l); //printf("duty_cycle=%lf \n",*duty_cycle); }else{*catalog=0;} // printf("saliendo \n"); return 0; }
void smf_fillgaps( ThrWorkForce *wf, smfData *data, smf_qual_t mask, int *status ) { /* Local Variables */ const gsl_rng_type *type; /* GSL random number generator type */ dim_t bpt; /* Number of bolos per thread */ dim_t i; /* Bolometer index */ dim_t nbolo; /* Number of bolos */ dim_t ntslice; /* Number of time slices */ double *dat=NULL; /* Pointer to bolo data */ int fillpad; /* Fill PAD samples? */ size_t bstride; /* bolo stride */ size_t pend; /* Last non-PAD sample */ size_t pstart; /* First non-PAD sample */ size_t tstride; /* time slice stride */ smfFillGapsData *job_data; /* Structures holding data for worker threads */ smfFillGapsData *pdata; /* Pointer to data for next worker thread */ smf_qual_t *qua=NULL; /* Pointer to quality array */ /* Main routine */ if (*status != SAI__OK) return; /* Check we have double precision data floating point data. */ if (!smf_dtype_check_fatal( data, NULL, SMF__DOUBLE, status )) return; /* Pointers to data and quality */ dat = data->pntr[0]; qua = smf_select_qualpntr( data, NULL, status ); if( !qua ) { *status = SAI__ERROR; errRep( "", FUNC_NAME ": No valid QUALITY array was provided", status ); return; } if( !dat ) { *status = SAI__ERROR; errRep( "", FUNC_NAME ": smfData does not contain a DATA component",status); return; } /* obtain data dimensions */ smf_get_dims( data, NULL, NULL, &nbolo, &ntslice, NULL, &bstride, &tstride, status ); /* Determine how many bolometers to process in each thread, and create the structures used to pass data to the threads. */ if( wf ) { bpt = nbolo/wf->nworker; if( wf->nworker*bpt < nbolo ) bpt++; job_data = astMalloc( sizeof( smfFillGapsData )*wf->nworker ); } else { bpt = nbolo; job_data = astMalloc( sizeof( smfFillGapsData ) ); } /* Find the indices of the first and last non-PAD sample. */ smf_get_goodrange( qua, ntslice, tstride, SMF__Q_PAD, &pstart, &pend, status ); /* Report an error if it is too short. */ if( pend - pstart <= 2*BOX && *status == SAI__OK ) { *status = SAI__ERROR; errRepf( "", FUNC_NAME ": length of data (%d samples) is too small " "to fill gaps. Must have at least %d samples per bolometer.", status, (int) ( pend - pstart ), 2*BOX + 1 ); } /* If the supplied "mask" value includes SMF__Q_PAD, then we will be replacing the zero-padded region at the start and end of each time series with artificial noisey data that connects the first and last data values smoothly. Remove SMF__Q_PAD from the mask. */ if( mask & SMF__Q_PAD ) { mask &= ~SMF__Q_PAD; fillpad = 1; } else { fillpad = 0; } /* Get the default GSL randim number generator type. A separate random number generator is used for each worker thread so that the gap filling process does not depend on the the order in which threads are executed. */ type = gsl_rng_default; /* Begin a job context. */ thrBeginJobContext( wf, status ); /* Loop over bolometer in groups of "bpt". */ pdata = job_data; for( i = 0; i < nbolo; i += bpt, pdata++ ) { /* Store information for this group in the next smfFillGapsData structure. */ pdata->ntslice = ntslice; pdata->dat = dat; pdata->r = gsl_rng_alloc( type ); pdata->b1 = i; pdata->b2 = i + bpt - 1; pdata->pend = pend; pdata->fillpad = fillpad; pdata->pstart = pstart; if( pdata->b2 >= nbolo ) pdata->b2 = nbolo - 1; pdata->bstride = bstride; pdata->tstride = tstride; pdata->qua = qua; pdata->mask = mask; /* Submit a job to the workforce to process this group of bolometers. */ (void) thrAddJob( wf, 0, pdata, smfFillGapsParallel, 0, NULL, status ); } /* Wait until all jobs in the current job context have completed, and then end the job context. */ thrWait( wf, status ); thrEndJobContext( wf, status ); /* Free resources. */ if( job_data ) { pdata = job_data; for( i = 0; i < nbolo; i += bpt, pdata++ ) { if( pdata->r ) gsl_rng_free( pdata->r ); } job_data = astFree( job_data ); } }
int main(int argc, char* argv[]) { // Initialisation argp_parse(&argp, argc, argv, 0, 0, 0); init_globals(); if(! wsinit() ) { fprintf(stderr, "Could not allocate grammar workspace\n"); return 1; } gsl_rng* rng = gsl_rng_alloc( gsl_rng_env_setup() ); if(!rng) { fprintf(stderr, "Could not create rng\n"); return 1; } // Create a set of grammars according to desired initial condition grammar_t grammars[agents]; for(unsigned a=0; a<agents; a++) { if(! (grammars[a] = ginit()) ) { fprintf(stderr, "Could not create grammar\n"); } switch(initial_condition) { case ic_random: randomise_associations(grammars[a], rng); break; case ic_identity: identity_associations(grammars[a]); break; case ic_rook: rook_associations(grammars[a], rng); break; default: fprintf(stderr, "Unknown initial condition\n"); return 1; } renew_pseudo_associations(grammars[a]); } // Print out initial coherence matrix printf("coherence agents=%u round=0\n", agents); for(unsigned a1=0; a1<agents; a1++) { for(unsigned a2=0; a2<agents; a2++) { printf("%g ", coherence(grammars[a1], grammars[a2])); } printf("\n"); } printf("\n"); unsigned interactions_per_round = agents * meanings * signals; for(unsigned t=0;t<rounds*interactions_per_round;t++) { // Update loop starts here // 1. Choose a pair of speakers unsigned a1 = gsl_rng_uniform_int(rng, agents); unsigned a2 = gsl_rng_uniform_int(rng, agents-1); if (a2 >= a1) a2++; // 2. Speaker selects a topic meaning_t m1 = sample_meaning(grammars[a1], rng); // 3. Speaker produces a signal for m signal_t s = produce_signal(grammars[a1], m1, rng); // 4. Listener infers a meaning meaning_t m2 = infer_meaning(grammars[a2], s, rng); // 5. Obtain feedback double fb = feedback > 0.0 ? stochastic_feedback(m1,m2,rng) : deterministic_feedback(m1,m2); // 6. Update grammars vary_association(grammars[a1], m1, s, fb*stepsize ); vary_association(grammars[a2], m2, s, fb*stepsize ); renew_pseudo_associations(grammars[a1]); renew_pseudo_associations(grammars[a2]); // Update loop ends here // Print out the coherence matrix at the end of each rounds if((t+1) % interactions_per_round == 0) { printf("coherence agents=%u round=%u\n", agents, (t+1)/interactions_per_round); for(unsigned a1=0; a1<agents; a1++) { for(unsigned a2=0; a2<agents; a2++) { printf("%g ", coherence(grammars[a1], grammars[a2])); } printf("\n"); } printf("\n"); } } // Print out grammars at the end for(unsigned a=0; a<agents; a++) { printf("grammar agent=%u meanings=%u signals=%u round=%u\n", a, meanings, signals, rounds); for(meaning_t m=0; m<meanings; m++) { for(signal_t s=0;s<signals; s++) { printf("%g ", get_association(grammars[a], m, s)); } printf("\n"); } printf("\n"); } // Print out pseudo grammars at the end for(unsigned a=0; a<agents; a++) { printf("pseudo agent=%u meanings=%u signals=%u round=%u\n", a, meanings, signals, rounds); for(meaning_t m=0; m<meanings; m++) { for(signal_t s=0;s<signals; s++) { printf("%g ", get_pseudo_association(grammars[a], m, s)); } printf("\n"); } printf("\n"); } return 0; }
int main() { // ---------------------------------------------------------------- // Initialize the random number generator // ---------------------------------------------------------------- gsl_rng *rand_gen; rand_gen = gsl_rng_alloc(gsl_rng_mt19937); gsl_rng_set(rand_gen, seed); // ---------------------------------------------------------------- // Build the network---only use giant component // ---------------------------------------------------------------- struct node_gra *total_net = NULL; struct node_gra *net = NULL; FILE *infile; infile = fopen("test.dat", "r"); total_net = FBuildNetwork(infile, 0, 0, 0, 1); fclose(infile); net = GetLargestStronglyConnectedSet(total_net, 100000); // ---------------------------------------------------------------- // Initialize the coclassification matrix // ---------------------------------------------------------------- int i, j; int **coclas; int S = CountNodes(net); coclas = allocate_i_mat(S, S); for (i=0; i<S; i++) for (j=0; j<S; j++) coclas[i][j] = 0; // ---------------------------------------------------------------- // Find the modules rep times and calculate coclassification matrix // ---------------------------------------------------------------- struct group *part = NULL; struct node_gra *p1 = NULL; struct node_gra *p2 = NULL; for (i=0; i<rep; i++) { fprintf(stderr, "Repetition %d\n", i+1); part = SACommunityIdent(net, 0.0, -1.0, 0.0, 0.10, S, // #modules 'r', // r=random initial conf 1, // 0=No collective moves 'n', // n=no output rand_gen); // Update coclas matrix // -------------------------------------------------------------- p1 = net; while ((p1 = p1->next) != NULL) { p2 = net; while ((p2 = p2->next) != NULL) { if (p1->inGroup == p2->inGroup) coclas[p1->num][p2->num] += 1; } } // Remove the partition // -------------------------------------------------------------- RemovePartition(part); part = NULL; } // ---------------------------------------------------------------- // Output results // ---------------------------------------------------------------- p1 = net; while ((p1 = p1->next) != NULL) { p2 = net; while ((p2 = p2->next) != NULL) { fprintf(stdout, "%s %s -1 -1 -1 -1 %lf\n", p1->label, p2->label, (double)coclas[p1->num][p2->num] / (double)rep); } } // ---------------------------------------------------------------- // Free memory // ---------------------------------------------------------------- RemoveGraph(total_net); RemoveGraph(net); free_i_mat(coclas,S); gsl_rng_free(rand_gen); return 0; }
GammaDistributionFitter::GammaDistributionFitResult GammaDistributionFitter::fit(vector<DPosition<2> > & input) { const gsl_multifit_fdfsolver_type * T = NULL; gsl_multifit_fdfsolver * s = NULL; int status = 0; size_t iter = 0; const size_t p = 2; gsl_multifit_function_fdf f; double x_init[2] = { init_param_.b, init_param_.p }; gsl_vector_view x = gsl_vector_view_array(x_init, p); const gsl_rng_type * type = NULL; gsl_rng * r = NULL; gsl_rng_env_setup(); type = gsl_rng_default; r = gsl_rng_alloc(type); f.f = &gammaDistributionFitterf_; f.df = &gammaDistributionFitterdf_; f.fdf = &gammaDistributionFitterfdf_; f.n = input.size(); f.p = p; f.params = &input; T = gsl_multifit_fdfsolver_lmsder; s = gsl_multifit_fdfsolver_alloc(T, input.size(), p); gsl_multifit_fdfsolver_set(s, &f, &x.vector); #ifdef GAMMA_DISTRIBUTION_FITTER_VERBOSE printState_(iter, s); #endif do { ++iter; status = gsl_multifit_fdfsolver_iterate(s); #ifdef GAMMA_DISTRIBUTION_FITTER_VERBOSE printf("status = %s\n", gsl_strerror(status)); printState_(iter, s); #endif if (status) { break; } status = gsl_multifit_test_delta(s->dx, s->x, 1e-4, 1e-4); #ifdef GAMMA_DISTRIBUTION_FITTER_VERBOSE printf("Status = '%s'\n", gsl_strerror(status)); #endif } while (status == GSL_CONTINUE && iter < 1000); #ifdef GAMMA_DISTRIBUTION_FITTER_VERBOSE printf("Final status = '%s'\n", gsl_strerror(status)); #endif if (status != GSL_SUCCESS) { gsl_rng_free(r); gsl_multifit_fdfsolver_free(s); throw Exception::UnableToFit(__FILE__, __LINE__, __PRETTY_FUNCTION__, "UnableToFit-GammaDistributionFitter", "Could not fit the gamma distribution to the data"); } // write the result in a GammaDistributionFitResult struct GammaDistributionFitResult result; result.b = gsl_vector_get(s->x, 0); result.p = gsl_vector_get(s->x, 1); // build a formula with the fitted parameters for gnuplot stringstream formula; formula << "f(x)=" << "(" << result.b << " ** " << result.p << ") / gamma(" << result.p << ") * x ** (" << result.p << " - 1) * exp(- " << result.b << " * x)"; gnuplot_formula_ = formula.str(); #ifdef GAMMA_DISTRIBUTION_FITTER_VERBOSE cout << gnuplot_formula_ << endl; #endif gsl_rng_free(r); gsl_multifit_fdfsolver_free(s); return result; }
npRandom::npRandom(unsigned long int seed) { ran = gsl_rng_alloc(gsl_rng_mt19937); gsl_rng_set(ran, seed); }