pgrouting::vrp::Optimize Class Reference

#include "optimize.h"

Inheritance diagram for pgrouting::vrp::Optimize:

Collaboration diagram for pgrouting::vrp::Optimize:

Public Member Functions
	Optimize (const Solution &solution)
	Optimize (const Solution &solution, size_t times)
Vehicle::Cost	cost () const
std::string	cost_str () const
int	cvTot () const
void	decrease_truck ()
double	duration () const
Initials_code	get_kind () const
std::vector< General_vehicle_orders_t >	get_postgres_result () const
void	inter_swap (size_t times)
bool	is_feasable () const
bool	operator< (const Solution &s_rhs) const
std::string	tau (const std::string &title="Tau") const
double	total_service_time () const
double	total_travel_time () const
int	twvTot () const
double	wait_time () const

Static Public Member Functions
static Pgr_messages &	msg ()
	The problem's message. More...

Public Attributes
Solution	best_solution

Protected Attributes
double	EPSILON
std::deque< Vehicle_pickDeliver >	fleet
Fleet	trucks

Private Member Functions
bool	decrease_truck (size_t)
void	delete_empty_truck ()
bool	inter_swap ()
bool	move_order (Order order, Vehicle_pickDeliver &from_truck, Vehicle_pickDeliver &to_truck)
	moves an order to an non empty vehicle More...
bool	move_reduce_cost (Vehicle_pickDeliver &from, Vehicle_pickDeliver &to)
void	save_if_best ()
void	sort_by_duration ()
void	sort_by_size ()
bool	swap_worse (Vehicle_pickDeliver &from, Vehicle_pickDeliver &to)

Static Private Attributes
static Pgr_pickDeliver *	problem
	this solution belongs to this problem More...

Detailed Description

Definition at line 41 of file optimize.h.

Constructor & Destructor Documentation

Optimize() [1/2]

pgrouting::vrp::Optimize::Optimize ( const Solution &  solution )

explicit

Definition at line 41 of file optimize.cpp.

                                      :
    Solution(old_solution),
    best_solution(old_solution)  {
        pgassert(false);
        decrease_truck();
        inter_swap(fleet.size());
    }

References decrease_truck(), pgrouting::vrp::Solution::fleet, inter_swap(), and pgassert.

Optimize() [2/2]

pgrouting::vrp::Optimize::Optimize	(	const Solution &	solution,
		size_t	times
	)

Definition at line 50 of file optimize.cpp.

                      :
    Solution(old_solution),
    best_solution(old_solution)  {
        inter_swap(times);
 
        this->fleet = best_solution.fleet;
        msg().log << tau("bestSol before sort by size");
        sort_by_size();
        msg().log << tau("bestSol after sort by size");
        msg().log <<  tau();
    }

References best_solution, pgrouting::vrp::Solution::fleet, inter_swap(), pgrouting::Pgr_messages::log, pgrouting::vrp::Solution::msg(), sort_by_size(), and pgrouting::vrp::Solution::tau().

Member Function Documentation

cost()

Vehicle::Cost pgrouting::vrp::Solution::cost ( ) const

inherited

Definition at line 130 of file solution.cpp.

                     {
    double total_duration(0);
    double total_wait_time(0);
    int total_twv(0);
    int total_cv(0);
    for (const auto &v : fleet) {
        total_duration += v.duration();
        total_wait_time += v.total_wait_time();
        total_twv += v.twvTot();
        total_cv += v.cvTot();
    }
    return std::make_tuple(
            total_twv, total_cv, fleet.size(),
            total_wait_time, total_duration);
}

References pgrouting::vrp::Solution::fleet.

Referenced by pgrouting::vrp::Solution::cost_str(), and pgrouting::vrp::Solution::operator<().

cost_str()

std::string pgrouting::vrp::Solution::cost_str ( ) const

inherited

Definition at line 149 of file solution.cpp.

                         {
    Vehicle::Cost s_cost(cost());
    std::ostringstream log;
 
    log << "(twv, cv, fleet, wait, duration) = ("
        << std::get<0>(s_cost) << ", "
        << std::get<1>(s_cost) << ", "
        << std::get<2>(s_cost) << ", "
        << std::get<3>(s_cost) << ", "
        << std::get<4>(s_cost) << ")";
 
    return log.str();
}

References pgrouting::vrp::Solution::cost().

Referenced by save_if_best(), and pgrouting::vrp::Solution::tau().

cvTot()

int pgrouting::vrp::Solution::cvTot ( ) const

