Exemplo n.º 1
0
char *print_indiv( char *buffer )
{
  if ( *buffer < FSET_START )
    {
      printf( " X%d", *buffer );
      return( ++buffer );
    }
  printf(" (%c",prim_print[*buffer - FSET_START]);
  buffer = print_indiv( print_indiv( ++buffer ) );
  printf(")");
  return( buffer );
}
Exemplo n.º 2
0
/**
 * Simulate a day
 * Print the result of each hour
**/
void simulate_day(vector<tower>* solution, vector<tower>* towers, const int dist, float taux_var)
{
	cout << "DAY: " << endl;
	int index, n = (int) towers->size();
	for (int i = 0; i < 10; i++) {
		cout << i << "h: ";
		for (vector<tower>::iterator it = solution->begin(); it != solution->end(); it++) {
			if (it->var_est < 1) {
				do {
					index = rand() % n;
				} while (find(solution->begin(), solution->end(), (*towers)[index]) != solution->end() || !check_dist_with_specific_tower(solution, (*towers)[index], dist));
				change_var(towers, index, taux_var);
				*it = (*towers)[index];
			}
		}
		print_indiv(solution);
	}
}
Exemplo n.º 3
0
void stats( float *fitness, char **pop, int gen )
{
  int i, node_count;
  node_count = best = 0;
  favgpop = 0.0f;
  for ( i = 0; i < POPSIZE; i ++ )
    {
      node_count +=  length( pop[i] );
      favgpop += fitness[i];
      if ( fitness[i] > fitness[best] ) 
	best = i;
    }
  avg_len = (float) node_count / POPSIZE;
  favgpop /= POPSIZE;
  printf("\nGen=%d AvgFit=%g BestFit=%g Nodes=%lu Avg_size=%g\n",
         gen, -favgpop,  -fitness[best],nodes_evaluated,avg_len);
  print_indiv( pop[best] );
}
Exemplo n.º 4
0
/**
 * Principal function of the Genetic Algorithm
 * \fn shooter_repartition genetic algorithm heuristic for selection of towers
**/
void shooter_repartition(const char * input_file_name, const float mutation_prob, const int population_size, 
						 const int nb_children, const int nb_iteration, const int dist, float taux_var, bool sim)
{
	vector<tower>* towers = new vector<tower>();
	int k, n;
	tower_parse(input_file_name, *towers, k, n);
	srand((unsigned int) time(NULL));
	if (!is_easy_solution(k, n)) {
		vector<vector<tower>*>* population = generate_initial_pop(towers, k, dist, taux_var);
		sort_population(population);
		vector<vector<tower>*>* children;

		// population growth until reaching population_size
		while ((int) population->size() < population_size) { 
			children = reproduction_iteration(nb_children, mutation_prob, population, towers, dist, taux_var);
			sort_population(children);
			for (int i = 0; i < (int) children->size(); i++) {
				if ((int) population->size() < population_size) { //do not oversize the population_size  && !find_indiv(population, (*children)[i])
					population->push_back((*children)[i]);
				}
				else {
					break;
				}
			}
		}
		// reordering population
		sort_population(population);

		// iteration of genetic algorithm
		for (int j = 0; j < nb_iteration; j++) { 
			children = reproduction_iteration(nb_children, mutation_prob, population, towers, dist, taux_var);
			for (int i = 0; i < (int) children->size(); i++) {
				child_insertion((*children)[i], population);
			}
		}

		// printing the results
		for (int i = 0; i < 10 ; i++) { 
			cout << i+1 << " : ";
			print_indiv((*population)[i]);
		}

		if(sim)
			simulate_day(population->front(), towers, dist, taux_var);

		for (vector<vector<tower>*>::iterator it  = population->begin(); it != population->end(); it++){
			delete *it;
		}
		delete population;
	}
	else { // generate all the permutations and verify which is the best;
		int tmp_eval = 0, best_eval = 0;
		int nb_perm = binomial_coef(n,k);
		int t_size = towers->size();
		int *perm_indexes = (int*) malloc( k * sizeof(int)); //build index tracker to avoid repeating indivs
		vector<tower> *tmp_indiv, *best_indiv;
		tmp_indiv = new vector<tower>();
		best_indiv = new vector<tower>();
		for(int l = 0; l<k; l++){
			perm_indexes[l] = l;
			tmp_indiv->push_back((*towers)[l]);
		}
		// spread var for variance
		spread_indiv_var(tmp_indiv, towers, taux_var);
		*best_indiv = *tmp_indiv;
		best_eval = check_dist(best_indiv, dist) ? eval_indiv(best_indiv) : 0;
		for (int j = 0; j < nb_perm; j++){
			//build and eval permutation
			for (int i = 0; i < k ; i++){
				tmp_indiv->at(i) = towers->at(perm_indexes[i]);
			}
			spread_indiv_var(tmp_indiv, towers, taux_var);
			if(check_dist(tmp_indiv,dist)) {
				tmp_eval = eval_indiv(tmp_indiv);
				if (tmp_eval > best_eval) {
					best_eval = tmp_eval;
					*best_indiv = *tmp_indiv;
				}
			}
			//update of indexes tracker
			perm_indexes[k-1]++;
			for( int m = k-2; m >= 0; m--){ //go to next permutation
				if (perm_indexes[m+1] > t_size-(k-m-1)){
					perm_indexes[m]++;
					for(int p = m+1; p < k; p++){//correcting overflow
						perm_indexes[p] = perm_indexes[p-1]+1; 
					}
				}
			}
		}
		print_indiv(best_indiv);
		
		if (sim)
			simulate_day(best_indiv, towers, dist, taux_var);

		free(perm_indexes);
		delete best_indiv;
		delete tmp_indiv;

	}

	delete towers;
}