void ms::evolve(population &pop) const
{
// Let's store some useful variables.
const population::size_type NP = pop.size();
// Get out if there is nothing to do.
if (m_starts == 0 || NP == 0) {
return;
}
// Local population used in the algorithm iterations.
population working_pop(pop);
//ms main loop
for (int i=0; i< m_starts; ++i)
{
working_pop.reinit();
m_algorithm->evolve(working_pop);
if (working_pop.problem().compare_fc(working_pop.get_individual(working_pop.get_best_idx()).cur_f,working_pop.get_individual(working_pop.get_best_idx()).cur_c,
pop.get_individual(pop.get_worst_idx()).cur_f,pop.get_individual(pop.get_worst_idx()).cur_c
) )
{
//update best population replacing its worst individual with the good one just produced.
pop.set_x(pop.get_worst_idx(),working_pop.get_individual(working_pop.get_best_idx()).cur_x);
pop.set_v(pop.get_worst_idx(),working_pop.get_individual(working_pop.get_best_idx()).cur_v);
}
if (m_screen_output)
{
std::cout << i << ". " << "\tCurrent iteration best: " << working_pop.get_individual(working_pop.get_best_idx()).cur_f << "\tOverall champion: " << pop.champion().f << std::endl;
}
}
}
/// Evolve method.
void monte_carlo::evolve(population &pop) const
{
// Let's store some useful variables.
const problem::base &prob = pop.problem();
const problem::base::size_type prob_dimension = prob.get_dimension(), prob_i_dimension = prob.get_i_dimension();
const decision_vector &lb = prob.get_lb(), &ub = prob.get_ub();
const population::size_type pop_size = pop.size();
// Get out if there is nothing to do.
if (pop_size == 0 || m_max_eval == 0) {
return;
}
// Initialise temporary decision vector, fitness vector and decision vector.
decision_vector tmp_x(prob_dimension);
fitness_vector tmp_f(prob.get_f_dimension());
constraint_vector tmp_c(prob.get_c_dimension());
// Main loop.
for (std::size_t i = 0; i < m_max_eval; ++i) {
// Generate a random decision vector.
for (problem::base::size_type j = 0; j < prob_dimension - prob_i_dimension; ++j) {
tmp_x[j] = boost::uniform_real<double>(lb[j],ub[j])(m_drng);
}
for (problem::base::size_type j = prob_dimension - prob_i_dimension; j < prob_dimension; ++j) {
tmp_x[j] = boost::uniform_int<int>(lb[j],ub[j])(m_urng);
}
// Compute fitness and constraints.
prob.objfun(tmp_f,tmp_x);
prob.compute_constraints(tmp_c,tmp_x);
// Locate the worst individual.
const population::size_type worst_idx = pop.get_worst_idx();
if (prob.compare_fc(tmp_f,tmp_c,pop.get_individual(worst_idx).cur_f,pop.get_individual(worst_idx).cur_c)) {
pop.set_x(worst_idx,tmp_x);
}
}
}
void ihs::evolve(population &pop) const
{
// Let's store some useful variables.
const problem::base &prob = pop.problem();
const problem::base::size_type prob_dimension = prob.get_dimension(), prob_i_dimension = prob.get_i_dimension();
const decision_vector &lb = prob.get_lb(), &ub = prob.get_ub();
const population::size_type pop_size = pop.size();
// Get out if there is nothing to do.
if (pop_size == 0 || m_gen == 0) {
return;
}
decision_vector lu_diff(prob_dimension);
for (problem::base::size_type i = 0; i < prob_dimension; ++i) {
lu_diff[i] = ub[i] - lb[i];
}
// Int distribution to be used when picking random individuals.
boost::uniform_int<population::size_type> uni_int(0,pop_size - 1);
const double c = std::log(m_bw_min/m_bw_max) / m_gen;
// Temporary individual used during evolution.
population::individual_type tmp;
tmp.cur_x.resize(prob_dimension);
tmp.cur_f.resize(prob.get_f_dimension());
tmp.cur_c.resize(prob.get_c_dimension());
for (std::size_t g = 0; g < m_gen; ++g) {
const double ppar_cur = m_ppar_min + ((m_ppar_max - m_ppar_min) * g) / m_gen, bw_cur = m_bw_max * std::exp(c * g);
// Continuous part.
for (problem::base::size_type i = 0; i < prob_dimension - prob_i_dimension; ++i) {
if (m_drng() < m_phmcr) {
// tmp's i-th chromosome element is the one from a randomly chosen individual.
tmp.cur_x[i] = pop.get_individual(uni_int(m_urng)).cur_x[i];
// Do pitch adjustment with ppar_cur probability.
if (m_drng() < ppar_cur) {
// Randomly, add or subtract pitch from the current chromosome element.
if (m_drng() > .5) {
tmp.cur_x[i] += m_drng() * bw_cur * lu_diff[i];
} else {
tmp.cur_x[i] -= m_drng() * bw_cur * lu_diff[i];
}
// Handle the case in which we added or subtracted too much and ended up out
// of boundaries.
if (tmp.cur_x[i] > ub[i]) {
tmp.cur_x[i] = boost::uniform_real<double>(lb[i],ub[i])(m_drng);
} else if (tmp.cur_x[i] < lb[i]) {
tmp.cur_x[i] = boost::uniform_real<double>(lb[i],ub[i])(m_drng);
}
}
} else {
// Pick randomly within the bounds.
tmp.cur_x[i] = boost::uniform_real<double>(lb[i],ub[i])(m_drng);
}
}
//Integer Part
for (problem::base::size_type i = prob_dimension - prob_i_dimension; i < prob_dimension; ++i) {
if (m_drng() < m_phmcr) {
tmp.cur_x[i] = pop.get_individual(uni_int(m_urng)).cur_x[i];
if (m_drng() < ppar_cur) {
if (m_drng() > .5) {
tmp.cur_x[i] += double_to_int::convert(m_drng() * bw_cur * lu_diff[i]);
} else {
tmp.cur_x[i] -= double_to_int::convert(m_drng() * bw_cur * lu_diff[i]);
}
// Wrap over in case we went past the bounds.
if (tmp.cur_x[i] > ub[i]) {
tmp.cur_x[i] = lb[i] + double_to_int::convert(tmp.cur_x[i] - ub[i]) % static_cast<int>(lu_diff[i]);
} else if (tmp.cur_x[i] < lb[i]) {
tmp.cur_x[i] = ub[i] - double_to_int::convert(lb[i] - tmp.cur_x[i]) % static_cast<int>(lu_diff[i]);
}
}
} else {
// Pick randomly within the bounds.
tmp.cur_x[i] = boost::uniform_int<int>(lb[i],ub[i])(m_urng);
}
}
// And we push him back
pop.push_back(tmp.cur_x);
// We locate the worst individual.
const population::size_type worst_idx = pop.get_worst_idx();
// And we get rid of him :)
pop.erase(worst_idx);
}
}
/**
* Run the CORE algorithm
*
* @param[in,out] pop input/output pagmo::population to be evolved.
*/
void cstrs_core::evolve(population &pop) const
{
// store useful variables
const problem::base &prob = pop.problem();
const population::size_type pop_size = pop.size();
const problem::base::size_type prob_dimension = prob.get_dimension();
// get the constraints dimension
problem::base::c_size_type prob_c_dimension = prob.get_c_dimension();
//We perform some checks to determine wether the problem/population are suitable for CORE
if(prob_c_dimension < 1) {
pagmo_throw(value_error,"The problem is not constrained and CORE is not suitable to solve it");
}
if(prob.get_f_dimension() != 1) {
pagmo_throw(value_error,"The problem is multiobjective and CORE is not suitable to solve it");
}
// Get out if there is nothing to do.
if(pop_size == 0) {
return;
}
// generates the unconstrained problem
problem::con2uncon prob_unconstrained(prob);
// associates the population to this problem
population pop_uncon(prob_unconstrained);
// fill this unconstrained population
pop_uncon.clear();
for(population::size_type i=0; i<pop_size; i++) {
pop_uncon.push_back(pop.get_individual(i).cur_x);
}
// vector containing the infeasibles positions
std::vector<population::size_type> pop_infeasibles;
// Main CORE loop
for(int k=0; k<m_gen; k++) {
if(k%m_repair_frequency == 0) {
pop_infeasibles.clear();
// get the infeasible individuals
for(population::size_type i=0; i<pop_size; i++) {
if(!prob.feasibility_c(pop.get_individual(i).cur_c)) {
pop_infeasibles.push_back(i);
}
}
// random shuffle of infeasibles?
population::size_type number_of_repair = (population::size_type)(m_repair_ratio * pop_infeasibles.size());
// repair the infeasible individuals
for(population::size_type i=0; i<number_of_repair; i++) {
const population::size_type ¤t_individual_idx = pop_infeasibles.at(i);
pop.repair(current_individual_idx, m_repair_algo);
}
// the population is repaired, it can be now used in the new unconstrained population
// only the repaired individuals are put back in the population
for(population::size_type i=0; i<number_of_repair; i++) {
population::size_type current_individual_idx = pop_infeasibles.at(i);
pop_uncon.set_x(current_individual_idx, pop.get_individual(current_individual_idx).cur_x);
}
}
m_original_algo->evolve(pop_uncon);
// push back the population in the main problem
pop.clear();
for(population::size_type i=0; i<pop_size; i++) {
pop.push_back(pop_uncon.get_individual(i).cur_x);
}
// Check the exit conditions (every 40 generations, just as DE)
if(k % 40 == 0) {
decision_vector tmp(prob_dimension);
double dx = 0;
for(decision_vector::size_type i=0; i<prob_dimension; i++) {
tmp[i] = pop.get_individual(pop.get_worst_idx()).best_x[i] - pop.get_individual(pop.get_best_idx()).best_x[i];
dx += std::fabs(tmp[i]);
}
if(dx < m_xtol ) {
if (m_screen_output) {
std::cout << "Exit condition -- xtol < " << m_xtol << std::endl;
}
break;
}
double mah = std::fabs(pop.get_individual(pop.get_worst_idx()).best_f[0] - pop.get_individual(pop.get_best_idx()).best_f[0]);
if(mah < m_ftol) {
if(m_screen_output) {
std::cout << "Exit condition -- ftol < " << m_ftol << std::endl;
}
break;
}
// outputs current values
if(m_screen_output) {
std::cout << "Generation " << k << " ***" << std::endl;
std::cout << " Best global fitness: " << pop.champion().f << std::endl;
std::cout << " xtol: " << dx << ", ftol: " << mah << std::endl;
std::cout << " xtol: " << dx << ", ftol: " << mah << std::endl;
}
}
}
}