inherited

Definition at line 121 of file solution.cpp.

                      {
    int total(0);
    for (const auto &v : fleet) {
        total += v.cvTot();
    }
    return total;
}

References pgrouting::vrp::Solution::fleet.

decrease_truck() [1/2]

void pgrouting::vrp::Optimize::decrease_truck

(

)

Definition at line 446 of file optimize.cpp.

                         {
    bool decreased(false);
    for (size_t i = 1; i < fleet.size(); ++i) {
        decreased = decrease_truck(i) || decreased;
    }
    if (decreased) {
        delete_empty_truck();
        save_if_best();
        decrease_truck();
    }
    save_if_best();
}

References delete_empty_truck(), pgrouting::vrp::Solution::fleet, and save_if_best().

Referenced by inter_swap(), and Optimize().

decrease_truck() [2/2]

bool pgrouting::vrp::Optimize::decrease_truck ( size_t  cycle )

private

Definition at line 460 of file optimize.cpp.

                                     {
    auto position = cycle;
    for (auto orders = fleet[position].orders_in_vehicle();
            !orders.empty();
            orders.pop_front()) {
        /* Step 2: grab an order */
        auto order = fleet[position].orders()[orders.front()];
        pgassert(order.idx() == orders.front());
 
 
        /* Step 3:
         * cycle the fleet
         * insert in first truck possible
         */
 
        for (size_t i = 0; i < position; ++i) {
            fleet[i].insert(order);
            pgassert((fleet[i].has_order(order) && fleet[i].is_feasable()) || !fleet[i].has_order(order));
            if (fleet[i].has_order(order)) {
                /*
                 * delete the order from the current truck
                 */
                fleet[position].erase(order);
                break;
            }
        }
    }
    return fleet[position].orders_in_vehicle().empty();
}

References pgrouting::vrp::Solution::fleet, pgrouting::vrp::Solution::is_feasable(), and pgassert.

delete_empty_truck()

void pgrouting::vrp::Optimize::delete_empty_truck ( )

private

Definition at line 288 of file optimize.cpp.

                             {
    fleet.erase(std::remove_if(
                fleet.begin(),
                fleet.end(),
                [](const Vehicle_pickDeliver &v){
                return v.orders_in_vehicle().empty();}),
            fleet.end());
    save_if_best();
}

References pgrouting::vrp::Solution::fleet, and save_if_best().

Referenced by decrease_truck(), and inter_swap().

duration()

double pgrouting::vrp::Solution::duration ( ) const

inherited

Definition at line 76 of file solution.cpp.

                         {
    double total(0);
    for (const auto &v : fleet) {
        total += v.duration();
    }
    return total;
}

References pgrouting::vrp::Solution::fleet.

Referenced by move_reduce_cost(), save_if_best(), and swap_worse().

get_kind()

Initials_code pgrouting::vrp::Solution::get_kind ( ) const

inherited

Definition at line 237 of file solution.cpp.

                         {
    return problem->get_kind();
}

References pgrouting::vrp::Pgr_pickDeliver::get_kind(), and pgrouting::vrp::Solution::problem.

Referenced by move_order(), move_reduce_cost(), and swap_worse().

get_postgres_result()

std::vector< General_vehicle_orders_t > pgrouting::vrp::Solution::get_postgres_result ( ) const

inherited

Definition at line 42 of file solution.cpp.

                                    {
    std::vector<General_vehicle_orders_t> result;
    /* postgres numbering starts with 1 */
    int i(1);
    for (const auto& truck : fleet) {
        std::vector<General_vehicle_orders_t> data =
            truck.get_postgres_result(i);
        result.insert(result.end(), data.begin(), data.end());
 
        ++i;
    }
    return result;
}

References pgrouting::vrp::Solution::fleet.

inter_swap() [1/2]

bool pgrouting::vrp::Optimize::inter_swap ( )

private

Definition at line 94 of file optimize.cpp.

                     {
    msg().log
        << "\n" <<tau("before inter swap");
    delete_empty_truck();
    auto swapped_f = false;
    /*
     *   .. to ... from ....
     */
    for (auto &from : fleet) {
        for (auto &to : fleet) {
            if (&from == &to) break;
 
#if 0
            msg().log
                << "\n to " << to.id()
                << "from " << from.id();
            auto swapped = false;
#endif
            swap_worse(to, from);
            move_reduce_cost(from, to);
#if 0
            msg().log << "++++++++" << p_swaps;
#endif
        }
    }
 
    msg().log
        << "\n" <<tau("after");
    delete_empty_truck();
 
    return swapped_f;
}

