vrprouting::initialsol::tabu::Initial_solution Class Reference

#include "tabu.h"

Inheritance diagram for vrprouting::initialsol::tabu::Initial_solution:

Collaboration diagram for vrprouting::initialsol::tabu::Initial_solution:

Public Member Functions
	Initial_solution ()=delete
	Initial solution without information is not valid. More...
	Initial_solution (TTimestamp, bool, problem::PickDeliver *)
	Creating a complete initial solution. More...
std::tuple< int, int, size_t, TInterval, TInterval, TInterval >	cost () const
	Get all statistics in one cycle. More...
std::string	cost_str () const
int	cvTot () const
	Total number of capacity constraint violations of the solution. More...
TInterval	duration () const
	Total duration of the solution. More...
const std::deque< Vehicle_pickDeliver > &	fleet () const
	Get the current fleet solution. More...
std::vector< Solution_rt >	get_postgres_result () const
	get solution like postgres needs it More...
std::vector< Short_vehicle >	get_stops () const
	get solution like postgres needs it More...
bool	is_feasible () const
	is the solution feasible? More...
Pgr_messages &	msg ()
double	objective () const
	Get the value of the objective function. More...
bool	operator< (const Solution &) const
const Orders &	orders () const
std::string	tau (const std::string &title="Tau") const
	writing the solution in compact form into a string More...
TInterval	total_service_time () const
	Total service time of the solution. More...
TInterval	total_travel_time () const
	Total travel time of the solution. More...
int	twvTot () const
	Total number of time windows constraint violations of the solution. More...
Fleet &	vehicles ()
TInterval	wait_time () const
	Total waiting time of the solution. More...

Protected Attributes
std::deque< Vehicle_pickDeliver >	m_fleet
	The current solution. More...
Pgr_messages	m_msg
Orders	m_orders
	the problem info More...
Fleet	m_trucks

Private Member Functions
void	invariant () const
	class invariant about the orders that have been assigned More...
void	process_given_solution_from_user (TTimestamp, bool)
	processes the initial solution given by the user More...
void	process_unassigned ()
	Adds unassigned orders to phony vehicles. More...

Private Attributes
Identifiers< size_t >	m_all_orders
	set of all orders More...
Identifiers< size_t >	m_assigned
	set of assigned orders More...
Identifiers< size_t >	m_unassigned
	set of unassigned orders More...

Detailed Description

Definition at line 45 of file initialsol/tabu.h.

Constructor & Destructor Documentation

Initial_solution() [1/2]

vrprouting::initialsol::tabu::Initial_solution::Initial_solution ( )

delete

Initial solution without information is not valid.

Initial_solution() [2/2]

vrprouting::initialsol::tabu::Initial_solution::Initial_solution	(	TTimestamp	execution_date,
		bool	optimize,
		problem::PickDeliver *	problem_ptr
	)

Creating a complete initial solution.

Parameters

[in]	execution_date	used for setting unmovable orders from the past
[in]	optimize	prepare orders for optimization
[in]	problem_ptr	the problem pointer

Get all the orders

• when an order is feasible on at least one vehicles is part of the orders set
• unfeasible orders are ignored

From the of used vehicles When there are unassigned orders

• mark as unmovable all orders on vehicles where the unassigned orders are not feasible

Get the remaining empty unused vehicles

add the unassigned orders to phony vehicles

Definition at line 60 of file initialsol/tabu.cpp.

                                         :
    Solution(problem_ptr),
    m_all_orders(),
    m_unassigned(),
    m_assigned() {
        invariant();
 
        m_all_orders = vehicles().feasible_orders();
        m_unassigned = m_all_orders;
 
        process_given_solution_from_user(execution_date, optimize);
        pgassert(is_feasible());
 
        if (!m_unassigned.empty()) {
            for (auto &v : m_fleet) {
                bool is_usable(false);
                for (const auto &o : m_unassigned) {
                    if (v.feasible_orders().has(o)) {
                        /*
                         * found an order to be inserted that fits on the vehicle
                         */
                        is_usable = true;
                        break;
                    }
                }
                /*
                 * No order to be inserted fits on the vehicle
                 */
                if (!is_usable) v.set_unmovable(std::numeric_limits<TTimestamp>::max());
            }
        }
 
        auto unused = vehicles().get_unused_trucks();
        m_fleet.insert(m_fleet.end(), unused.begin(), unused.end());
        pgassert(is_feasible());
 
        process_unassigned();
        pgassert(is_feasible());
 
        invariant();
    }

