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()); }