References delete_empty_truck(), pgrouting::vrp::Solution::fleet, pgrouting::Pgr_messages::log, move_reduce_cost(), pgrouting::vrp::Solution::msg(), swap_worse(), and pgrouting::vrp::Solution::tau().

Referenced by inter_swap(), and Optimize().

inter_swap() [2/2]

void pgrouting::vrp::Optimize::inter_swap

(

size_t

times

)

Definition at line 66 of file optimize.cpp.

                                 {
    msg().log << tau("before sort by size");
    sort_by_size();
    msg().log << tau("before decrease");
    decrease_truck();
    msg().log << tau("after decrease");
    sort_by_size();
    msg().log << tau("after sort by size");
 
    size_t i = 0;
    while (i++ < times) {
        msg().log << "\n*************************** CYCLE" << i;
        inter_swap();
        msg().log << tau("after inter swap");
        std::rotate(fleet.begin(), fleet.begin() + 1, fleet.end());
        msg().log << tau("before next cycle");
    }
}

References decrease_truck(), pgrouting::vrp::Solution::fleet, inter_swap(), pgrouting::Pgr_messages::log, pgrouting::vrp::Solution::msg(), sort_by_size(), and pgrouting::vrp::Solution::tau().

is_feasable()

bool pgrouting::vrp::Solution::is_feasable ( ) const

inherited

Definition at line 67 of file solution.cpp.

                            {
    for (const auto& v : fleet) {
        if (v.is_feasable()) continue;
        return false;
    }
    return true;
}

References pgrouting::vrp::Solution::fleet.

Referenced by decrease_truck(), and pgrouting::vrp::Initial_solution::do_while_foo().

move_order()

bool pgrouting::vrp::Optimize::move_order ( Order  order, Vehicle_pickDeliver &  from_truck, Vehicle_pickDeliver &  to_truck  )

private

moves an order to an non empty vehicle

order: order to be moved from_truck: here is the order to truck: truck to put the order

to check if the order was inserted: to_truck.has_order(order)

Returns

bool: when move was done

Definition at line 393 of file optimize.cpp.

                                       {
    pgassert(from_truck.has_order(order));
    pgassert(!to_truck.has_order(order));
    /*
     * don't move to empty truck
     */
    if (to_truck.empty()) return false;
 
    /*
     * don't move from a real truck to a phoney truck
     */
    if (!from_truck.is_phony() && to_truck.is_phony()) return false;
 
    /*
     * Don't move from a vehicle with more orders
     */
    if (from_truck.size() > to_truck.size()) return false;
 
    /*
     * insert the order
     */
    this->get_kind() == OneDepot?
        to_truck.semiLIFO(order) :
        to_truck.insert(order);
 
    if (to_truck.has_order(order)) {
        from_truck.erase(order);
 
        pgassert(!(from_truck.has_order(order) && to_truck.has_order(order)));
        pgassert(!from_truck.has_order(order));
        pgassert(to_truck.has_order(order));
        return true;
    }
 
    pgassert(!(from_truck.has_order(order) && to_truck.has_order(order)));
    pgassert(from_truck.has_order(order));
    pgassert(!to_truck.has_order(order));
    return false;
}

References pgrouting::vrp::Vehicle::empty(), pgrouting::vrp::Vehicle_pickDeliver::erase(), pgrouting::vrp::Solution::get_kind(), pgrouting::vrp::Vehicle_pickDeliver::has_order(), pgrouting::vrp::Vehicle_pickDeliver::insert(), pgrouting::vrp::Vehicle::is_phony(), pgrouting::vrp::OneDepot, pgassert, pgrouting::vrp::Vehicle_pickDeliver::semiLIFO(), and pgrouting::vrp::Vehicle::size().

Referenced by swap_worse().

move_reduce_cost()

bool pgrouting::vrp::Optimize::move_reduce_cost ( Vehicle_pickDeliver &  from, Vehicle_pickDeliver &  to  )

private