References Identifiers< T >::empty(), vrprouting::problem::Fleet::feasible_orders(), vrprouting::problem::Fleet::get_unused_trucks(), invariant(), vrprouting::problem::Solution::is_feasible(), m_all_orders, vrprouting::problem::Solution::m_fleet, m_unassigned, pgassert, process_given_solution_from_user(), process_unassigned(), and vrprouting::problem::Solution::vehicles().

Member Function Documentation

cost()

std::tuple< int, int, size_t, TInterval, TInterval, TInterval > Solution::cost ( ) const

inherited

Get all statistics in one cycle.

Returns

totals of

idx	variable
0	twv
1	cv
2	fleet size
3	waiting time
4	duration
5	travel time

std::get<idx>

Definition at line 218 of file solution.cpp.

                     {
  TInterval total_duration(0);
  TInterval total_wait_time(0);
  TInterval total_tt(0);
  int total_twv(0);
  int total_cv(0);
  /*
   * Cycle the fleet
   */
  for (const auto& v : m_fleet) {
    total_duration += v.duration();
    total_wait_time += v.total_wait_time();
    total_twv += v.twvTot();
    total_cv += v.cvTot();
    total_tt += v.total_travel_time();
  }
  /*
   * build the tuple
   */
  return std::make_tuple(
      total_twv, total_cv, m_fleet.size(),
      total_wait_time, total_duration,
      total_tt);
}

References vrprouting::problem::Solution::m_fleet.

Referenced by vrprouting::problem::Solution::cost_str(), and vrprouting::problem::Solution::operator<().

cost_str()

std::string Solution::cost_str ( ) const

inherited

Returns

The costs in one string

Definition at line 246 of file solution.cpp.

                         {
  /*
   * get the cost
   */
  auto s_cost(cost());
  std::ostringstream log;
 
  /*
   * Build the string
   */
  log << std::fixed << std::setprecision(4)
    << "twv=" << std::get<0>(s_cost)
    << " cv=" << std::get<1>(s_cost)
    << " wait=" << std::get<3>(s_cost)
    << " duration=" << std::get<4>(s_cost)
    << " tt=" << std::get<5>(s_cost);
 
  return log.str();
}

References vrprouting::problem::Solution::cost().

Referenced by vrprouting::problem::Solution::tau().

cvTot()

int Solution::cvTot ( ) const

inherited

Total number of capacity constraint violations of the solution.

Returns

Total number of capacity violations The total capacity violations of the solution is the sum of the capacity violations of all vehicles

Definition at line 196 of file solution.cpp.

                      {
  return std::accumulate(begin(m_fleet), end(m_fleet), 0,
      [](int i, const Vehicle_pickDeliver& v) {return v.cvTot() + i;});
}

References vrprouting::problem::Vehicle::cvTot(), and vrprouting::problem::Solution::m_fleet.

Referenced by vrprouting::problem::Solution::get_postgres_result().

duration()

TInterval Solution::duration ( ) const

inherited

Total duration of the solution.

Returns

the solution's duration

The solution duration is the sum of the durations of all vehicles

Definition at line 140 of file solution.cpp.

                         {
  return std::accumulate(begin(m_fleet), end(m_fleet), static_cast<TInterval>(0),
      [](TInterval i, const Vehicle_pickDeliver& v) {return v.duration() + i;});
}

References vrprouting::problem::Vehicle::duration(), and vrprouting::problem::Solution::m_fleet.

Referenced by vrprouting::problem::Solution::get_postgres_result(), vrprouting::optimizers::simple::Optimize::save_if_best(), and vrprouting::optimizers::simple::Optimize::swap_worse().

fleet()

const std::deque<Vehicle_pickDeliver>& vrprouting::problem::Solution::fleet ( ) const

inlineinherited

Get the current fleet solution.

Definition at line 107 of file solution.h.

{return m_fleet;}

References vrprouting::problem::Solution::m_fleet.

Referenced by vrprouting::optimizers::tabu::Optimize::intensify(), and vrprouting::optimizers::tabu::Optimize::Optimize().

get_postgres_result()

std::vector< Solution_rt > Solution::get_postgres_result ( ) const

inherited

get solution like postgres needs it

Returns

container for postgres

