From: Francois Fleuret <francois@fleuret.org>
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;