Definition at line 311 of file optimize.cpp.

                                 {
    pgassert(&from != &to);
 
    auto from_truck = from;
    auto to_truck = to;
    /*
     * don't move to empty truck
     */
    if (to_truck.empty()) return false;
 
    /*
     * don't move from a real truck to a phoney truck
     */
    if (!from_truck.is_phony() && to_truck.is_phony()) {
        return false;
    }
 
    auto moved = false;
 
    auto from_orders = from_truck.orders_in_vehicle();
    for (const auto o_id : from_orders) {
        /*
         * removing an order decreases the duration
         */
        auto order = from_truck.orders()[o_id];
 
        auto curr_duration = from_truck.duration() + to_truck.duration();
        /*
         * insert it in the "to" truck
         */
        pgassert(!to_truck.has_order(order));
        this->get_kind() == OneDepot?
            to_truck.semiLIFO(order) :
            to_truck.insert(order);
        pgassert((to_truck.has_order(order) && to_truck.is_feasable()) || !to_truck.has_order(order));
 
        if (to_truck.has_order(order)) {
            from_truck.erase(order);
 
            auto new_duration = from_truck.duration() + to_truck.duration();
 
            /*
             * cost is reduced
             */
            if (new_duration < curr_duration
                   || from_truck.empty()
                   || new_duration < best_solution.duration()) {
                moved = true;
                save_if_best();
                continue;
            }
 
            /*
             * cost is not reduced
             * revert changes
             */
            to_truck.erase(order);
            this->get_kind() == OneDepot?
                from_truck.semiLIFO(order) :
                from_truck.insert(order);
        }
    }
    return moved;
}

References best_solution, pgrouting::vrp::Solution::duration(), pgrouting::vrp::Solution::get_kind(), pgrouting::vrp::OneDepot, pgrouting::vrp::Vehicle_pickDeliver::orders_in_vehicle(), pgassert, and save_if_best().

Referenced by inter_swap().

msg()

Pgr_messages & pgrouting::vrp::Solution::msg ( )

staticinherited

The problem's message.

Returns

The problem's message for logging

Definition at line 60 of file solution.cpp.

              {
    return problem->msg;
}

References pgrouting::vrp::Pgr_pickDeliver::msg, and pgrouting::vrp::Solution::problem.

Referenced by pgrouting::vrp::Initial_solution::do_while_foo(), inter_swap(), pgrouting::vrp::Initial_solution::one_truck_all_orders(), Optimize(), save_if_best(), and pgrouting::vrp::Solution::Solution().

operator<()

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

inherited