Definition at line 61 of file solution.cpp.

                                    {
  std::vector<Solution_rt> result;
 
  /* postgres numbering starts with 1 */
  int i(1);
 
  for (auto v : m_fleet) {
    v.evaluate(0);
    auto data = v.get_postgres_result(i);
    /*
     * Results adjusted for the depot and the first stop
     * So the vehicle waits on the depot not on the first stop
     */
    data[1].arrivalTime = data[1].operationTime;
    data[0].waitDuration = data[1].waitDuration;
    data[1].waitDuration = 0;
    data[0].departureTime = data[0].arrivalTime + data[0].waitDuration;
 
 
    result.insert(result.end(), data.begin(), data.end());
    ++i;
  }
 
  Solution_rt aggregates = {
    /*
     * Vehicle id = -2 indicates its an aggregate row
     *
     * (twv, cv, fleet, wait, duration)
     */
    -2,  // summary row on vehicle_number
    twvTot(),  // on vehicle_id
    cvTot(),   // on vehicle_seq
    -1,  // on order_id
    -1,  // on stop_id
    -2,  // on stop_type (gets increased later by one so it gets -1)
    -1,  // not accounting total loads
    static_cast<int64_t>(total_travel_time()),
    -1,  // not accounting arrival_travel_time
    static_cast<int64_t>(wait_time()),
    -1,  // not accounting operation time
    static_cast<int64_t>(total_service_time()),
    static_cast<int64_t>(duration()),
    cvTot(),
    twvTot()
  };
  result.push_back(aggregates);
 
  return result;
}

References vrprouting::problem::Solution::cvTot(), vrprouting::problem::Solution::duration(), vrprouting::problem::Solution::m_fleet, vrprouting::problem::Solution::total_service_time(), vrprouting::problem::Solution::total_travel_time(), vrprouting::problem::Solution::twvTot(), and vrprouting::problem::Solution::wait_time().

get_stops()

std::vector< Short_vehicle > Solution::get_stops ( ) const

inherited

get solution like postgres needs it

Returns

container for postgres

Definition at line 49 of file solution.cpp.

                          {
  std::vector<Short_vehicle> result;
  for (auto v : m_fleet) {
    result.push_back(Short_vehicle{v.id(), v.get_stops()});
  }
  return result;
}

References Short_vehicle::id, and vrprouting::problem::Solution::m_fleet.

invariant()

void vrprouting::initialsol::tabu::Initial_solution::invariant ( ) const

private

class invariant about the orders that have been assigned

Invariant

assigned UNION unassigned = all_orders

assigned INTERSECTION unassigned = empty

Definition at line 50 of file initialsol/tabu.cpp.

                                  {
    pgassert(m_all_orders == (m_assigned + m_unassigned));
    pgassert((m_assigned * m_unassigned).empty());
}

References m_all_orders, m_assigned, m_unassigned, and pgassert.

Referenced by Initial_solution(), process_given_solution_from_user(), and process_unassigned().

is_feasible()

bool Solution::is_feasible ( ) const

inherited

is the solution feasible?

The solution is feasible when all vehicles are feasible.

Returns

true when all vehicles in solution are feasible

Definition at line 129 of file solution.cpp.

                            {
  return std::find_if(m_fleet.begin(), m_fleet.end(),
      [] (const Vehicle_pickDeliver& v) -> bool {return !v.is_feasible();}) == m_fleet.end();
}

References vrprouting::problem::Solution::m_fleet.

Referenced by vrprouting::optimizers::simple::Optimize::decrease_truck(), vrprouting::initialsol::simple::Initial_solution::do_while_feasible(), vrprouting::initialsol::simple::Initial_solution::do_while_foo(), Initial_solution(), process_given_solution_from_user(), and process_unassigned().

msg()

Pgr_messages& vrprouting::problem::Solution::msg ( )

inlineinherited

Definition at line 119 of file solution.h.

{return m_msg;}

References vrprouting::problem::Solution::m_msg.

Referenced by vrprouting::initialsol::simple::Initial_solution::do_while_foo(), vrprouting::optimizers::simple::Optimize::inter_swap(), vrprouting::optimizers::tabu::Optimize::move_2_real(), vrprouting::initialsol::simple::Initial_solution::one_truck_all_orders(), vrprouting::optimizers::simple::Optimize::Optimize(), vrprouting::optimizers::tabu::Optimize::Optimize(), process_unassigned(), vrprouting::optimizers::simple::Optimize::save_if_best(), and vrprouting::optimizers::tabu::Optimize::tabu_search().

objective()

double vrprouting::problem::Solution::objective ( ) const

