From: Francois Fleuret Date: Thu, 20 Dec 2012 08:37:22 +0000 (+0100) Subject: Cosmetics. X-Git-Url: https://fleuret.org/cgi-bin/gitweb/gitweb.cgi?a=commitdiff_plain;h=8a3940ee003a04bac70679bdd7b3e2e8bc45ae37;p=mtp.git Cosmetics. --- diff --git a/mtp_graph.cc b/mtp_graph.cc index 2832e71..ea8f91b 100644 --- a/mtp_graph.cc +++ b/mtp_graph.cc @@ -53,7 +53,7 @@ public: inline void add_leaving_edge(Edge *e); inline void del_leaving_edge(Edge *e); inline void decrease_distance_in_heap(Vertex **heap); - inline void increase_distance_in_heap(Vertex **heap, int heap_size); + inline void increase_distance_in_heap(Vertex **heap, Vertex **heap_bottom); }; ////////////////////////////////////////////////////////////////////// @@ -104,18 +104,18 @@ void Vertex::decrease_distance_in_heap(Vertex **heap) { } } -void Vertex::increase_distance_in_heap(Vertex **heap, int heap_size) { +void Vertex::increase_distance_in_heap(Vertex **heap, Vertex **heap_bottom) { Vertex **c1, **c2, **h; // omg, that's beautiful h = heap_slot; while(c1 = heap + 2 * (h - heap) + 1, - c1 < heap + heap_size && + c1 < heap_bottom && (c2 = c1 + 1, (*c1)->distance_from_source < (*h)->distance_from_source || - (c2 < heap + heap_size && (*c2)->distance_from_source < (*h)->distance_from_source) + (c2 < heap_bottom && (*c2)->distance_from_source < (*h)->distance_from_source) )) { - if(c2 < heap + heap_size && (*c2)->distance_from_source <= (*c1)->distance_from_source) { + if(c2 < heap_bottom && (*c2)->distance_from_source <= (*c1)->distance_from_source) { swap(*c2, *h); swap((*c2)->heap_slot, (*h)->heap_slot); h = c2; @@ -188,6 +188,60 @@ MTPGraph::~MTPGraph() { delete[] paths; } +int MTPGraph::compute_dp_ranks() { + Vertex *v; + Edge *e; + + // This procedure computes for each node the longest link from the + // source and abort if the graph is not a DAG. It works by removing + // successively nodes without predecessor: At the first iteration it + // removes the source, then the nodes with incoming edge only from + // the source, etc. If it can remove all the nodes that way, the + // graph is a DAG. If at some point it can not remove node anymore + // and there are some remaining nodes, the graph is not a DAG. The + // rank of a node is the iteration at which is it removed, and we + // set the distance_from_source fields to this value. + + Vertex **active = new Vertex *[_nb_vertices]; + + // All the nodes are active at first + for(int k = 0; k < _nb_vertices; k++) { + _vertices[k].distance_from_source = 0; + active[k] = &_vertices[k]; + } + + scalar_t rank = 1; + int nb_active = _nb_vertices, pred_nb_active; + + do { + // We set the distance_from_source field of all the vertices with incoming + // edges to the current rank value + for(int f = 0; f < nb_active; f++) { + v = active[f]; + for(e = v->leaving_edges; e; e = e->next_leaving_edge) { + e->terminal_vertex->distance_from_source = rank; + } + } + + pred_nb_active = nb_active; + nb_active = 0; + + // We keep all the vertices with incoming nodes + for(int f = 0; f < pred_nb_active; f++) { + v = active[f]; + if(v->distance_from_source == rank) { + active[nb_active++] = v; + } + } + + rank++; + } while(nb_active < pred_nb_active); + + delete[] active; + + return nb_active == 0; +} + ////////////////////////////////////////////////////////////////////// void MTPGraph::print(ostream *os) { @@ -259,60 +313,6 @@ void MTPGraph::force_positivized_lengths() { #endif } -int MTPGraph::compute_dp_ranks() { - Vertex *v; - Edge *e; - - // This procedure computes for each node the longest link from the - // source and abort if the graph is not a DAG. It works by removing - // successively nodes without predecessor: At the first iteration it - // removes the source, then the nodes with incoming edge only from - // the source, etc. If it can remove all the nodes that way, the - // graph is a DAG. If at some point it can not remove node anymore - // and there are some remaining nodes, the graph is not a DAG. The - // rank of a node is the iteration at which is it removed, and we - // set the distance_from_source fields to this value. - - Vertex **active = new Vertex *[_nb_vertices]; - - // All the nodes are active at first - for(int k = 0; k < _nb_vertices; k++) { - _vertices[k].distance_from_source = 0; - active[k] = &_vertices[k]; - } - - scalar_t rank = 1; - int nb_active = _nb_vertices, pred_nb_active; - - do { - // We set the distance_from_source field of all the vertices with incoming - // edges to the current rank value - for(int f = 0; f < nb_active; f++) { - v = active[f]; - for(e = v->leaving_edges; e; e = e->next_leaving_edge) { - e->terminal_vertex->distance_from_source = rank; - } - } - - pred_nb_active = nb_active; - nb_active = 0; - - // We keep all the vertices with incoming nodes - for(int f = 0; f < pred_nb_active; f++) { - v = active[f]; - if(v->distance_from_source == rank) { - active[nb_active++] = v; - } - } - - rank++; - } while(nb_active < pred_nb_active); - - delete[] active; - - return nb_active == 0; -} - void MTPGraph::dp_compute_distances() { Vertex *v, *tv; Edge *e; @@ -367,7 +367,7 @@ void MTPGraph::find_shortest_path() { a = _heap; b = _heap + _heap_size; swap(*a, *b); swap((*a)->heap_slot, (*b)->heap_slot); - _heap[0]->increase_distance_in_heap(_heap, _heap_size); + _heap[0]->increase_distance_in_heap(_heap, _heap + _heap_size); // Now update the neighbors of the currently closest to the source for(e = v->leaving_edges; e; e = e->next_leaving_edge) { @@ -394,12 +394,18 @@ void MTPGraph::find_best_paths(scalar_t *lengths) { _edges[e].positivized_length = _edges[e].length; } - // Update the distances to the source in "good order" + // Compute the distance of every node from the source by just + // visiting them in the proper DAG ordering we computed when + // building the graph dp_compute_distances(); do { + // Use the current distance from the source to make all edge + // lengths positive update_positivized_lengths(); + // Fix numerical errors force_positivized_lengths(); + find_shortest_path(); total_length = 0.0; diff --git a/mtp_graph.h b/mtp_graph.h index 883a67f..9f50ae4 100644 --- a/mtp_graph.h +++ b/mtp_graph.h @@ -37,6 +37,10 @@ class Vertex; class Edge; class MTPGraph { + // Set the distance_from_source fields to the number of DP + // iterations needed to update it. Abort if the graph is not a DAG. + int compute_dp_ranks(); + // Uses the estimated vertex distances to the source to make all the // edge lengths positive, resulting in an identical added value to // all the paths from the same initial node to the same final node @@ -49,7 +53,7 @@ class MTPGraph { // the total correction when compiled in VERBOSE mode. void force_positivized_lengths(); - // Visit the vertices according to _dp_order and simply update their + // Visit the vertices according to _dp_order and update their // distance from the source void dp_compute_distances(); @@ -63,10 +67,6 @@ class MTPGraph { // nodes met along the path, and computes path->length properly. int retrieve_one_path(Edge *e, Path *path); - // Set the distance_from_source fields to the number of DP - // iterations needed to update it. Abort if the graph is not a DAG. - int compute_dp_ranks(); - int _nb_vertices, _nb_edges; Vertex *_source, *_sink;