Definition at line 189 of file solution.cpp.

                                               {
    Vehicle::Cost lhs(cost());
    Vehicle::Cost rhs(s_rhs.cost());
 
    /*
     * capacity violations
     */
    if (std::get<0>(lhs) < std::get<0>(rhs))
        return true;
    if (std::get<0>(lhs) > std::get<0>(rhs))
        return false;
 
    /*
     * time window 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 pgrouting::vrp::Solution::cost().

save_if_best()

void pgrouting::vrp::Optimize::save_if_best ( )

private

Definition at line 491 of file optimize.cpp.

                       {
    if (duration() < best_solution.duration()) {
        best_solution = (*this);
        msg().log << "\n*********** best by duration"
            << best_solution.cost_str();
#if 0
        msg().dbg_log << best_solution.tau("best by duration");
#endif
    }
    if (fleet.size() < best_solution.fleet.size()) {
        best_solution = (*this);
        msg().log << "\n*********** best by fleet size"
            << best_solution.cost_str();
#if 0
        msg().dbg_log << best_solution.tau("best by fleet size");
#endif
    }
}

References best_solution, pgrouting::vrp::Solution::cost_str(), pgrouting::vrp::Solution::duration(), pgrouting::vrp::Solution::fleet, pgrouting::Pgr_messages::log, pgrouting::vrp::Solution::msg(), and pgrouting::vrp::Solution::tau().

Referenced by decrease_truck(), delete_empty_truck(), and move_reduce_cost().

sort_by_duration()

void pgrouting::vrp::Optimize::sort_by_duration ( )

private

Definition at line 279 of file optimize.cpp.

                           {
    std::sort(fleet.begin(), fleet.end(), []
            (const Vehicle_pickDeliver &lhs, const Vehicle_pickDeliver &rhs)
            -> bool {
            return lhs.duration() > rhs.duration();
            });
}

References pgrouting::vrp::Solution::fleet.

Referenced by sort_by_size().

sort_by_size()

void pgrouting::vrp::Optimize::sort_by_size ( )

private

Definition at line 268 of file optimize.cpp.

                       {
    sort_by_duration();
    std::stable_sort(fleet.begin(), fleet.end(), []
            (const Vehicle_pickDeliver &lhs, const Vehicle_pickDeliver &rhs)
            -> bool {
            return lhs.orders_in_vehicle().size()
            > rhs.orders_in_vehicle().size();
            });
}

References pgrouting::vrp::Solution::fleet, and sort_by_duration().

Referenced by inter_swap(), and Optimize().

swap_worse()

bool pgrouting::vrp::Optimize::swap_worse ( Vehicle_pickDeliver &  from, Vehicle_pickDeliver &  to  )

private

Definition at line 133 of file optimize.cpp.

                                                                       {
    /*
     * working on a copy of the vehicles
     */
    auto from_truck = from;
    auto to_truck = to;
 
    auto swapped = false;
 
    /*
     * To avoid invalidation of cycles
     */
    auto o_from_orders = from_truck.orders_in_vehicle();
    auto o_to_orders = to_truck.orders_in_vehicle();
 
    pgassert((o_from_orders * o_to_orders).empty());
 
    for (auto from_orders = from_truck.orders_in_vehicle();
            !from_orders.empty();
            from_orders.pop_front()) {
        auto from_order = from_truck.orders()[from_orders.front()];
 
        pgassert(from_truck.has_order(from_order));
 
        if (move_order(from_order, from_truck, to_truck)) {
            pgassert(!from_truck.has_order(from_order));
            pgassert(to_truck.has_order(from_order));
            /*
             * The order could be moved to "to" truck
             */
            to = to_truck;
            from = from_truck;
            /*
             * go to next order
             */
            pgassert(!from.has_order(from_order));
            pgassert(to.has_order(from_order));
            pgassert(!from_truck.has_order(from_order));
            pgassert(to_truck.has_order(from_order));
            pgassert(!(from.has_order(from_order) && to.has_order(from_order)));
            pgassert(from.has_order(from_order) || to.has_order(from_order));
            continue;
        }
 
        pgassert(from_truck.has_order(from_order));
        auto curr_from_duration = from_truck.duration();
 
        for (auto to_order_id : o_to_orders) {
            auto to_order = to.orders()[to_order_id];
            /*
             * The orders might have being swapped before
             */
            if (!to_truck.has_order(to_order)) continue;
            // if (!from_truck.has_order(from_order)) break; // TODO delete line
 
            pgassert(from_truck.has_order(from_order));
            pgassert(to_truck.has_order(to_order));
 
            auto curr_to_duration = to_truck.duration();
 
            /*
             * delete from_order, and to order from their trucks
             */
            pgassert(from_truck.has_order(from_order));
            from_truck.erase(from_order);
            pgassert(to_truck.has_order(to_order));
            to_truck.erase(to_order);
 
            /*
             * insert them in the other truck
             */
            if (this->get_kind() == OneDepot) {
                from_truck.semiLIFO(to_order);
                to_truck.semiLIFO(from_order);
            } else {
                from_truck.insert(to_order);
                to_truck.insert(from_order);
            }
 
            pgassert((from_truck.has_order(to_order) && from_truck.is_feasable()) || !from_truck.has_order(to_order));
            pgassert((to_truck.has_order(from_order) && to_truck.is_feasable()) || !to_truck.has_order(from_order));
 
            if (from_truck.has_order(to_order) && to_truck.has_order(from_order)) {
                auto new_from_duration = from_truck.duration();
                auto new_to_duration = to_truck.duration();
 
                auto estimated_delta =
                    - (curr_from_duration + curr_to_duration)
                    + (new_to_duration + new_from_duration);
 
                auto estimated_duration = duration() + estimated_delta;
 
                /*
                 * Can swap when:
                 *   - or from_truck duration is reduced
                 *   - the total fleet duration is reduced
                 *   - or the new fleet duration is better than best_solution duration
                 */
                if (new_from_duration < curr_from_duration ||
                        estimated_delta < 0 ||
                        estimated_duration < best_solution.duration()) {
                    /*
                     * this acctually makes the swapping
                     */
                    to = to_truck;
                    from = from_truck;
 
                    pgassert(!(from.has_order(from_order) && to.has_order(from_order)));
                    pgassert(from.has_order(from_order) || to.has_order(from_order));
                    pgassert(!(from.has_order(to_order) && to.has_order(to_order)));
                    pgassert(from.has_order(to_order) || to.has_order(to_order));
 
                    swapped = true;
                    break;
                }
            }
            /*
             * Can't swap, restore vehicles
             */
            to_truck = to;
            from_truck = from;
 
            pgassert(!(from.has_order(from_order) && to.has_order(from_order)));
            pgassert(from.has_order(from_order) || to.has_order(from_order));
            pgassert(!(from.has_order(to_order) && to.has_order(to_order)));
            pgassert(from.has_order(to_order) || to.has_order(to_order));
        }
    }
 
    return false && swapped;
}