inlineinherited

Get the value of the objective function.

Definition at line 110 of file solution.h.

{return static_cast<double>(total_travel_time());}

References vrprouting::problem::Solution::total_travel_time().

Referenced by vrprouting::optimizers::tabu::Optimize::move_2_real(), vrprouting::optimizers::tabu::Optimize::single_pair_insertion(), vrprouting::optimizers::tabu::Optimize::swap_between_routes(), and vrprouting::optimizers::tabu::Optimize::tabu_search().

operator<()

bool Solution::operator< ( const Solution &  s_rhs ) const

inherited

Definition at line 267 of file solution.cpp.

                                               {
  auto lhs(cost());
  auto rhs(s_rhs.cost());
 
  /*
   * time window violations
   */
  if (std::get<0>(lhs) < std::get<0>(rhs))
    return true;
  if (std::get<0>(lhs) > std::get<0>(rhs))
    return false;
 
  /*
   * capacity violations
   */
  if (std::get<1>(lhs) < std::get<1>(rhs))
    return true;
  if (std::get<1>(lhs) > std::get<1>(rhs))
    return false;
 
  /*
   * fleet size
   */
  if (std::get<2>(lhs) < std::get<2>(rhs))
    return true;
  if (std::get<2>(lhs) > std::get<2>(rhs))
    return false;
 
  /*
   * waiting time
   */
  if (std::get<3>(lhs) < std::get<3>(rhs))
    return true;
  if (std::get<3>(lhs) > std::get<3>(rhs))
    return false;
 
  /*
   * duration
   */
  if (std::get<4>(lhs) < std::get<4>(rhs))
    return true;
  if (std::get<4>(lhs) > std::get<4>(rhs))
    return false;
 
  return false;
}

References vrprouting::problem::Solution::cost().

orders()

const Orders& vrprouting::problem::Solution::orders ( ) const

inlineinherited

Definition at line 120 of file solution.h.

{return m_orders;}

References vrprouting::problem::Solution::m_orders.

Referenced by vrprouting::optimizers::simple::Optimize::decrease_truck(), vrprouting::optimizers::tabu::Optimize::diversify(), vrprouting::optimizers::tabu::Optimize::move_2_real(), process_given_solution_from_user(), process_unassigned(), vrprouting::optimizers::tabu::Optimize::set_tabu_list_length(), vrprouting::optimizers::tabu::Optimize::single_pair_insertion(), and vrprouting::optimizers::tabu::Optimize::swap_between_routes().

process_given_solution_from_user()

void vrprouting::initialsol::tabu::Initial_solution::process_given_solution_from_user ( TTimestamp  execution_date, bool  optimize  )

private

processes the initial solution given by the user

User's initial solution is considered.

Precondition

m_fleet is empty

invariant()

m_fleet has vehicles that have orders

Postcondition

invariant()

is feasible

Set the initial solution given by the user

Used vehicles: are the ones that have a solution from the user

The solution fleet are the used vehicles

Definition at line 131 of file initialsol/tabu.cpp.

                                                                                           {
    pgassert(m_fleet.empty());
    invariant();
 
    vehicles().set_initial_solution(orders(), m_assigned, m_unassigned, execution_date, optimize);
 
    auto used_v = vehicles().get_used_trucks();
 
    m_fleet.insert(m_fleet.end(), used_v.begin(), used_v.end());
 
    pgassert(is_feasible());
    invariant();
}

References vrprouting::problem::Fleet::get_used_trucks(), invariant(), vrprouting::problem::Solution::is_feasible(), m_assigned, vrprouting::problem::Solution::m_fleet, m_unassigned, vrprouting::problem::Solution::orders(), pgassert, vrprouting::problem::Fleet::set_initial_solution(), and vrprouting::problem::Solution::vehicles().

Referenced by Initial_solution().

process_unassigned()

void vrprouting::initialsol::tabu::Initial_solution::process_unassigned ( )

private

Adds unassigned orders to phony vehicles.

Precondition

invariant()

is_feasible()

Postcondition

invariant()

is_feasible()

unassigned is empty

test pre conditions

cycle the unassigned orders

• get a new phony vehicle
• Add the order to the phony vehicle
• update for invariant
• Add the vehicle to the fleet

test post conditions

