/// Implementation of the constraint function.
void earth_planet::compute_constraints_impl(constraint_vector &c, const decision_vector &x) const
{
// We decode the decision vector into a multiple fly-by trajectory
trajectory.init_from_full_vector(x.begin(),x.end(),encoding);
// We evaluate the state mismatch at the mid-point. And we use astronomical units to scale them
trajectory.evaluate_all_mismatch_con(c.begin(), c.begin() + 7);
for (int i=0; i<3; ++i) c[i]/=ASTRO_AU;
for (int i=3; i<6; ++i) c[i]/=ASTRO_EARTH_VELOCITY;
// We evaluate the constraints on the throttles writing on the 7th mismatch constrant (mass is off)
trajectory.get_leg(0).get_throttles_con(c.begin() + 6, c.begin() + 6 + n_segments);
// We evaluate the constraint on the initial launch velocity
c[6 + n_segments] = (trajectory.evaluate_leg_vinf2_i(0) - vmax*vmax) / ASTRO_EARTH_VELOCITY / ASTRO_EARTH_VELOCITY;
// We evaluate the linear constraint on the epochs (tf > ti)
c[7 + n_segments] = trajectory.get_leg(0).get_t_i().mjd2000() - trajectory.get_leg(0).get_t_f().mjd2000();
}
/// Implementation of the constraint function.
void gtoc5_rendezvous::compute_constraints_impl(constraint_vector &c, const decision_vector &x) const
{
using namespace kep_toolbox;
// We set the leg.
const epoch epoch_i(x[0],epoch::MJD), epoch_f(x[1] + x[0],epoch::MJD);
array3D v0, r0, vf, rf;
m_source.eph(epoch_i,r0,v0);
m_target.eph(epoch_f,rf,vf);
m_leg.set_leg(epoch_i,sc_state(r0,v0,m_leg.get_spacecraft().get_mass()),x.begin() + 3, x.end(),epoch_f,sc_state(rf,vf,x[2]),ASTRO_MU_SUN);
// We evaluate the state mismatch at the mid-point. And we use astronomical units to scale them
m_leg.get_mismatch_con(c.begin(), c.begin() + 7);
for (int i=0; i<3; ++i) c[i]/=ASTRO_AU;
for (int i=3; i<6; ++i) c[i]/=ASTRO_EARTH_VELOCITY;
c[6] /= m_leg.get_spacecraft().get_mass();
// We evaluate the constraints on the throttles writing on the 7th mismatch constrant (mass is off)
m_leg.get_throttles_con(c.begin() + 7, c.begin() + 7 + m_n_segments);
}
std::string gtoc5_rendezvous::pretty(const decision_vector &x) const
{
using namespace kep_toolbox;
// We set the leg.
const epoch epoch_i(x[0],epoch::MJD), epoch_f(x[1] + x[0],epoch::MJD);
array3D v0, r0, vf, rf;
m_source.eph(epoch_i,r0,v0);
m_target.eph(epoch_f,rf,vf);
m_leg.set_leg(epoch_i,sc_state(r0,v0,m_leg.get_spacecraft().get_mass()),x.begin() + 3, x.end(),epoch_f,sc_state(rf,vf,x[2]),ASTRO_MU_SUN);
std::ostringstream oss;
oss << m_leg << '\n' << m_source << '\n' << m_target << '\n';
return oss.str();
}
std::string gtoc5_launch::pretty(const decision_vector &x) const
{
using namespace kep_toolbox;
// 1 - We set the leg.
const epoch epoch_i(x[0],epoch::MJD), epoch_f(x[1] + x[0],epoch::MJD);
array3D v0, r0, vf, rf;
m_earth.get_eph(epoch_i,r0,v0);
m_target.get_eph(epoch_f,rf,vf);
v0[0] += x[2];
v0[1] += x[3];
v0[2] += x[4];
m_leg.set_leg(epoch_i,sc_state(r0,v0,m_leg.get_spacecraft().get_mass()),x.begin() + 6, x.end(),epoch_f,sc_state(rf,vf,x[5]),ASTRO_MU_SUN);
std::ostringstream oss;
oss << m_leg << '\n' << m_earth << '\n' << m_target << '\n';
return oss.str();
}
void tsp_vrplc::compute_constraints_impl(constraint_vector &c, const decision_vector& x) const
{
decision_vector::size_type n_cities = get_n_cities();
switch( get_encoding() )
{
case FULL:
{
// 1 - We set the equality constraints
for (size_t i = 0; i < n_cities; i++) {
c[i] = 0;
c[i+n_cities] = 0;
for (size_t j = 0; j < n_cities; j++)
{
if(i==j) continue; // ignoring main diagonal
decision_vector::size_type rows = compute_idx(i, j, n_cities);
decision_vector::size_type cols = compute_idx(j, i, n_cities);
c[i] += x[rows];
c[i+n_cities] += x[cols];
}
c[i] = c[i]-1;
c[i+n_cities] = c[i+n_cities]-1;
}
//2 - We set the inequality constraints
//2.1 - First we compute the uj (see http://en.wikipedia.org/wiki/Travelling_salesman_problem#Integer_linear_programming_formulation)
// we start always out tour from the first city, without loosing generality
size_t next_city = 0,current_city = 0;
std::vector<int> u(n_cities);
for (size_t i = 0; i < n_cities; i++)
{
u[current_city] = i+1;
for (size_t j = 0; j < n_cities; j++)
{
if (current_city==j) continue;
if (x[compute_idx(current_city, j, n_cities)] == 1)
{
next_city = j;
break;
}
}
current_city = next_city;
}
int count=0;
for (size_t i = 1; i < n_cities; i++) {
for (size_t j = 1; j < n_cities; j++)
{
if (i==j) continue;
c[2*n_cities+count] = u[i]-u[j] + (n_cities+1) * x[compute_idx(i, j, n_cities)] - n_cities;
count++;
}
}
break;
}
case RANDOMKEYS:
break;
case CITIES:
{
std::vector<population::size_type> range(n_cities);
for (std::vector<population::size_type>::size_type i=0; i<range.size(); ++i)
{
range[i]=i;
}
c[0] = !std::is_permutation(x.begin(),x.end(),range.begin());
break;
}
}
return;
}
/// Implementation of the objective function.
void earth_planet::objfun_impl(fitness_vector &f, const decision_vector &x) const
{
trajectory.init_from_full_vector(x.begin(),x.end(),encoding);
f[0] = trajectory.get_leg(0).evaluate_dv() / 1000;
}