References best_solution, pgrouting::vrp::Solution::duration(), pgrouting::vrp::Solution::get_kind(), pgrouting::vrp::Vehicle_pickDeliver::has_order(), move_order(), pgrouting::vrp::OneDepot, pgrouting::vrp::Vehicle_pickDeliver::orders(), pgrouting::vrp::Vehicle_pickDeliver::orders_in_vehicle(), and pgassert.

Referenced by inter_swap().

tau()

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

inherited

Definition at line 164 of file solution.cpp.

                                          {
    std::ostringstream log;
 
    log << "\n" << title << ": " << std::endl;
    for (const auto &v : fleet) {
        log << "\n" << v.tau();
    }
    log << "\n" << cost_str() << "\n";
    return log.str();
}

References pgrouting::vrp::Solution::cost_str(), and pgrouting::vrp::Solution::fleet.

Referenced by inter_swap(), pgrouting::vrp::operator<<(), Optimize(), and save_if_best().

total_service_time()

double pgrouting::vrp::Solution::total_service_time ( ) const

inherited

Definition at line 112 of file solution.cpp.

                                   {
    double total(0);
    for (const auto &v : fleet) {
        total += v.total_service_time();
    }
    return total;
}

References pgrouting::vrp::Solution::fleet.

total_travel_time()

double pgrouting::vrp::Solution::total_travel_time ( ) const

inherited

Definition at line 103 of file solution.cpp.

                                  {
    double total(0);
    for (const auto &v : fleet) {
        total += v.total_travel_time();
    }
    return total;
}

References pgrouting::vrp::Solution::fleet.

twvTot()

int pgrouting::vrp::Solution::twvTot ( ) const

inherited

Definition at line 85 of file solution.cpp.

                       {
    int total(0);
    for (const auto &v : fleet) {
        total += v.twvTot();
    }
    return total;
}

References pgrouting::vrp::Solution::fleet.

wait_time()

double pgrouting::vrp::Solution::wait_time ( ) const

inherited

Definition at line 94 of file solution.cpp.

                          {
    double total(0);
    for (const auto &v : fleet) {
        total += v.total_wait_time();
    }
    return total;
}

References pgrouting::vrp::Solution::fleet.

Member Data Documentation

best_solution

Solution pgrouting::vrp::Optimize::best_solution

Definition at line 52 of file optimize.h.

Referenced by move_reduce_cost(), Optimize(), save_if_best(), and swap_worse().

EPSILON

double pgrouting::vrp::Solution::EPSILON

protectedinherited

Definition at line 48 of file solution.h.

Referenced by pgrouting::vrp::Solution::operator=().

fleet

std::deque<Vehicle_pickDeliver> pgrouting::vrp::Solution::fleet

protectedinherited

Definition at line 49 of file solution.h.

Referenced by pgrouting::vrp::Solution::cost(), pgrouting::vrp::Solution::cvTot(), decrease_truck(), delete_empty_truck(), pgrouting::vrp::Initial_solution::do_while_foo(), pgrouting::vrp::Solution::duration(), pgrouting::vrp::Solution::get_postgres_result(), inter_swap(), pgrouting::vrp::Solution::is_feasable(), pgrouting::vrp::Initial_solution::one_truck_all_orders(), pgrouting::vrp::operator<<(), pgrouting::vrp::Solution::operator=(), Optimize(), save_if_best(), sort_by_duration(), sort_by_size(), pgrouting::vrp::Solution::tau(), pgrouting::vrp::Solution::total_service_time(), pgrouting::vrp::Solution::total_travel_time(), pgrouting::vrp::Solution::twvTot(), and pgrouting::vrp::Solution::wait_time().

problem

Pgr_pickDeliver * pgrouting::vrp::Solution::problem

staticprivateinherited

this solution belongs to this problem

Definition at line 114 of file solution.h.

Referenced by pgrouting::vrp::Solution::get_kind(), pgrouting::vrp::Solution::msg(), and pgrouting::vrp::PD_problem::PD_problem().

trucks

Fleet pgrouting::vrp::Solution::trucks

protectedinherited

Definition at line 52 of file solution.h.

Referenced by pgrouting::vrp::Initial_solution::do_while_foo(), pgrouting::vrp::Initial_solution::one_truck_all_orders(), pgrouting::vrp::Solution::operator=(), and pgrouting::vrp::Solution::Solution().

---

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

• optimize.h
• optimize.cpp