Definition at line 162 of file initialsol/tabu.cpp.

                                     {
    invariant();
    pgassert(is_feasible());
 
    Identifiers<size_t> notused;
 
    auto not_assigned = m_unassigned;
 
    for (const auto o : not_assigned) {
        auto phony_v = vehicles().get_phony();
        if (!phony_v.is_order_feasible(orders()[o])) {
            phony_v.push_back(orders()[o]);
            m_unassigned -= o;
            m_all_orders -= o;
            msg().error << "\n**Illegal Order** pick.opens() + tt > drop.closes() can not be inserted on any vehicle";
            continue;
        }
 
        phony_v.push_back(orders()[o]);
        pgassert(phony_v.is_feasible());
 
        m_assigned += o;
        m_unassigned -= o;
 
        m_fleet.push_back(phony_v);
        invariant();
    }
 
    pgassert(m_unassigned.empty());
    pgassert(is_feasible());
    invariant();
}

References Identifiers< T >::empty(), vrprouting::Pgr_messages::error, vrprouting::problem::Fleet::get_phony(), invariant(), vrprouting::problem::Solution::is_feasible(), m_all_orders, m_assigned, vrprouting::problem::Solution::m_fleet, m_unassigned, vrprouting::problem::Solution::msg(), vrprouting::problem::Solution::orders(), pgassert, vrprouting::problem::Vehicle_pickDeliver::push_back(), and vrprouting::problem::Solution::vehicles().

Referenced by Initial_solution().

tau()

std::string Solution::tau ( const std::string &  title = "Tau" ) const

inherited

writing the solution in compact form into a string

Parameters

[in]

title

Title to Use for the tau

Returns

The solution in one compacted string

Definition at line 116 of file solution.cpp.

                                          {
  std::string str {"\n" + title + ": " + '\n'};
  for (const auto& v : m_fleet) str += ("\n" + v.tau());
  str += "\n" + cost_str() + "\n";
  return str;
}

References vrprouting::problem::Solution::cost_str(), and vrprouting::problem::Solution::m_fleet.

Referenced by vrprouting::optimizers::simple::Optimize::inter_swap(), vrprouting::optimizers::simple::Optimize::Optimize(), and vrprouting::optimizers::tabu::Optimize::Optimize().

total_service_time()

TInterval Solution::total_service_time ( ) const

inherited

Total service time of the solution.

Returns

the total service time of the solution

The total service time of the solution is the sum of the service times of all vehicles

Definition at line 174 of file solution.cpp.

                                   {
  return std::accumulate(begin(m_fleet), end(m_fleet), static_cast<TInterval>(0),
      [](TInterval i, const Vehicle_pickDeliver& v) {return v.total_service_time() + i;});
}

References vrprouting::problem::Solution::m_fleet, and vrprouting::problem::Vehicle::total_service_time().

Referenced by vrprouting::problem::Solution::get_postgres_result().

total_travel_time()

TInterval Solution::total_travel_time ( ) const

inherited

Total travel time of the solution.

Returns

the total waiting time

The total travel time of the solution is the sum of the travel times of all vehicles

Definition at line 162 of file solution.cpp.

                                  {
  return std::accumulate(begin(m_fleet), end(m_fleet), static_cast<TInterval>(0),
      [](TInterval i, const Vehicle_pickDeliver& v) {return v.total_travel_time() + i;});
}

References vrprouting::problem::Solution::m_fleet, and vrprouting::problem::Vehicle::total_travel_time().

Referenced by vrprouting::problem::Solution::get_postgres_result(), and vrprouting::problem::Solution::objective().

twvTot()

int Solution::twvTot ( ) const

inherited

Total number of time windows constraint violations of the solution.

Returns

the total number of time window violations

The total time window violations of the solution is the sum of the time window violations of all vehicles

Definition at line 185 of file solution.cpp.

                       {
  return std::accumulate(begin(m_fleet), end(m_fleet), 0,
      [](int i, const Vehicle_pickDeliver& v) {return v.twvTot() + i;});
}

References vrprouting::problem::Solution::m_fleet, and vrprouting::problem::Vehicle::twvTot().

Referenced by vrprouting::problem::Solution::get_postgres_result().

vehicles()

Fleet& vrprouting::problem::Solution::vehicles ( )

inlineinherited

Definition at line 121 of file solution.h.

{return m_trucks;}

References vrprouting::problem::Solution::m_trucks.

Referenced by vrprouting::initialsol::simple::Initial_solution::do_while_foo(), Initial_solution(), vrprouting::initialsol::simple::Initial_solution::one_truck_all_orders(), process_given_solution_from_user(), and process_unassigned().

