X-Git-Url: https://fleuret.org/cgi-bin/gitweb/gitweb.cgi?a=blobdiff_plain;f=mtp_graph.cc;h=682dd808e830eb4f36d99a02695d240fc3da3f50;hb=78b0bdef0b9a3479502c7598fd69a012c297e125;hp=ea8f91b93cd974e2c73a4e1dc08ac4bcca5f0bbb;hpb=8a3940ee003a04bac70679bdd7b3e2e8bc45ae37;p=mtp.git

diff --git a/mtp_graph.cc b/mtp_graph.cc
index ea8f91b..682dd80 100644
--- a/mtp_graph.cc
+++ b/mtp_graph.cc
@@ -202,44 +202,44 @@ int MTPGraph::compute_dp_ranks() {
   // 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];
+  Vertex **with_predecessor = new Vertex *[_nb_vertices];
 
-  // All the nodes are active at first
+  // All the nodes are with_predecessor at first
   for(int k = 0; k < _nb_vertices; k++) {
     _vertices[k].distance_from_source = 0;
-    active[k] = &_vertices[k];
+    with_predecessor[k] = &_vertices[k];
   }
 
   scalar_t rank = 1;
-  int nb_active = _nb_vertices, pred_nb_active;
+  int nb_with_predecessor = _nb_vertices, pred_nb_with_predecessor;
 
   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(int f = 0; f < nb_with_predecessor; f++) {
+      v = with_predecessor[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;
+    pred_nb_with_predecessor = nb_with_predecessor;
+    nb_with_predecessor = 0;
 
     // We keep all the vertices with incoming nodes
-    for(int f = 0; f < pred_nb_active; f++) {
-      v = active[f];
+    for(int f = 0; f < pred_nb_with_predecessor; f++) {
+      v = with_predecessor[f];
       if(v->distance_from_source == rank) {
-        active[nb_active++] = v;
+        with_predecessor[nb_with_predecessor++] = v;
       }
     }
 
     rank++;
-  } while(nb_active < pred_nb_active);
+  } while(nb_with_predecessor < pred_nb_with_predecessor);
 
-  delete[] active;
+  delete[] with_predecessor;
 
-  return nb_active == 0;
+  return nb_with_predecessor == 0;
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -300,7 +300,6 @@ void MTPGraph::force_positivized_lengths() {
     Edge *e = _edges + k;
 
     if(e->positivized_length < 0) {
-
 #ifdef VERBOSE
       residual_error -= e->positivized_length;
       max_error = max(max_error, - e->positivized_length);
@@ -333,7 +332,6 @@ void MTPGraph::dp_compute_distances() {
       if(d < tv->distance_from_source) {
         tv->distance_from_source = d;
         tv->pred_edge_toward_source = e;
-        tv->decrease_distance_in_heap(_heap);
       }
     }
   }
@@ -344,7 +342,7 @@ void MTPGraph::dp_compute_distances() {
 // pred_edge_toward_source.
 
 void MTPGraph::find_shortest_path() {
-  Vertex *v, *tv, **a, **b;
+  Vertex *v, *tv, **last_slot;
   Edge *e;
   scalar_t d;
 
@@ -361,15 +359,15 @@ void MTPGraph::find_shortest_path() {
     // Get the closest to the source
     v = _heap[0];
 
-    // Remove it from the heap (swap it with the last in the heap, and
+    // Remove it from the heap (swap it with the last_slot in the heap, and
     // update the distance of that one)
     _heap_size--;
-    a = _heap;
-    b = _heap + _heap_size;
-    swap(*a, *b); swap((*a)->heap_slot, (*b)->heap_slot);
+    last_slot = _heap + _heap_size;
+    swap(*_heap, *last_slot); swap((*_heap)->heap_slot, (*last_slot)->heap_slot);
     _heap[0]->increase_distance_in_heap(_heap, _heap + _heap_size);
 
-    // Now update the neighbors of the currently closest to the source
+    // Now update the neighbors of the node currently closest to the
+    // source
     for(e = v->leaving_edges; e; e = e->next_leaving_edge) {
       d = v->distance_from_source + e->positivized_length;
       tv = e->terminal_vertex;
@@ -384,7 +382,7 @@ void MTPGraph::find_shortest_path() {
 }
 
 void MTPGraph::find_best_paths(scalar_t *lengths) {
-  scalar_t total_length;
+  scalar_t shortest_path_length;
   Vertex *v;
   Edge *e;
 
@@ -394,7 +392,7 @@ void MTPGraph::find_best_paths(scalar_t *lengths) {
     _edges[e].positivized_length = _edges[e].length;
   }
 
-  // Compute the distance of every node from the source by just
+  // Compute the distance of all the nodes from the source by just
   // visiting them in the proper DAG ordering we computed when
   // building the graph
   dp_compute_distances();
@@ -408,7 +406,7 @@ void MTPGraph::find_best_paths(scalar_t *lengths) {
 
     find_shortest_path();
 
-    total_length = 0.0;
+    shortest_path_length = 0.0;
 
     // Do we reach the sink?
     if(_sink->pred_edge_toward_source) {
@@ -416,13 +414,13 @@ void MTPGraph::find_best_paths(scalar_t *lengths) {
       // original edge lengths
       v = _sink;
       while(v->pred_edge_toward_source) {
-        total_length += v->pred_edge_toward_source->length;
+        shortest_path_length += v->pred_edge_toward_source->length;
         v = v->pred_edge_toward_source->origin_vertex;
       }
       // If that length is negative
-      if(total_length < 0.0) {
+      if(shortest_path_length < 0.0) {
 #ifdef VERBOSE
-        cerr << __FILE__ << ": Found a path of length " << total_length << endl;
+        cerr << __FILE__ << ": Found a path of length " << shortest_path_length << endl;
 #endif
         // Invert all the edges along the best path
         v = _sink;
@@ -437,7 +435,7 @@ void MTPGraph::find_best_paths(scalar_t *lengths) {
       }
     }
 
-  } while(total_length < 0.0);
+  } while(shortest_path_length < 0.0);
 
   // Put back the graph in its original state (i.e. invert edges which
   // have been inverted in the process)