Initial_solution::Initial_solution(
int kind,
size_t number_of_orders) :
Solution(),
all_orders(number_of_orders),
unassigned(number_of_orders),
assigned() {
invariant();
pgassert(kind >= 0 && kind < 7);
switch (kind) {
case 0:
one_truck_all_orders();
break;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
do_while_foo(kind);
break;
default: pgassert(false);
}
invariant();
}
/*
* from_truck: position of the truck where the order is
* to truck: truck to put the order
*/
bool
Optimize::swap_order(
const Order from_order,
Vehicle_pickDeliver &from_truck,
const Order to_order,
Vehicle_pickDeliver &to_truck) {
if (!from_truck.has_order(from_order)
|| !to_truck.has_order(to_order)) {
return false;
}
pgassert(from_truck.has_order(from_order));
pgassert(to_truck.has_order(to_order));
from_truck.erase(from_order);
to_truck.erase(to_order);
from_truck.insert(to_order);
to_truck.insert(from_order);
pgassert(from_truck.has_order(to_order));
pgassert(to_truck.has_order(from_order));
return true;
}
void
Initial_solution::do_while_foo(int kind) {
invariant();
pgassert(kind > 0 && kind < 7);
msg.log << "\nInitial_solution::do_while_foo\n";
Identifiers<size_t> notused;
#if 0
bool out_of_trucks(true);
#endif
while (!unassigned.empty()) {
msg.log << unassigned.size() << " unassigned: " << unassigned << "\n";
msg.log << assigned.size() << " assigned:" << assigned << "\n";
auto current = unassigned.size();
#if 0
auto truck = out_of_trucks?
trucks.get_truck(unassigned.front()) :
trucks.get_truck();
#else
auto truck = trucks.get_truck(unassigned.front());
#endif
msg.log << "got truck:" << truck.tau() << "\n";
/*
* kind 1 to 7 work with the same code structure
*/
truck.do_while_feasable(kind, unassigned, assigned);
msg.log << unassigned.size() << " unassigned: " << unassigned << "\n";
msg.log << assigned.size() << " assigned:" << assigned << "\n";
msg.log << "current" << current << " unassigned: " << unassigned.size();
pgassertwm(current > unassigned.size(), msg.get_log().c_str());
#if 0
if (truck.orders_in_vehicle().empty()) {
out_of_trucks = notused.has(truck.idx());
if (out_of_trucks) {
for (auto t : notused) {
trucks.release_truck(t);
}
}
notused += truck.idx();
continue;
}
#endif
fleet.push_back(truck);
invariant();
}
pgassertwm(true, msg.get_log().c_str());
pgassert(is_feasable());
invariant();
}
void
Vehicle_pickDeliver::erase(const Order &order) {
invariant();
pgassert(has_order(order));
Vehicle::erase(order.pickup());
Vehicle::erase(order.delivery());
orders_in_vehicle.erase(orders_in_vehicle.find(order.id()));
invariant();
pgassert(!has_order(order));
}
/*
* from_truck: position of the truck where the order is
* to truck: truck to put the order
*/
void
Optimize::move_order(
Order order,
Vehicle_pickDeliver &from_truck,
Vehicle_pickDeliver &to_truck) {
pgassert(from_truck.has_order(order));
pgassert(!to_truck.has_order(order));
from_truck.erase(order);
to_truck.insert(order);
pgassert(!from_truck.has_order(order));
pgassert(to_truck.has_order(order));
}
void
Vehicle_pickDeliver::push_front(const Order &order) {
invariant();
pgassert(!has_order(order));
orders_in_vehicle.insert(order.id());
m_path.insert(m_path.begin() + 1, order.delivery());
m_path.insert(m_path.begin() + 1, order.pickup());
evaluate(1);
pgassert(has_order(order));
pgassert(!has_cv());
invariant();
}
void
Vehicle_pickDeliver::push_back(const Order &order) {
invariant();
pgassert(!has_order(order));
orders_in_vehicle.insert(order.id());
m_path.insert(m_path.end() - 1, order.pickup());
m_path.insert(m_path.end() - 1, order.delivery());
evaluate(m_path.size() - 3);
pgassert(has_order(order));
pgassert(!has_cv());
invariant();
}
// -------------------------------------------------------------------------
double Pgr_trspHandler::getRestrictionCost(
int64_t edge_ind,
const EdgeInfo &edge,
bool isStart) {
double cost = 0.0;
int64_t edge_id = edge.edgeID();
if (m_ruleTable.find(edge_id) == m_ruleTable.end()) {
return(0.0);
}
auto vecRules = m_ruleTable[edge_id];
int64_t st_edge_ind = edge_ind;
for (const auto &rule : vecRules) {
bool flag = true;
int64_t v_pos = (isStart? C_EDGE : RC_EDGE);
edge_ind = st_edge_ind;
pgassert(!(edge_ind == -1));
for (auto const &precedence : rule.precedencelist()) {
if (precedence != m_edges[edge_ind].edgeID()) {
flag = false;
break;
}
auto m_parent_ind = m_parent[edge_ind].e_idx[v_pos];
v_pos = m_parent[edge_ind].v_pos[v_pos];
edge_ind = m_parent_ind;
}
if (flag)
cost += rule.cost();
}
return cost;
}
bool
Optimize::decrease_truck(size_t cycle) {
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);
if (fleet[i].is_feasable()) {
/*
* delete the order from the current truck
*/
fleet[position].erase(order);
break;
} else {
fleet[i].erase(order);
}
}
}
return fleet[position].orders_in_vehicle().empty();
}
EdgeInfo Pgr_trspHandler::dijkstra_exploration() {
EdgeInfo cur_edge;
pgassert(current_node == m_start_vertex);
while (!que.empty()) {
auto cur_pos = que.top();
que.pop();
auto cure_idxex = cur_pos.second.first;
cur_edge = m_edges[cure_idxex];
if (cur_pos.second.second) {
/*
* explore edges connected to end node
*/
current_node = cur_edge.endNode();
if (cur_edge.cost() < 0.0) continue;
if (current_node == m_end_vertex) break;
explore(current_node, cur_edge, false);
} else {
/*
* explore edges connected to start node
*/
current_node = cur_edge.startNode();
if (cur_edge.r_cost() < 0.0) continue;
if (current_node == m_end_vertex) break;
explore(current_node, cur_edge, true);
}
}
return cur_edge;
}
void
Pgr_linear<G>::add_shortcut(
G &graph, V vertex,
E incoming_edge,
E outgoing_edge) {
pgassert(incoming_edge != outgoing_edge);
auto a = graph.adjacent(vertex, incoming_edge);
auto c = graph.adjacent(vertex, outgoing_edge);
pgassert(a != vertex);
pgassert(a != c);
pgassert(vertex != c);
if (graph.is_undirected()) {
Identifiers<V> adjacent_vertices = graph.find_adjacent_vertices(vertex);
V vertex_1 = adjacent_vertices.front();
adjacent_vertices.pop_front();
V vertex_2 = adjacent_vertices.front();
adjacent_vertices.pop_front();
E shortcut_E;
CH_edge shortcut(get_next_id(), graph[vertex_1].id,
graph[vertex_2].id,
graph[incoming_edge].cost + graph[outgoing_edge].cost);
shortcut.add_contracted_vertex(graph[vertex], vertex);
shortcut.add_contracted_edge_vertices(graph[incoming_edge]);
shortcut.add_contracted_edge_vertices(graph[outgoing_edge]);
debug << "Adding shortcut\n";
debug << shortcut;
graph.add_shortcut(shortcut);
debug << "Added shortcut\n";
} else {
CH_edge shortcut(
get_next_id(),
graph[a].id,
graph[c].id,
graph[incoming_edge].cost + graph[outgoing_edge].cost);
shortcut.add_contracted_vertex(graph[vertex], vertex);
shortcut.add_contracted_edge_vertices(graph[incoming_edge]);
shortcut.add_contracted_edge_vertices(graph[outgoing_edge]);
debug << "Adding shortcut\n";
debug << shortcut;
graph.add_shortcut(shortcut);
debug << "Added shortcut\n";
}
}
bool
Optimize::swap_order() {
#if 0
msg.log << "++++++++" << p_swaps;
#endif
while (!p_swaps.empty()) {
auto swap_data = p_swaps.top();
p_swaps.pop();
size_t from_pos = 0;
size_t to_pos = 0;
for (; from_pos < fleet.size()
&& fleet[from_pos].idx() != swap_data.from_truck.idx()
; ++from_pos) {
}
pgassert(from_pos < fleet.size());
for (; to_pos < fleet.size()
&& fleet[to_pos].idx() != swap_data.to_truck.idx()
; ++to_pos) {
}
pgassert(to_pos < fleet.size());
if (swap_order(
fleet[from_pos].orders()[swap_data.from_order], fleet[from_pos],
fleet[to_pos].orders()[swap_data.to_order], fleet[to_pos])) {
save_if_best();
#if 0
msg.log
<< "\n Swapping order "
<< fleet[from_pos].orders()[
swap_data.from_order].pickup().original_id()
<< " from truck " << fleet[from_pos].id()
<< " with order "
<< fleet[to_pos].orders()[
swap_data.to_order].pickup().original_id()
<< " of truck " << fleet[to_pos].id();
#endif
#if 0
msg.log << "\nswappping after:";
msg.log << "\n" << fleet[to_pos].tau();
msg.log << "\n" << fleet[from_pos].tau();
#endif
return true;
}
}
return false;
}
Optimize::Optimize(
const Solution &old_solution) :
Solution(old_solution),
best_solution(old_solution) {
pgassert(false);
decrease_truck();
inter_swap(fleet.size());
}
V add_one_vertex(
T_V vertex) {
auto v = add_vertex(this->graph);
this->vertices_map[vertex.id] = v;
this->graph[v].cp_members(vertex);
pgassert(boost::num_vertices(this->graph) == this->num_vertices());
return v;
}
/*
* from_truck: position of the truck where the order is
* to truck: truck to put the order
*/
void
Optimize::swap_order(
const Order from_order,
Vehicle_pickDeliver &from_truck,
const Order to_order,
Vehicle_pickDeliver &to_truck) {
pgassert(from_truck.has_order(from_order));
pgassert(to_truck.has_order(to_order));
from_truck.erase(from_order);
to_truck.erase(to_order);
from_truck.insert(to_order);
to_truck.insert(from_order);
pgassert(from_truck.has_order(to_order));
pgassert(to_truck.has_order(from_order));
}
size_t
Vehicle_pickDeliver::pop_back() {
invariant();
pgassert(!empty());
auto pick_itr = m_path.rbegin();
while (pick_itr != m_path.rend() && !pick_itr->is_pickup()) {
++pick_itr;
}
pgassert(pick_itr->is_pickup());
ID deleted_pick_id = pick_itr->id();
auto delivery_id = problem->node(deleted_pick_id).Did();
m_path.erase((pick_itr + 1).base());
auto delivery_itr = m_path.rbegin();
while (delivery_itr != m_path.rend()
&& !(delivery_itr->id() ==delivery_id)) {
++delivery_itr;
}
pgassert(delivery_itr->is_delivery());
pgassert(delivery_itr->Pid() == deleted_pick_id);
m_path.erase((delivery_itr + 1).base());
/* figure out from where the evaluation is needed */
evaluate(1);
ID deleted_order_id(
problem->order_of(problem->node(deleted_pick_id)).id());
orders_in_vehicle.erase(orders_in_vehicle.find(deleted_order_id));
invariant();
return deleted_order_id;
}
size_t
Vehicle_pickDeliver::pop_front() {
invariant();
pgassert(!empty());
auto pick_itr = m_path.begin();
while (pick_itr != m_path.end() && !pick_itr->is_pickup()) {
++pick_itr;
}
pgassert(pick_itr->is_pickup());
ID deleted_pick_id = pick_itr->id();
auto delivery_id = problem->node(deleted_pick_id).Did();
m_path.erase(pick_itr);
auto delivery_itr = m_path.begin();
while (delivery_itr != m_path.end()
&& !(delivery_itr->id() == delivery_id)) {
++delivery_itr;
}
pgassert(delivery_itr->is_delivery());
pgassert(delivery_itr->Pid() == deleted_pick_id);
m_path.erase(delivery_itr);
evaluate(1);
ID deleted_order_id(
problem->order_of(problem->node(deleted_pick_id)).id());
orders_in_vehicle.erase(orders_in_vehicle.find(deleted_order_id));
invariant();
return deleted_order_id;
}
// -------------------------------------------------------------------------
double Pgr_trspHandler::construct_path(int64_t ed_id, Position pos) {
pgassert(pos != ILLEGAL);
if (m_parent[ed_id].isIllegal(pos)) {
Path_t pelement;
auto cur_edge = &m_edges[ed_id];
if (pos == RC_EDGE) {
pelement.node = cur_edge->startNode();
pelement.cost = cur_edge->cost();
} else {
pelement.node = cur_edge->endNode();
pelement.cost = cur_edge->r_cost();
}
pelement.edge = cur_edge->edgeID();
m_path.push_back(pelement);
pgassert(m_path.start_id() == m_start_vertex);
return pelement.cost;
}
double ret = construct_path(m_parent[ed_id].e_idx[pos],
m_parent[ed_id].v_pos[pos]);
Path_t pelement;
auto cur_edge = &m_edges[ed_id];
if (pos == RC_EDGE) {
pelement.node = cur_edge->startNode();
pelement.cost = m_dCost[ed_id].endCost - ret;
ret = m_dCost[ed_id].endCost;
} else {
pelement.node = cur_edge->endNode();
pelement.cost = m_dCost[ed_id].startCost - ret;
ret = m_dCost[ed_id].startCost;
}
pelement.edge = cur_edge->edgeID();
m_path.push_back(pelement);
return ret;
}
bool do_pgr_test_matrixRows(
Matrix_cell_t *matrix_rows,
size_t total_rows,
char ** log_msg,
char ** err_msg) {
std::ostringstream log;
std::ostringstream err;
try {
pgassert(!(*log_msg));
pgassert(!(*err_msg));
std::vector< Matrix_cell_t > matrix(matrix_rows, matrix_rows + total_rows);
log << "Original: \n" <<
std::setprecision(32);
for (const auto row : matrix) {
log << "start_vid = " << row.from_vid
<< "\tend_vid = " << row.to_vid
<< "\tagg_cost = " << row.cost;
}
*err_msg = NULL;
*log_msg = strdup(log.str().c_str());
return true;
} catch (AssertFailedException &except) {
log << except.what() << "\n";
*err_msg = strdup(log.str().c_str());
return false;
} catch (std::exception& except) {
log << except.what() << "\n";
*err_msg = strdup(log.str().c_str());
return false;
} catch(...) {
log << "Caught unknown exception!\n";
*err_msg = strdup(log.str().c_str());
return false;
}
}
Order
Vehicle_pickDeliver::get_worse_order(
std::set<size_t> orders) const {
invariant();
pgassert(!empty());
// auto orders(of_this_subset);
auto worse_order(problem->orders()[*orders.begin()]);
auto delta_duration((std::numeric_limits<double>::max)());
auto curr_duration(duration());
while (!orders.empty()) {
auto truck(*this);
auto order(problem->orders()[*orders.begin()]);
pgassert(truck.has_order(order));
orders.erase(orders.begin());
truck.erase(order);
auto delta = truck.duration() - curr_duration;
if (delta < delta_duration) {
worse_order = order;
delta_duration = delta;
}
}
return worse_order;
}
double
Dmatrix::tourCost(const Tour &tour) const {
double total_cost(0);
if (tour.cities.empty()) return total_cost;
auto prev_id = tour.cities.front();
for (const auto &id : tour.cities) {
if (id == tour.cities.front()) continue;
pgassert(distance(prev_id, id) != (std::numeric_limits<double>::max)());
total_cost += costs[prev_id][id];
prev_id = id;
}
total_cost += costs[prev_id][tour.cities.front()];
return total_cost;
}
/*
* from_truck trying to make from_truck's duration smaller
* - maybe all orders can be moved
* - if that is the case, the from_truck could be removed
*
* Deleting an order on the from_truck
* - number of truck remains the same
* - from_truk duration() can not get larger
* - the overall duration can get larger
*
*/
bool
Optimize::move_reduce_cost(size_t from_pos, size_t to_pos) {
pgassert(to_pos < from_pos);
auto from_truck = fleet[from_pos];
auto to_truck = fleet[to_pos];
auto moved(false);
auto orders(from_truck.orders_in_vehicle);
while (!orders.empty()) {
/*
* get the order that decreases the duration the most
* (there is always a worse)
*/
auto order = from_truck.get_worse_order(orders);
orders.erase(order.id());
/*
* insert it in the next truck
*/
to_truck.insert(order);
if (to_truck.is_feasable()) {
problem->log
<< "\n Move order " << order.id()
<< " from truck " << from_truck.id()
<< " to truck " << to_truck.id();
#ifndef NDEBUG
problem->dbg_log << "\nMove before:";
problem->dbg_log << "\n" << fleet[to_pos].tau();
problem->dbg_log << "\n" << fleet[from_pos].tau();
#endif
from_truck.erase(order);
move_order(order, fleet[from_pos], fleet[to_pos]);
moved = true;
save_if_best();
#ifndef NDEBUG
problem->dbg_log << "\nMove after:";
problem->dbg_log << "\n" << fleet[to_pos].tau();
problem->dbg_log << "\n" << fleet[from_pos].tau();
#endif
}
}
return moved;
}
Path
Pgr_trspHandler::process_trsp(
size_t edge_count) {
pgassert(m_path.start_id() == m_start_vertex);
pgassert(m_path.end_id() == m_end_vertex);
pgassert(m_parent.empty());
m_parent.resize(edge_count + 1);
m_dCost.resize(edge_count + 1);
initialize_que();
current_node = m_start_vertex;
pgassert(m_path.start_id() == m_start_vertex);
auto cur_edge = dijkstra_exploration();
pgassert(m_path.start_id() == m_start_vertex);
if (current_node != m_end_vertex) {
Path result(m_start_vertex, m_end_vertex);
return result.renumber_vertices(m_min_id);;
}
pgassert(m_path.start_id() == m_start_vertex);
if (current_node == cur_edge.startNode()) {
construct_path(cur_edge.idx(), C_EDGE);
} else {
construct_path(cur_edge.idx(), RC_EDGE);
}
Path_t pelement;
pelement.node = m_end_vertex;
pelement.edge = -1;
pelement.cost = 0.0;
m_path.push_back(pelement);
m_path.Path::recalculate_agg_cost();
return m_path.renumber_vertices(m_min_id);
}
void
do_pgr_MY_FUNCTION_NAME(
MY_EDGE_TYPE *data_edges,
size_t total_edges,
int64_t start_vid,
int64_t end_vid,
bool directed,
bool only_cost,
MY_RETURN_VALUE_TYPE **return_tuples,
size_t *return_count,
char ** log_msg,
char ** notice_msg,
char ** err_msg) {
std::ostringstream log;
std::ostringstream err;
std::ostringstream notice;
try {
pgassert(!(*log_msg));
pgassert(!(*notice_msg));
pgassert(!(*err_msg));
pgassert(!(*return_tuples));
pgassert(*return_count == 0);
pgassert(total_edges != 0);
graphType gType = directed? DIRECTED: UNDIRECTED;
Path path;
if (directed) {
log << "Working with directed Graph\n";
pgrouting::DirectedGraph digraph(gType);
digraph.insert_edges(data_edges, total_edges);
path = pgr_MY_FUNCTION_NAME(digraph,
start_vid,
end_vid,
only_cost);
} else {
log << "Working with Undirected Graph\n";
pgrouting::UndirectedGraph undigraph(gType);
undigraph.insert_edges(data_edges, total_edges);
path = pgr_MY_FUNCTION_NAME(
undigraph,
start_vid,
end_vid,
only_cost);
}
auto count = path.size();
if (count == 0) {
(*return_tuples) = NULL;
(*return_count) = 0;
notice <<
"No paths found between start_vid and end_vid vertices";
return;
}
(*return_tuples) = pgr_alloc(count, (*return_tuples));
size_t sequence = 0;
path.generate_postgres_data(return_tuples, sequence);
(*return_count) = sequence;
pgassert(*err_msg == NULL);
*log_msg = log.str().empty()?
*log_msg :
pgr_msg(log.str().c_str());
*notice_msg = notice.str().empty()?
*notice_msg :
pgr_msg(notice.str().c_str());
} catch (AssertFailedException &except) {
(*return_tuples) = pgr_free(*return_tuples);
(*return_count) = 0;
err << except.what();
*err_msg = pgr_msg(err.str().c_str());
*log_msg = pgr_msg(log.str().c_str());
} catch (std::exception &except) {
(*return_tuples) = pgr_free(*return_tuples);
(*return_count) = 0;
err << except.what();
*err_msg = pgr_msg(err.str().c_str());
*log_msg = pgr_msg(log.str().c_str());
} catch(...) {
(*return_tuples) = pgr_free(*return_tuples);
(*return_count) = 0;
err << "Caught unknown exception!";
*err_msg = pgr_msg(err.str().c_str());
*log_msg = pgr_msg(log.str().c_str());
}
}
void
do_pgr_max_flow(
pgr_edge_t *data_edges,
size_t total_tuples,
int64_t *source_vertices,
size_t size_source_verticesArr,
int64_t *sink_vertices,
size_t size_sink_verticesArr,
char *algorithm,
bool only_flow,
pgr_flow_t **return_tuples,
size_t *return_count,
char** log_msg,
char** notice_msg,
char **err_msg) {
std::ostringstream log;
std::ostringstream notice;
std::ostringstream err;
try {
pgassert(data_edges);
pgassert(source_vertices);
pgassert(sink_vertices);
pgrouting::graph::PgrFlowGraph<pgrouting::FlowGraph> G;
std::set<int64_t> set_source_vertices;
std::set<int64_t> set_sink_vertices;
for (size_t i = 0; i < size_source_verticesArr; ++i) {
set_source_vertices.insert(source_vertices[i]);
}
for (size_t i = 0; i < size_sink_verticesArr; ++i) {
set_sink_vertices.insert(sink_vertices[i]);
}
std::set<int64_t> vertices(set_source_vertices);
vertices.insert(set_sink_vertices.begin(), set_sink_vertices.end());
if (vertices.size()
!= (set_source_vertices.size() + set_sink_vertices.size())) {
*err_msg = pgr_msg("A source found as sink");
// TODO(vicky) return as hint the sources that are also sinks
return;
}
G.create_flow_graph(data_edges, total_tuples, set_source_vertices,
set_sink_vertices, algorithm);
int64_t max_flow;
if (strcmp(algorithm, "push_relabel") == 0) {
max_flow = G.push_relabel();
} else if (strcmp(algorithm, "edmonds_karp") == 0) {
max_flow = G.edmonds_karp();
} else if (strcmp(algorithm, "boykov_kolmogorov") == 0) {
max_flow = G.boykov_kolmogorov();
} else {
log << "Unspecified algorithm!\n";
*err_msg = pgr_msg(log.str().c_str());
(*return_tuples) = NULL;
(*return_count) = 0;
return;
}
std::vector<pgr_flow_t> flow_edges;
if (only_flow) {
pgr_flow_t edge;
edge.edge = -1;
edge.source = -1;
edge.target = -1;
edge.flow = max_flow;
edge.residual_capacity = -1;
flow_edges.push_back(edge);
} else {
G.get_flow_edges(flow_edges);
}
(*return_tuples) = pgr_alloc(flow_edges.size(), (*return_tuples));
for (size_t i = 0; i < flow_edges.size(); ++i) {
(*return_tuples)[i] = flow_edges[i];
}
*return_count = flow_edges.size();
*log_msg = log.str().empty()?
*log_msg :
pgr_msg(log.str().c_str());
*notice_msg = notice.str().empty()?
*notice_msg :
pgr_msg(notice.str().c_str());
} catch (AssertFailedException &except) {
(*return_tuples) = pgr_free(*return_tuples);
(*return_count) = 0;
err << except.what();
*err_msg = pgr_msg(err.str().c_str());
*log_msg = pgr_msg(log.str().c_str());
} catch (std::exception &except) {
(*return_tuples) = pgr_free(*return_tuples);
(*return_count) = 0;
err << except.what();
*err_msg = pgr_msg(err.str().c_str());
*log_msg = pgr_msg(log.str().c_str());
} catch(...) {
(*return_tuples) = pgr_free(*return_tuples);
(*return_count) = 0;
err << "Caught unknown exception!";
*err_msg = pgr_msg(err.str().c_str());
*log_msg = pgr_msg(log.str().c_str());
}
}
void
do_pgr_floydWarshall(
pgr_edge_t *data_edges,
size_t total_tuples,
bool directedFlag,
// return values
Matrix_cell_t **return_tuples,
size_t *return_count,
char ** log_msg,
char ** err_msg) {
// function starts
std::ostringstream log;
try {
pgassert(!(*log_msg));
pgassert(!(*err_msg));
pgassert(!(*return_tuples));
pgassert(*return_count == 0);
graphType gType = directedFlag? DIRECTED: UNDIRECTED;
if (directedFlag) {
log << "Processing Directed graph\n";
pgrouting::DirectedGraph digraph(gType);
digraph.insert_edges(data_edges, total_tuples);
log << digraph;
pgr_floydWarshall(digraph, *return_count, return_tuples);
} else {
log << "Processing Undirected graph\n";
pgrouting::UndirectedGraph undigraph(gType);
undigraph.insert_edges(data_edges, total_tuples);
log << undigraph;
pgr_floydWarshall(undigraph, *return_count, return_tuples);
}
if (*return_count == 0) {
log << "NOTICE: No Vertices found??? wiered error\n";
*err_msg = strdup(log.str().c_str());
*return_tuples = NULL;
*return_count = 0;
return;
}
*log_msg = strdup(log.str().c_str());
return;
} catch (AssertFailedException &except) {
if (*return_tuples) free(*return_tuples);
(*return_count) = 0;
log << except.what() << "\n";
*err_msg = strdup(log.str().c_str());
} catch (std::exception& except) {
if (*return_tuples) free(*return_tuples);
(*return_count) = 0;
log << except.what() << "\n";
*err_msg = strdup(log.str().c_str());
} catch(...) {
if (*return_tuples) free(*return_tuples);
(*return_count) = 0;
log << "Caught unknown exception!\n";
*err_msg = strdup(log.str().c_str());
}
}
void
do_pgr_one_to_many_withPoints(
pgr_edge_t *edges, size_t total_edges,
Point_on_edge_t *points_p, size_t total_points,
pgr_edge_t *edges_of_points, size_t total_edges_of_points,
int64_t start_vid,
int64_t *end_pidsArr, size_t size_end_pidsArr,
char driving_side,
bool details,
bool directed,
bool only_cost,
General_path_element_t **return_tuples, size_t *return_count,
char ** log_msg,
char ** err_msg) {
std::ostringstream log;
std::ostringstream err;
try {
pgassert(!(*return_tuples));
pgassert((*return_count) == 0);
pgassert(!(*log_msg));
pgassert(!(*err_msg));
/*
* DOCUMENT:
* - Points are treated as the same point when the pid is the same
* therefore when two points have the same pid, but different edge/fraction
* an error is generated.
*/
std::vector< Point_on_edge_t >
points(points_p, points_p + total_points);
int errcode = check_points(points, log);
if (errcode) {
*log_msg = strdup(log.str().c_str());
err << "Unexpected point(s) with same pid but different edge/fraction/side combination found.";
*err_msg = strdup(err.str().c_str());
return;
}
std::vector< pgr_edge_t >
edges_to_modify(edges_of_points, edges_of_points + total_edges_of_points);
std::vector< pgr_edge_t > new_edges;
log << "driving_side" << driving_side << "\n";
create_new_edges(
points,
edges_to_modify,
driving_side,
new_edges);
log << "Inserting points into a c++ vector structure\n";
/*
* Eliminating duplicates
* & ordering the points
*/
std::set< int64_t > s_end_vertices(end_pidsArr, end_pidsArr + size_end_pidsArr);
std::vector< int64_t > end_vertices(s_end_vertices.begin(), s_end_vertices.end());
log << "start_vid" << start_vid << "\n";
log << "end_vertices";
for (const auto &vid : end_vertices) {
log << vid << "\n";
}
graphType gType = directed? DIRECTED: UNDIRECTED;
std::deque< Path > paths;
if (directed) {
log << "Working with directed Graph\n";
pgrouting::DirectedGraph digraph(
pgrouting::extract_vertices(
pgrouting::extract_vertices(edges, total_edges),
new_edges),
gType);
digraph.graph_insert_data(edges, total_edges);
digraph.graph_insert_data(new_edges);
pgr_dijkstra(digraph, paths, start_vid, end_vertices, only_cost);
} else {
log << "Working with Undirected Graph\n";
auto vertices(pgrouting::extract_vertices(edges, total_edges));
vertices = pgrouting::extract_vertices(vertices, new_edges);
pgrouting::UndirectedGraph undigraph(vertices, gType);
vertices.clear();
undigraph.graph_insert_data(edges, total_edges);
undigraph.graph_insert_data(new_edges);
pgr_dijkstra(undigraph, paths, start_vid, end_vertices, only_cost);
}
if (!details) {
for (auto &path : paths) {
eliminate_details(path, edges_to_modify);
}
}
/*
* order paths based on the end_pid
*/
std::sort(paths.begin(), paths.end(), [](const Path &a, const Path &b) {
return a.end_id() < b.end_id();
});
size_t count(0);
count = count_tuples(paths);
if (count == 0) {
(*return_tuples) = NULL;
(*return_count) = 0;
log <<
"No paths found between Starting and any of the Ending vertices\n";
*log_msg = strdup(log.str().c_str());
return;
}
(*return_tuples) = pgr_alloc(count, (*return_tuples));
log << "Converting a set of paths into the tuples\n";
(*return_count) = (collapse_paths(return_tuples, paths));
*log_msg = strdup(log.str().c_str());
pgassert(!(*err_msg));
return;
} catch (AssertFailedException &except) {
if (*return_tuples) free(*return_tuples);
(*return_count) = 0;
*log_msg = strdup(log.str().c_str());
err << except.what() << "\n";
*err_msg = strdup(err.str().c_str());
} catch (std::exception& except) {
if (*return_tuples) free(*return_tuples);
(*return_count) = 0;
*log_msg = strdup(log.str().c_str());
err << except.what() << "\n";
*err_msg = strdup(err.str().c_str());
} catch(...) {
if (*return_tuples) free(*return_tuples);
(*return_count) = 0;
*log_msg = strdup(log.str().c_str());
err << "Caught unknown exception!\n";
*err_msg = strdup(err.str().c_str());
}
}
bool
Optimize::swap_worse(size_t from_pos, size_t to_pos) {
pgassert(to_pos < from_pos);
auto from_truck = fleet[from_pos];
auto to_truck = fleet[to_pos];
auto swapped(false);
auto from_orders(from_truck.orders_in_vehicle);
auto to_orders(to_truck.orders_in_vehicle);
auto local_limit(from_orders.size() * to_orders.size() + 1);
while (!from_orders.empty() && --local_limit > 0) {
auto from_order(from_truck.get_worse_order(from_orders));
from_orders.erase(from_order.id());
while (!to_orders.empty()) {
auto to_order(to_truck.get_worse_order(to_orders));
to_orders.erase(to_order.id());
/*
* delete from_order, and to order from their trucks
*/
auto curr_from_duration(from_truck.duration());
auto curr_to_duration(to_truck.duration());
from_truck.erase(from_order);
to_truck.erase(to_order);
/*
* insert them in the other truck
*/
from_truck.insert(to_order);
to_truck.insert(from_order);
if (from_truck.is_feasable() && to_truck.is_feasable()) {
/*
* Can swap but:
* - only swap when the total duration is reduced
* - or from_truck duration is reduced
*/
if (((from_truck.duration() + to_truck.duration())
< (curr_from_duration + curr_to_duration))
|| (from_truck.duration() < curr_from_duration)) {
problem->log
<< "\n Swap order " << from_order.id()
<< " from truck " << from_truck.id()
<< " with order " << to_order.id() << " of truck " << to_truck.id();
#ifndef NDEBUG
problem->dbg_log << "\nswappping before:";
problem->dbg_log << "\n" << fleet[to_pos].tau();
problem->dbg_log << "\n" << fleet[from_pos].tau();
#endif
swap_order(from_order, fleet[from_pos], to_order, fleet[to_pos]);
swapped = true;
save_if_best();
from_orders.insert(to_order.id());
#ifndef NDEBUG
problem->dbg_log << "\nswappping after:";
problem->dbg_log << "\n" << fleet[to_pos].tau();
problem->dbg_log << "\n" << fleet[from_pos].tau();
#endif
break;
}
}
/*
* wasn't swapped
*/
to_truck = fleet[to_pos];
from_truck = fleet[from_pos];
}
}
return swapped;
}
void
do_pgr_connectedComponents(
pgr_edge_t *data_edges,
size_t total_edges,
pgr_components_rt **return_tuples,
size_t *return_count,
char ** log_msg,
char ** notice_msg,
char ** err_msg) {
std::ostringstream log;
std::ostringstream err;
std::ostringstream notice;
try {
pgassert(!(*log_msg));
pgassert(!(*notice_msg));
pgassert(!(*err_msg));
pgassert(!(*return_tuples));
pgassert(*return_count == 0);
pgassert(total_edges != 0);
graphType gType = UNDIRECTED;
std::vector<pgr_components_rt> results;
log << "Working with Undirected Graph\n";
pgrouting::ComponentsUndiGraph undigraph(gType);
undigraph.insert_edges(data_edges, total_edges);
results = pgr_connectedComponents(
undigraph);
auto count = results.size();
if (count == 0) {
(*return_tuples) = NULL;
(*return_count) = 0;
notice <<
"No paths found between start_vid and end_vid vertices";
return;
}
(*return_tuples) = pgr_alloc(count, (*return_tuples));
for (size_t i = 0; i < count; i++) {
*((*return_tuples) + i) = results[i];
}
(*return_count) = count;
pgassert(*err_msg == NULL);
*log_msg = log.str().empty()?
*log_msg :
pgr_msg(log.str().c_str());
*notice_msg = notice.str().empty()?
*notice_msg :
pgr_msg(notice.str().c_str());
} catch (AssertFailedException &except) {
(*return_tuples) = pgr_free(*return_tuples);
(*return_count) = 0;
err << except.what();
*err_msg = pgr_msg(err.str().c_str());
*log_msg = pgr_msg(log.str().c_str());
} catch (std::exception &except) {
(*return_tuples) = pgr_free(*return_tuples);
(*return_count) = 0;
err << except.what();
*err_msg = pgr_msg(err.str().c_str());
*log_msg = pgr_msg(log.str().c_str());
} catch(...) {
(*return_tuples) = pgr_free(*return_tuples);
(*return_count) = 0;
err << "Caught unknown exception!";
*err_msg = pgr_msg(err.str().c_str());
*log_msg = pgr_msg(log.str().c_str());
}
}
void
Initial_solution::invariant() const {
/* this checks there is no order duplicated */
pgassert(all_orders == (assigned + unassigned));
pgassert((assigned * unassigned).empty());
}
