void use_sorting(int a[], int lenght)
{
results(a, lenght);
save_results(a, lenght);//сохраняем исходный массив в файле
cout << "\nheap sort" << endl;
heap_sort(a, lenght);
results(a, lenght);//вывод на экран
//сохранение в файл
save_results(a, lenght);//сохраняем отсортированный массив
delete [] a;
}
int main(int argc, char ** argv){
// parse arguments
if(argc != 4){
printf("usage: ./random problem_file execution_number num_iterations\n");
return -1;
}
const char * file_name = argv[file_name_idx];
int execution_number = atoi(argv[execution_idx]);
long long num_processed = atoll(argv[num_processed_idx]);
// read instance
Instance instance = Instance::load(file_name);
instance.preprocess();
int n = instance.num_words();
int best_known = instance.superstring_length();
int random_best = INT_MAX;
int start = time(0);
#pragma omp parallel for
for(int i = 0; i < num_processed; i++){
Individual x(n);
x.randomize();
int v = instance.evaluate(&x);
#pragma omp critical
{
if(v < random_best) random_best = v;
int duration = time(0) - start;
printf("time = %d\nbest found = %d\nbest known = %d\n", duration, random_best, best_known);
save_results(random_best, num_processed, duration, file_name, execution_number);
}
}
int duration = time(0) - start;
printf("time = %d\nbest found = %d\nbest known = %d\n", duration, random_best, best_known);
save_results(random_best, num_processed, duration, file_name, execution_number);
return 0;
}
int main(int argc, char** argv)
{
/* declearation */
DT *a, b;
long arr_bytes, arr_size, p;
int i, samples;
double t_start, t_end, deltaT;
/* initialization */
b = 0.0;
arr_bytes = 1024 * 1024 * 1024; // 1GB
arr_size = arr_bytes/sizeof(DT);
samples = 3;
/* memory allocation */
#ifndef MIC
a = (DT *)malloc(arr_bytes);
#else
a = (DT *)_mm_malloc(arr_bytes, 64);
#endif
if(a==NULL)
{
DB(RT_LVL, "array 'a' allocation failed");
}
fill(a, arr_size, 5.0);
#pragma omp parallel
{
init_flush_cache_array();
}
/* measurement */
for(i=0; i<samples; i++)
{
#pragma omp parallel
{
flush_cache();
}
t_start = timer();
#pragma omp parallel for private(p) shared(a, arr_size)
for(p=0; p<arr_size; p++)
{
//b += a[p];
a[p] = b;
}
b = b + 1.0;
t_end = timer();
if(i==(samples-1))
{
deltaT = t_end - t_start;
SAVE_DATA("%lf\t", arr_bytes/deltaT)
printf("bw: %lf\t", arr_bytes/deltaT);
}
}
b = a[0] + a[arr_size-1];
save_results(&b, 1); // save results to avoid the aggressive optimizations
SAVE_DATA("\n")
/* post-process */
#ifndef MIC
if(a!=NULL) free(a);
#else
if(a!=NULL) _mm_free(a);
#endif
return 0;
}
/*Algoritmo Principal*/
int main(int argc, char *argv[])
{
char name[20];// = "_kita_1";
char archiveName[20] = "archive";
char fitputName[20] = "fitput";
char varputName[20] = "varput";
char hvName[20]= "hv";
unsigned int i, j, t;
unsigned int fun, gen;
clock_t startTime, endTime;
double duration, clocktime;
FILE *fitfile,*varfile;
/*Parametros iniciales*/
strcpy(name,argv[1]);
fun = atoi(argv[2]);
gen = atoi(argv[3]);
printf("%s %d %d \n",name,fun,gen);
initialize_data(fun,gen);
/*Iniciar variables*/
initialize_memory();
/*
sprintf(name,"kita_1_");
sprintf(archiveName,strcat(name,"archive.out"));
sprintf(fitputName, strcat(name,"fitput.out"));
sprintf(varputName, strcat(name,"varput.out"));
sprintf(hvName,strcat(name,"hv.out"));
*/
//fitfile = fopen(strcat(strcat(fitputName,name),".out"),"w");
//varfile = fopen(strcat(strcat(varputName,name),".out"),"w");
//hv = fopen(strcat(strcat(hvName,name),".out"),"w");
/* Iniciar generador de aleatorios*/
initialize_rand();
startTime = clock();
/* Iniciar contador de generaciones*/
t = 0;
/* Iniciar valores de la poblacion de manera aleatoria*/
initialize_pop();
/* Calcular velocidad inicial*/
initialize_vel();
/* Evaluar las particulas de la poblacion*/
evaluate();
/* Almacenar el pBest inicial (variables and valor de aptitud) de las particulas*/
store_pbests();
/* Insertar las particulas no domindas de la poblacion en el archivo*/
insert_nondom();
//printf("\n%d",nondomCtr);
/*Ciclo Principal*/
while(t <= maxgen)
{
//clocktime = (clock() - startTime)/(double)CLOCKS_PER_SEC;
/*if(verbose > 0 && t%printevery==0 || t == maxgen)
{
fprintf(stdout,"Generation %d Time: %.2f sec\n",t,clocktime);
fflush(stdout);
}*/
/*if(t%printevery==0 || t == maxgen)
{
fprintf(outfile,"Generation %d Time: %.2f sec\n",t,clocktime);
}*/
/* Calcular la nueva velocidad de cada particula en la pooblacion*/
//printf("\n 1");
compute_velocity();
/* Calcular la nueva posicion de cada particula en la poblacion*/
//printf("\n 2");
compute_position();
/* Mantener las particulas en la poblacion de la poblacion en el espacio de busqueda*/
//printf("\n 3");
maintain_particles();
/* Pertubar las particulas en la poblacion*/
if(t < maxgen * pMut)
mutate(t);
/* Evaluar las particulas en la poblacion*/
//printf("\n 4");
evaluate();
/* Insertar nuevas particulas no domindas en el archivo*/
//printf("\n 5");
update_archive();
/* Actualizar el pBest de las particulas en la poblacion*/
//printf("\n 6");
update_pbests();
/* Escribir resultados del mejor hasta ahora*/
//verbose > 0 && t%printevery==0 || t == maxgen
/*if(t%printevery==0 || t == maxgen)
{
//fprintf(outfile, "Size of Pareto Set: %d\n", nondomCtr);
fprintf(fitfile, "%d\n",t);
fprintf(varfile, "%d\n",t);
for(i = 0; i < nondomCtr; i++)
{
for(j = 0; j < maxfun; j++)
fprintf(fitfile, "%f ", archiveFit[i][j]);
fprintf(fitfile, "\n");
}
fprintf(fitfile, "\n\n");
fflush(fitfile);
for(i = 0; i < nondomCtr; i++)
{
for(j = 0; j < maxfun; j++)
fprintf(varfile, "%f ", archiveVar[i][j]);
fprintf(varfile, "\n");
}
fprintf(varfile, "\n\n");
fflush(varfile);
}*/
/* Incrementar contador de generaciones*/
t++;
//printf("%d\n",t);
}
/* Escribir resultados en el archivo */
save_results(strcat(strcat(archiveName,name),".out"));
endTime = clock();
duration = ( endTime - startTime ) / (double)CLOCKS_PER_SEC;
fprintf(stdout, "%lf sec\n", duration);
//fclose(fitfile);
//fclose(varfile);
free_memory();
return EXIT_SUCCESS;
}
// Required entry point
//------------------------------------------------------------------------------
int sample_main( int argc, const char** argv )
{
// show console and redirect printing
NVPWindow::sysVisibleConsole();
const Config config( argc, argv );
Timer timer;
//
// Load scene
//
std::cerr << "Load scene ... "; std::cerr.flush();
timer.start();
bake::Scene scene;
SceneMemory* scene_memory;
float scene_bbox_min[] = {FLT_MAX, FLT_MAX, FLT_MAX};
float scene_bbox_max[] = {-FLT_MAX, -FLT_MAX, -FLT_MAX};
if (!load_scene( config.scene_filename.c_str(), scene, scene_bbox_min, scene_bbox_max, scene_memory, config.num_instances_per_mesh )) {
std::cerr << "Failed to load scene, exiting" << std::endl;
exit(-1);
}
printTimeElapsed( timer );
// Print scene stats
{
std::cerr << "Loaded scene: " << config.scene_filename << std::endl;
std::cerr << "\t" << scene.num_meshes << " meshes, " << scene.num_instances << " instances" << std::endl;
size_t num_vertices = 0;
size_t num_triangles = 0;
for (size_t i = 0; i < scene.num_meshes; ++i) {
num_vertices += scene.meshes[i].num_vertices;
num_triangles += scene.meshes[i].num_triangles;
}
std::cerr << "\tuninstanced vertices: " << num_vertices << std::endl;
std::cerr << "\tuninstanced triangles: " << num_triangles << std::endl;
}
// OptiX Prime requires all instances to have the same vertex stride
for (size_t i = 1; i < scene.num_meshes; ++i) {
if (scene.meshes[i].vertex_stride_bytes != scene.meshes[0].vertex_stride_bytes) {
std::cerr << "Error: all meshes must have the same vertex stride. Bailing.\n";
exit(-1);
}
}
//
// Generate AO samples
//
std::cerr << "Minimum samples per face: " << config.min_samples_per_face << std::endl;
std::cerr << "Generate sample points ... \n"; std::cerr.flush();
timer.reset();
timer.start();
std::vector<size_t> num_samples_per_instance(scene.num_instances);
const size_t total_samples = bake::distributeSamples( scene, config.min_samples_per_face, config.num_samples, &num_samples_per_instance[0] );
bake::AOSamples ao_samples;
allocate_ao_samples( ao_samples, total_samples );
bake::sampleInstances( scene, &num_samples_per_instance[0], config.min_samples_per_face, ao_samples );
printTimeElapsed( timer );
std::cerr << "Total samples: " << total_samples << std::endl;
{
const int sqrt_num_rays = static_cast<int>( sqrtf( static_cast<float>( config.num_rays ) ) + .5f );
std::cerr << "Rays per sample: " << sqrt_num_rays * sqrt_num_rays << std::endl;
std::cerr << "Total rays: " << total_samples * sqrt_num_rays * sqrt_num_rays << std::endl;
}
//
// Evaluate AO samples
//
std::cerr << "Compute AO ... "; std::cerr.flush();
timer.reset();
timer.start();
std::vector<float> ao_values( total_samples );
std::fill(ao_values.begin(), ao_values.end(), 0.0f);
float scene_maxdistance;
float scene_offset;
{
const float scene_scale = std::max(std::max(scene_bbox_max[0] - scene_bbox_min[0],
scene_bbox_max[1] - scene_bbox_min[1]),
scene_bbox_max[2] - scene_bbox_min[2]);
scene_maxdistance = scene_scale * config.scene_maxdistance_scale;
scene_offset = scene_scale * config.scene_offset_scale;
if (config.scene_offset){
scene_offset = config.scene_offset;
}
if (config.scene_maxdistance){
scene_maxdistance = config.scene_maxdistance;
}
}
if (config.use_ground_plane_blocker) {
// Add blocker for ground plane (no surface samples)
std::vector<bake::Mesh> blocker_meshes;
std::vector<bake::Instance> blocker_instances;
std::vector<float> plane_vertices;
std::vector<unsigned int> plane_indices;
make_ground_plane(scene_bbox_min, scene_bbox_max, config.ground_upaxis, config.ground_scale_factor, config.ground_offset_factor,
scene.meshes[0].vertex_stride_bytes,
plane_vertices, plane_indices, blocker_meshes, blocker_instances);
bake::Scene blockers = { &blocker_meshes[0], blocker_meshes.size(), &blocker_instances[0], blocker_instances.size() };
bake::computeAOWithBlockers(scene, blockers,
ao_samples, config.num_rays, scene_offset, scene_maxdistance, config.use_cpu, config.conserve_memory, &ao_values[0]);
} else {
bake::computeAO(scene, ao_samples, config.num_rays, scene_offset, scene_maxdistance, config.use_cpu, config.conserve_memory, &ao_values[0]);
}
printTimeElapsed( timer );
std::cerr << "Map AO to vertices ... "; std::cerr.flush();
timer.reset();
timer.start();
float** vertex_ao = new float*[ scene.num_instances ];
for (size_t i = 0; i < scene.num_instances; ++i ) {
vertex_ao[i] = new float[ scene.meshes[scene.instances[i].mesh_index].num_vertices ];
}
bake::mapAOToVertices( scene, &num_samples_per_instance[0], ao_samples, &ao_values[0], config.filter_mode, config.regularization_weight, vertex_ao );
printTimeElapsed( timer );
if (!config.output_filename.empty())
{
std::cerr << "Save vertex ao ... "; std::cerr.flush();
timer.reset();
timer.start();
bool saved = save_results(config.output_filename.c_str(), scene, vertex_ao);
printTimeElapsed(timer);
if (saved){
std::cerr << "Saved vertex ao to: " << config.output_filename << std::endl;
}
else{
std::cerr << "Failed to save vertex ao to: " << config.output_filename << std::endl;
}
}
if (config.use_viewer){
//
// Visualize results
//
std::cerr << "Launch viewer ... \n" << std::endl;
bake::view(scene.meshes, scene.num_meshes, scene.instances, scene.num_instances, vertex_ao, scene_bbox_min, scene_bbox_max);
}
for (size_t i = 0; i < scene.num_instances; ++i) {
delete [] vertex_ao[i];
}
delete [] vertex_ao;
destroy_ao_samples( ao_samples );
delete scene_memory;
return 1;
}
int infogap_obs( struct opt_data *op )
{
int i, j, ig_index, status, success = 0, count, neval_total, njac_total, no_memory = 0;
double *opt_params, phi_min = HUGE_VAL;
int ( *optimize_func )( struct opt_data * op );
if( ( opt_params = ( double * ) malloc( op->pd->nOptParam * sizeof( double ) ) ) == NULL ) no_memory = 1;
if( no_memory ) { tprintf( "Not enough memory!\n" ); return( 0 ); }
tprintf( "\n\nInfo-gap analysis: observation step %g observation domain %g\nInfo-gap search: ", op->cd->obsstep, op->cd->obsdomain );
if( op->cd->obsstep > DBL_EPSILON ) tprintf( "maximum\n" ); else tprintf( "minimum\n" );
tprintf( "Number of predictions %d\n", op->preds->nTObs );
for( i = 0; i < op->preds->nTObs; i++ )
{
// op->preds->obs_best are updated in mads_func.c
if( op->cd->obsstep > DBL_EPSILON ) op->preds->obs_best[i] = -HUGE_VAL; // max search
else op->preds->obs_best[i] = HUGE_VAL; // min search
j = op->preds->obs_index[i];
op->od->obs_weight[j] *= -1;
}
ig_index = op->preds->obs_index[0]; // first prediction is applied only
tprintf( "Info-gap observation:\n" );
tprintf( "%-20s: info-gap target %12g weight %12g range %12g - %12g\n", op->od->obs_id[ig_index], op->od->obs_target[ig_index], op->od->obs_weight[ig_index], op->od->obs_min[ig_index], op->od->obs_max[ig_index] );
if( op->cd->obsstep > DBL_EPSILON ) { op->od->obs_target[ig_index] = op->od->obs_min[ig_index]; op->od->obs_min[ig_index] -= op->cd->obsstep / 2; } // obsstep is positive
else { op->od->obs_target[ig_index] = op->od->obs_max[ig_index]; op->od->obs_max[ig_index] -= op->cd->obsstep / 2; } // obsstep is negative
if( strncasecmp( op->cd->opt_method, "lm", 2 ) == 0 ) optimize_func = optimize_lm; // Define optimization method: LM
else optimize_func = optimize_pso; // Define optimization method: PSO
neval_total = njac_total = count = 0;
while( 1 )
{
tprintf( "\nInfo-gap analysis #%d\n", ++count );
tprintf( "%-20s: info-gap target %12g weight %12g range %12g - %12g\n", op->od->obs_id[ig_index], op->od->obs_target[ig_index], op->od->obs_weight[ig_index], op->od->obs_min[ig_index], op->od->obs_max[ig_index] );
op->cd->neval = op->cd->njac = 0;
if( op->cd->analysis_type == IGRND ) status = igrnd( op );
else status = optimize_func( op );
neval_total += op->cd->neval;
njac_total += op->cd->njac;
if( !status ) break;
if( op->success )
{
for( i = 0; i < op->pd->nOptParam; i++ ) opt_params[i] = op->pd->var[op->pd->var_index[i]];
for( i = 0; i < op->od->nTObs; i++ ) op->od->obs_best[i] = op->od->obs_current[i];
phi_min = op->phi;
success = 1;
}
tprintf( "Intermediate info-gap results for model predictions:\n" );
tprintf( "%-20s: info-gap target %12g weight %12g range %12g - %12g\n", op->od->obs_id[ig_index], op->od->obs_target[ig_index], op->od->obs_weight[ig_index], op->od->obs_min[ig_index], op->od->obs_max[ig_index] );
for( i = 0; i < op->preds->nTObs; i++ )
{
j = op->preds->obs_index[i];
if( op->cd->obsstep > DBL_EPSILON ) tprintf( "%-20s: Current info-gap max %12g Observation step %g Observation domain %g Success %d\n", op->od->obs_id[j], op->preds->obs_best[i], op->cd->obsstep, op->cd->obsdomain, op->success );
else tprintf( "%-20s: Current info-gap min %12g Observation step %g Observation domain %g Success %d\n", op->od->obs_id[j], op->preds->obs_best[i], op->cd->obsstep, op->cd->obsdomain, op->success );
}
if( !op->success ) break;
if( op->cd->debug ) print_results( op, 1 );
save_results( 1, "infogap", op, op->gd );
op->od->obs_target[ig_index] += op->cd->obsstep;
if( op->cd->obsstep > DBL_EPSILON ) // max search
{
if( op->od->obs_target[ig_index] > op->od->obs_max[ig_index] ) break;
if( fabs( op->preds->obs_best[0] - op->od->obs_max[ig_index] ) < DBL_EPSILON ) break;
op->od->obs_min[ig_index] += op->cd->obsstep;
j = ( int )( ( double )( op->preds->obs_best[0] - op->od->obs_min[ig_index] + op->cd->obsstep / 2 ) / op->cd->obsstep + 1 );
op->od->obs_target[ig_index] += op->cd->obsstep * j;
op->od->obs_min[ig_index] += op->cd->obsstep * j;
if( op->od->obs_target[ig_index] > op->od->obs_max[ig_index] ) op->od->obs_target[ig_index] = op->od->obs_max[ig_index];
if( op->od->obs_min[ig_index] > op->od->obs_max[ig_index] ) op->od->obs_min[ig_index] = op->od->obs_max[ig_index];
}
else // min search
{
if( op->od->obs_target[ig_index] < op->od->obs_min[ig_index] ) break;
if( fabs( op->preds->obs_best[0] - op->od->obs_min[ig_index] ) < DBL_EPSILON ) break;
op->od->obs_max[ig_index] += op->cd->obsstep; // obsstep is negative
j = ( int )( ( double )( op->od->obs_max[ig_index] - op->preds->obs_best[0] - op->cd->obsstep / 2 ) / -op->cd->obsstep + 1 ); // obsstep is negative
op->od->obs_target[ig_index] += op->cd->obsstep * j;
op->od->obs_max[ig_index] += op->cd->obsstep * j;
if( op->od->obs_target[ig_index] < op->od->obs_min[ig_index] ) op->od->obs_target[ig_index] = op->od->obs_min[ig_index];
if( op->od->obs_max[ig_index] < op->od->obs_min[ig_index] ) op->od->obs_max[ig_index] = op->od->obs_min[ig_index];
}
}
op->cd->neval = neval_total; // provide the correct number of total evaluations
op->cd->njac = njac_total; // provide the correct number of total evaluations
if( success )
{
for( i = 0; i < op->pd->nOptParam; i++ ) op->cd->var[i] = op->pd->var[op->pd->var_index[i]] = op->pd->var_current[i] = op->pd->var_best[i] = opt_params[i];
for( i = 0; i < op->od->nTObs; i++ ) op->od->obs_current[i] = op->od->obs_best[i];
op->phi = phi_min;
op->success = success;
}
else tprintf( "\nWARNING: Info-gap analysis failed to find acceptable solutions!\n" );
tprintf( "\nInfo-gap results for model predictions:\n" );
for( i = 0; i < op->preds->nTObs; i++ )
{
j = op->preds->obs_index[i];
if( op->cd->obsstep > DBL_EPSILON ) tprintf( "%-20s: Info-gap max %12g Observation step %g Observation domain %g\n", op->od->obs_id[j], op->preds->obs_best[i], op->cd->obsstep, op->cd->obsdomain ); // max search
else tprintf( "%-20s: Info-gap min %12g Observation step %g Observation domain %g\n", op->od->obs_id[j], op->preds->obs_best[i], op->cd->obsstep, op->cd->obsdomain ); // min search
op->od->obs_target[j] = op->preds->obs_target[i];
op->od->obs_min[j] = op->preds->obs_min[i];
op->od->obs_max[j] = op->preds->obs_max[i];
op->od->obs_weight[j] *= -1;
}
tprintf( "\n" );
free( opt_params );
print_results( op, 1 );
save_results( 1, "", op, op->gd );
return( 1 );
}
void gmmreg_base::run(const char* f_config) {
initialize(f_config);
vnl_vector<double> params;
start_registration(params);
save_results(f_config, params);
}
/**
* The E-means algorithm, uses a genetic algorithm to optimize the parameters
* for the K-means implemetation of clustering based Lloyds clustering algorithm.
*
* @return Status code, 0 for SUCCESS, 1 for ERROR
*/
int emeans(void)
{
gsl_matrix *data = NULL,
*bounds = NULL,
*parent1 = NULL,
*parent2 = NULL,
**population = NULL,
**new_population = NULL,
***clusters = NULL;
int status = SUCCESS;
double fitness[size],
probability[size];
// Initialize the PRNG
pcg32_random_t rng;
int rounds = 5;
pcg32_srandom_r(&rng, time(NULL) ^ (intptr_t)&printf, (intptr_t)&rounds);
// Allocate memory and load the data
data = gsl_matrix_alloc(data_rows, data_cols);
bounds = gsl_matrix_alloc(data_cols, 2);
parent1 = gsl_matrix_alloc(n_clusters, data_cols);
parent2 = gsl_matrix_alloc(n_clusters, data_cols);
population = (gsl_matrix **)calloc(size, sizeof(gsl_matrix **));
new_population = (gsl_matrix **)calloc(size, sizeof(gsl_matrix **));
clusters = (gsl_matrix ***)calloc(size, sizeof(gsl_matrix ***));
for (int i = 0; i < (int)size; ++i)
{
clusters[i] = (gsl_matrix **)calloc(n_clusters, sizeof(gsl_matrix **));
population[i] = gsl_matrix_alloc(n_clusters, data_cols);
new_population[i] = gsl_matrix_alloc(n_clusters, data_cols);
}
if ((status = load_data(data_file, data)) != SUCCESS)
{
fprintf(stderr, RED "Unable to load data!\n" RESET);
status = ERROR;
goto free;
}
// Calculate the bounds of the data
calc_bounds(data, bounds);
// Generate the initial population
printf(CYAN "Generating initial population...\n" RESET);
for (int i = 0; i < (int)size; ++i)
{
random_centroids(population[i], bounds, &rng);
}
// Perform the Genetic Algorithm
for (int iter = 0; iter < max_iter; ++iter)
{
// Compute the fitness of each chromosome
for (int i = 0; i < (int)size; ++i)
{
lloyd_defined(trials, population[i], data, n_clusters, clusters[i]);
fitness[i] = dunn_index(population[i], n_clusters, clusters[i]);
if (VERBOSE == 1)
printf(CYAN "chromsome[%d], fitness: %10.6f\n" RESET, i, fitness[i]);
}
// Generate the probabilities for roulette wheel selection
gen_probability(size, fitness, probability);
// Save the results if there is a new best solution
save_results(fitness_file, centroids_file, cluster_file, size, fitness,
population, n_clusters, clusters);
// Perform roulette wheel selection and GA operators
if (VERBOSE == 1)
printf(CYAN "Executing roulette wheel selection...\n" RESET);
// Select parents from the population and perform genetic operators
for (int i = 0; i < size; i += 2)
{
// Select parents
for (int j = 0, idx = 0; j < 2; ++j)
{
idx = select_parent(size, probability, &rng);
if (VERBOSE == 1)
printf(CYAN "Parent %d selected as chromsome %d from population\n" RESET, j, idx);
if (j == 0)
gsl_matrix_memcpy(parent1, population[idx]);
else
gsl_matrix_memcpy(parent2, population[idx]);
}
// Perform crossover and mutation with specified probabilities
if (VERBOSE == 1)
printf(CYAN "Performing crossover...\n" RESET);
if (pcg32_random_r(&rng) / (double)UINT32_MAX <= c_rate)
{
crossover(parent1, parent2, &rng);
}
if (VERBOSE == 1)
printf(CYAN "Performing background mutation...\n" RESET);
for (int j = 0; j < 2; ++j)
{
if (pcg32_random_r(&rng) / (double)UINT32_MAX <= m_rate)
{
if (j == 0)
mutate(parent1, bounds, &rng);
else
mutate(parent2, bounds, &rng);
}
}
// Copy each parent to the new population
if (VERBOSE == 1)
printf(CYAN "Copying parents to new population...\n" RESET);
gsl_matrix_memcpy(new_population[i], parent1);
gsl_matrix_memcpy(new_population[i+1], parent2);
}
// Copy the new population to the next population
if (VERBOSE == 1)
printf(CYAN "Copying current population as new population\n" RESET);
for (int i = 0; i < size; ++i)
{
gsl_matrix_memcpy(population[i], new_population[i]);
}
// Check if stop signal, terminate if present
if (access("./stop", F_OK) != -1)
{
printf(YELLOW "Stop signal received, shutting down!\n" RESET);
remove("./stop");
break;
}
}
printf(GREEN "Finished executing E-means, shutting down!\n" RESET);
free:
for (int i = 0; i < (int)size; ++i)
{
for (int j = 0; j < n_clusters; ++j)
{
gsl_matrix_free(clusters[i][j]);
}
free(clusters[i]);
}
free(clusters);
for (int i = 0; i < (int)size; ++i)
{
gsl_matrix_free(population[i]);
gsl_matrix_free(new_population[i]);
}
free(population);
free(new_population);
gsl_matrix_free(data);
gsl_matrix_free(bounds);
return status;
}
