inline bool check_dist_and_prob(const char* function, const RealType& r, RealType p, RealType prob, RealType* result, const Policy& pol)
 {
   if(check_dist(function, r, p, result, pol) && detail::check_probability(function, prob, result, pol) == false)
   {
     return false;
   }
   return true;
 } // check_dist_and_prob
Beispiel #2
0
 inline bool check_dist_and_prob(const char* function, RealType p, RealType prob, RealType* result, const Policy& /* pol */)
 {
   if(check_dist(function, p, result, Policy()) && detail::check_probability(function, prob, result, Policy()) == false)
   {
     return false;
   }
   return true;
 }
Beispiel #3
0
 inline bool check_dist_and_prob(const char* function, RealType p, RealType prob, RealType* result, const Policy& /* pol */)
 {
   if((check_dist(function, p, result, Policy(), typename policies::method_error_check<Policy>::type()) && detail::check_probability(function, prob, result, Policy())) == false)
   {
     return false;
   }
   return true;
 }
 inline bool check_dist_and_k(const char* function, const RealType& r, const RealType& p, RealType k, RealType* result, const Policy& pol)
 {
   if(check_dist(function, r, p, result, pol) == false)
   {
     return false;
   }
   if( !(lslboost::math::isfinite)(k) || (k < 0) )
   { // Check k failures.
     *result = policies::raise_domain_error<RealType>(
       function,
       "Number of failures argument is %1%, but must be >= 0 !", k, pol);
     return false;
   }
   return true;
 } // Check_dist_and_k
Beispiel #5
0
 inline bool check_dist_and_k(const char* function, const RealType& p, RealType k, RealType* result, const Policy& pol)
 {
   if(check_dist(function, p, result, Policy()) == false)
   {
     return false;
   }
   if(!(boost::math::isfinite)(k) || !((k == 0) || (k == 1)))
   {
     *result = policies::raise_domain_error<RealType>(
       function,
       "Number of successes argument is %1%, but must be 0 or 1 !", k, pol);
     return false;
   }
  return true;
 }
Beispiel #6
0
float		count_dist(float xdep, float ydep, float xarr, float yarr)
{
  float		dist_long;
  float		dist_larg;
  float		hypothenuse;

  if (xdep == xarr || ydep == yarr)
    return (check_dist(xdep, ydep, xarr, yarr));
  else
    {
      dist_long = yarr - ydep;
      dist_larg = xarr - ydep;
      hypothenuse = sqrt((dist_long * dist_long) + (dist_larg * dist_larg));
      return (hypothenuse);
    }
}
Beispiel #7
0
 inline bool check_dist_and_k(const char* function, const RealType& N, const RealType& p, RealType k, RealType* result, const Policy& pol)
 {
    if(check_dist(function, N, p, result, pol) == false)
       return false;
    if((k < 0) || !(boost::math::isfinite)(k))
    {
        *result = policies::raise_domain_error<RealType>(
           function,
           "Number of Successes argument is %1%, but must be >= 0 !", k, pol);
        return false;
    }
    if(k > N)
    {
        *result = policies::raise_domain_error<RealType>(
           function,
           "Number of Successes argument is %1%, but must be <= Number of Trials !", k, pol);
        return false;
    }
    return true;
 }
 inline bool check_dist_and_prob(const char* function, const RealType& alpha, const RealType& beta, RealType p, RealType* result, const Policy& pol)
 {
   return check_dist(function, alpha, beta, result, pol)
     && check_prob(function, p, result, pol);
 } // bool check_dist_and_prob
Beispiel #9
0
 inline bool check_dist(const char* function, const RealType& p, RealType* result, const Policy& /* pol */)
 {
    return check_dist(function, p, result, Policy(), typename policies::constructor_error_check<Policy>::type());
 }
Beispiel #10
0
 inline bool check_dist_and_x(const char* function, const RealType& alpha, const RealType& beta, RealType x, RealType* result, const Policy& pol)
 {
   return check_dist(function, alpha, beta, result, pol)
     && beta_detail::check_x(function, x, result, pol);
 } // bool check_dist_and_x
Beispiel #11
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;
}
Beispiel #12
0
/**
 * Reproduction between two individu
 * Mix : [1 2 3 4 5] + [15 16 17 18 19] = [1 2 17 18 19] and [15 16 3 4 5]
**/
vector<tower>* mix(vector<tower>* parent1, vector<tower>* parent2, const int dist, vector<tower>* towers, float taux_var){
	vector<tower>* child1 = new vector<tower>();
	vector<tower>* child2 = new vector<tower>();
	for(int i = 0; i < ((int) parent1->size()/2); i++){
		child1->push_back((*parent1)[i]);
		child2->push_back((*parent2)[i]);
	}

	for(int i = ((int) parent1->size()/2); i < (int) parent1->size(); i++){
		if (find(child1->begin(), child1->end(), (*parent2)[i]) != child1->end() || find(child2->begin(), child2->end(), (*parent1)[i]) != child2->end()) { // ensure the unicity of tower 
			if (find(child1->begin(), child1->end(), (*parent1)[i]) != child1->end() || find(child2->begin(), child2->end(), (*parent2)[i]) != child2->end()) { // ensure the unicity of tower 
				delete child1;
				delete child2;
				return new vector<tower>();
			}
			else {
				child1->push_back((*parent1)[i]);
				child2->push_back((*parent2)[i]);
			}
		}
		else {
			child1->push_back((*parent2)[i]);
			child2->push_back((*parent1)[i]);
		}
	}

	if (*child1 == *parent1 || *child2 == *parent2 || *child1 == *parent2 || *child2 == *parent1)
	{
		delete child1;
		delete child2;
		return new vector<tower>();
	}

	// reset child and spread var
	spread_indiv_var(child1, towers, taux_var);
	spread_indiv_var(child2, towers, taux_var);

	if(*child1 < *child2){
		if (check_dist(child2, dist)) {
			delete child1;
			return child2;
		}
		else {
			if (check_dist(child1, dist)) {// if the first child don't respect the distance try it for the orher child
				delete child2;
				return child1;
			}
			else {
				delete child1;
				delete child2;
				return new vector<tower>();
			}
		}
	}
	else {
		if (check_dist(child1, dist)) {
			delete child2;
			return child1;
		}
		else {
			if (check_dist(child2, dist)) {// if the first child don't respect the distance try it for the orher child
				delete child1;
				return child2;
			}
			else {
				delete child1;
				delete child2;
				return new vector<tower>();
			}
		}
		
	}
}