wait_time()

TInterval Solution::wait_time ( ) const

inherited

Total waiting time of the solution.

Returns

the total waiting time

The total waiting time of the solution is the sum of the waiting time of all vehicles

Definition at line 151 of file solution.cpp.

                          {
  return std::accumulate(begin(m_fleet), end(m_fleet), static_cast<TInterval>(0),
      [](TInterval i, const Vehicle_pickDeliver& v) {return v.total_wait_time() + i;});
}

References vrprouting::problem::Solution::m_fleet, and vrprouting::problem::Vehicle::total_wait_time().

Referenced by vrprouting::problem::Solution::get_postgres_result().

Member Data Documentation

m_all_orders

Identifiers<size_t> vrprouting::initialsol::tabu::Initial_solution::m_all_orders

private

set of all orders

Definition at line 66 of file initialsol/tabu.h.

Referenced by Initial_solution(), invariant(), and process_unassigned().

m_assigned

Identifiers<size_t> vrprouting::initialsol::tabu::Initial_solution::m_assigned

private

set of assigned orders

Definition at line 72 of file initialsol/tabu.h.

Referenced by invariant(), process_given_solution_from_user(), and process_unassigned().

m_fleet

std::deque<Vehicle_pickDeliver> vrprouting::problem::Solution::m_fleet

protectedinherited

The current solution.

Definition at line 125 of file solution.h.

Referenced by vrprouting::problem::Solution::cost(), vrprouting::problem::Solution::cvTot(), vrprouting::optimizers::simple::Optimize::decrease_truck(), vrprouting::optimizers::simple::Optimize::delete_empty_truck(), vrprouting::optimizers::tabu::Optimize::diversify(), vrprouting::initialsol::simple::Initial_solution::do_while_foo(), vrprouting::problem::Solution::duration(), vrprouting::problem::Solution::fleet(), vrprouting::problem::Solution::get_postgres_result(), vrprouting::problem::Solution::get_stops(), Initial_solution(), vrprouting::optimizers::tabu::Optimize::intensify(), vrprouting::optimizers::simple::Optimize::inter_swap(), vrprouting::problem::Solution::is_feasible(), vrprouting::optimizers::tabu::Optimize::move_2_real(), vrprouting::initialsol::simple::Initial_solution::one_truck_all_orders(), vrprouting::optimizers::simple::Optimize::Optimize(), vrprouting::optimizers::tabu::Optimize::Optimize(), process_given_solution_from_user(), process_unassigned(), vrprouting::optimizers::simple::Optimize::save_if_best(), vrprouting::optimizers::tabu::Optimize::single_pair_insertion(), vrprouting::optimizers::simple::Optimize::sort_by_duration(), vrprouting::optimizers::simple::Optimize::sort_by_id(), vrprouting::optimizers::simple::Optimize::sort_by_size(), vrprouting::optimizers::tabu::Optimize::sort_by_size(), vrprouting::optimizers::simple::Optimize::sort_for_move(), vrprouting::optimizers::tabu::Optimize::swap_between_routes(), vrprouting::optimizers::tabu::Optimize::tabu_search(), vrprouting::problem::Solution::tau(), vrprouting::problem::Solution::total_service_time(), vrprouting::problem::Solution::total_travel_time(), vrprouting::problem::Solution::twvTot(), and vrprouting::problem::Solution::wait_time().

m_msg

Pgr_messages vrprouting::problem::Solution::m_msg

protectedinherited

Definition at line 130 of file solution.h.

Referenced by vrprouting::problem::Solution::msg().

m_orders

Orders vrprouting::problem::Solution::m_orders

protectedinherited

the problem info

Definition at line 128 of file solution.h.

Referenced by vrprouting::initialsol::simple::Initial_solution::do_while_feasible(), and vrprouting::problem::Solution::orders().

m_trucks

Fleet vrprouting::problem::Solution::m_trucks

protectedinherited

Definition at line 129 of file solution.h.

Referenced by vrprouting::problem::Solution::vehicles().

m_unassigned

Identifiers<size_t> vrprouting::initialsol::tabu::Initial_solution::m_unassigned

private

set of unassigned orders

Definition at line 69 of file initialsol/tabu.h.

Referenced by Initial_solution(), invariant(), process_given_solution_from_user(), and process_unassigned().

---

The documentation for this class was generated from the following files:

• initialsol/tabu.h
• initialsol/tabu.cpp