Changeset 986:e997802b855c in lemon-0.x for src/work/athos

Timestamp:

11/13/04 13:53:28 (20 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1376

Message:

Naming changes:

• head -> target
• tail -> source

Location:

src/work/athos

Files:

• bfs_test.cc (modified) (1 diff)
• dijkstra_demo.cc (modified) (1 diff)
• mincostflow.h (modified) (5 diffs)
• old/minlengthpaths.h (modified) (2 diffs)
• preflow_push_wogw.h (modified) (8 diffs)

src/work/athos/bfs_test.cc

@@ -42 +42 @@
       OutEdgeIt e;
       for(g.first(e,v); g.valid(e); g.next(e)) {
-        Node w=g.head(e);
+        Node w=g.target(e);
         if (!reached[w]) {
           bfs_queue.push(w);

src/work/athos/dijkstra_demo.cc

@@ -130 +130 @@
     std::cout << "out edges: ";
     for(out_edge_iterator j=flow_test.first_out_edge(i); j.valid(); ++j) 
-      std::cout << node_name.get(flow_test.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flow_test.head(j)) << " ";
+      std::cout << node_name.get(flow_test.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flow_test.target(j)) << " ";
     std::cout << "in edges: ";
     for(in_edge_iterator j=flow_test.first_in_edge(i); j.valid(); ++j) 
-      std::cout << node_name.get(flow_test.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flow_test.head(j)) << " ";
+      std::cout << node_name.get(flow_test.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flow_test.target(j)) << " ";
     std::cout << std::endl;
   }

src/work/athos/mincostflow.h

@@ -74 +74 @@
       ValueType operator[](typename ResGraph::Edge e) const {     
         if (res_graph.forward(e))
-          return  ol[e]-(pot[res_graph.head(e)]-pot[res_graph.tail(e)]);   
+          return  ol[e]-(pot[res_graph.target(e)]-pot[res_graph.source(e)]);   
         else
-          return -ol[e]-(pot[res_graph.head(e)]-pot[res_graph.tail(e)]);   
+          return -ol[e]-(pot[res_graph.target(e)]-pot[res_graph.source(e)]);   
       }     
         
@@ -259 +259 @@
           while ( i != nonabundant_arcs.end() ){
             if (flow[*i]>=buf){
-              Node a = abundant_components.find(res_graph.head(*i));
-              Node b = abundant_components.find(res_graph.tail(*i));
+              Node a = abundant_components.find(res_graph.target(*i));
+              Node b = abundant_components.find(res_graph.source(*i));
               //Merge
               if (a != b){
@@ -285 +285 @@
                   while (n!=non_root){
                     e = bfs_pred[n];
-                    n = res_graph.tail(e);
+                    n = res_graph.source(e);
                     res_graph.augment(e,qty_to_augment);
                   }
@@ -455 +455 @@
       FOR_EACH_LOC(typename Graph::EdgeIt, e, graph){
         //C^{\Pi}_{i,j}
-        mod_pot = cost[e]-potential[graph.head(e)]+potential[graph.tail(e)];
+        mod_pot = cost[e]-potential[graph.target(e)]+potential[graph.source(e)];
         fl_e = flow[e];
         //      std::cout << fl_e << std::endl;
@@ -484 +484 @@
           return false;
         }
-        supdem[graph.tail(e)] += flow[e];
-        supdem[graph.head(e)] -= flow[e];
+        supdem[graph.source(e)] += flow[e];
+        supdem[graph.target(e)] -= flow[e];
       }
       //write_property_vector(supdem, "supdem");

src/work/athos/old/minlengthpaths.h

@@ -54 +54 @@
         
       ValueType operator[](typename ResGraphType::Edge e) const {     
-        //if ( (1-2*rev[e])*ol[e]-(pot[G.head(e)]-pot[G.tail(e)] ) <0 ){
+        //if ( (1-2*rev[e])*ol[e]-(pot[G.target(e)]-pot[G.source(e)] ) <0 ){
         //  std::cout<<"Negative length!!"<<std::endl;
         //}
-        return (1-2*rev[e])*ol[e]-(pot[G.head(e)]-pot[G.tail(e)]);   
+        return (1-2*rev[e])*ol[e]-(pot[G.target(e)]-pot[G.source(e)]);   
       }     
         
@@ -162 +162 @@
             G.next(e);
           }
-          n = G.head(e);
+          n = G.target(e);
           paths[j].push_back(e);
           total_length += length[e];

src/work/athos/preflow_push_wogw.h

@@ -140 +140 @@
     //This private procedure is supposed to modify the preflow on edge j
     //by value v (which can be positive or negative as well) 
-    //and maintain the excess on the head and tail
+    //and maintain the excess on the target and source
     //Here we do not check whether this is possible or not
     void modify_preflow(Edge j, const T& v){
@@ -148 +148 @@
 
 
-      //Modifiyng the head
-      modify_excess(G.head(j),v);
-        
-      //Modifiyng the tail
-      modify_excess(G.tail(j),-v);
+      //Modifiyng the target
+      modify_excess(G.target(j),v);
+        
+      //Modifiyng the source
+      modify_excess(G.source(j),-v);
 
     }
@@ -273 +273 @@
         InEdgeIt e;
         for(G.first(e,v); G.valid(e); G.next(e)) {
-          Node w=G.tail(e);
+          Node w=G.source(e);
           if ( level[w] == number_of_nodes && w != s ) {
             bfs_queue.push(w);
@@ -311 +311 @@
       for(OutEdgeIt j=G.template first<OutEdgeIt>(s); G.valid(j); G.next(j)){ 
         modify_preflow(j,capacity[j] );
-        make_active(G.head(j));
-        int lev=level[G.head(j)];
+        make_active(G.target(j));
+        int lev=level[G.target(j)];
         if(highest_active<lev){
           highest_active=lev;
@@ -326 +326 @@
 
       if (capacity[j]>preflow[j]){
-        if(level[G.tail(j)]==level[G.head(j)]+1){
+        if(level[G.source(j)]==level[G.target(j)]+1){
           return true;
         }
         else{
-          if (level[G.head(j)] < new_level)
-            new_level=level[G.head(j)];
+          if (level[G.target(j)] < new_level)
+            new_level=level[G.target(j)];
         }
       }
@@ -342 +342 @@
       
       if (0<preflow[j]){
-        if(level[G.tail(j)]==level[G.head(j)]-1){
+        if(level[G.source(j)]==level[G.target(j)]-1){
          
           return true;
         }
         else{
-          if (level[G.tail(j)] < new_level)
-            new_level=level[G.tail(j)];
+          if (level[G.source(j)] < new_level)
+            new_level=level[G.source(j)];
         }
         
@@ -389 +389 @@
               e -= v;
               //New node might become active
-              if (excess[G.head(j)]==0){
-                make_active(G.head(j));
+              if (excess[G.target(j)]==0){
+                make_active(G.target(j));
               }
               modify_preflow(j,v);
@@ -405 +405 @@
               e -= v;
               //New node might become active
-              if (excess[G.tail(j)]==0){
-                make_active(G.tail(j));
+              if (excess[G.source(j)]==0){
+                make_active(G.source(j));
               }
               modify_preflow(j,-v);