Changeset 986:e997802b855c in lemon-0.x for src/work/jacint/max_save.h

Timestamp:

11/13/04 13:53:28 (19 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

File:

• src/work/jacint/max_save.h (modified) (23 diffs)

src/work/jacint/max_save.h

@@ -259 +259 @@
         OutEdgeIt e;
         for(g->first(e,w) ; g->valid(e); g->next(e)) {
-          Node v=g->head(e);
+          Node v=g->target(e);
           if (!M[v] && (*flow)[e] < (*capacity)[e] ) {
             queue.push(v);
@@ -268 +268 @@
         InEdgeIt f;
         for(g->first(f,w) ; g->valid(f); g->next(f)) {
-          Node v=g->tail(f);
+          Node v=g->source(f);
           if (!M[v] && (*flow)[f] > 0 ) {
             queue.push(v);
@@ -305 +305 @@
         InEdgeIt e;
         for(g->first(e,w) ; g->valid(e); g->next(e)) {
-          Node v=g->tail(e);
+          Node v=g->source(e);
           if (M[v] && (*flow)[e] < (*capacity)[e] ) {
             queue.push(v);
@@ -314 +314 @@
         OutEdgeIt f;
         for(g->first(f,w) ; g->valid(f); g->next(f)) {
-          Node v=g->head(f);
+          Node v=g->target(f);
           if (M[v] && (*flow)[f] > 0 ) {
             queue.push(v);
@@ -370 +370 @@
             
         if ( (*flow)[e] >= (*capacity)[e] ) continue; 
-        Node v=g->head(e);            
+        Node v=g->target(e);            
             
         if( lev > level[v] ) { //Push is allowed now
@@ -403 +403 @@
           
           if( (*flow)[e] <= 0 ) continue; 
-          Node v=g->tail(e); 
+          Node v=g->source(e); 
           
           if( lev > level[v] ) { //Push is allowed now
@@ -457 +457 @@
                                   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] == n && w != s ) {
                                       bfs_queue.push(w);
@@ -475 +475 @@
                                     Num c=(*capacity)[e];
                                     if ( c <= 0 ) continue;
-                                    Node w=g->head(e);
+                                    Node w=g->target(e);
                                     if ( level[w] < n ) {         
                                       if ( excess[w] <= 0 && w!=t ) active[level[w]].push(w);
@@ -502 +502 @@
                                   for(g->first(e,v); g->valid(e); g->next(e)) {
                                     if ( (*capacity)[e] <= (*flow)[e] ) continue;
-                                    Node w=g->tail(e);
+                                    Node w=g->source(e);
                                     if ( level[w] == n && w != s ) {
                                       bfs_queue.push(w);
@@ -516 +516 @@
                                   for(g->first(f,v); g->valid(f); g->next(f)) {
                                     if ( 0 >= (*flow)[f] ) continue;
-                                    Node w=g->head(f);
+                                    Node w=g->target(f);
                                     if ( level[w] == n && w != s ) {
                                       bfs_queue.push(w);
@@ -535 +535 @@
                                     Num rem=(*capacity)[e]-(*flow)[e];
                                     if ( rem <= 0 ) continue;
-                                    Node w=g->head(e);
+                                    Node w=g->target(e);
                                     if ( level[w] < n ) {         
                                       if ( excess[w] <= 0 && w!=t ) active[level[w]].push(w);
@@ -547 +547 @@
                                   {
                                     if ( (*flow)[f] <= 0 ) continue;
-                                    Node w=g->tail(f);
+                                    Node w=g->source(f);
                                     if ( level[w] < n ) {         
                                       if ( excess[w] <= 0 && w!=t ) active[level[w]].push(w);
@@ -645 +645 @@
       //        return dist[n]; }
       //       bool get(const typename MapGraphWrapper::Edge& e) const { 
-      //        return (dist.get(g->tail(e))<dist.get(g->head(e))); }
+      //        return (dist.get(g->source(e))<dist.get(g->target(e))); }
       bool operator[](const typename MapGraphWrapper::Edge& e) const { 
-        return (dist[g->tail(e)]<dist[g->head(e)]); 
+        return (dist[g->source(e)]<dist[g->target(e)]); 
       }
     };
@@ -784 +784 @@
       for(g->first(e,v); g->valid(e); g->next(e)) {
         if ( (*capacity)[e] <= (*flow)[e] ) continue;
-        Node u=g->tail(e);
+        Node u=g->source(e);
         if ( level[u] >= n ) { 
           bfs_queue.push(u);
@@ -795 +795 @@
       for(g->first(f,v); g->valid(f); g->next(f)) {
         if ( 0 >= (*flow)[f] ) continue;
-        Node u=g->head(f);
+        Node u=g->target(f);
         if ( level[u] >= n ) { 
           bfs_queue.push(u);
@@ -847 +847 @@
       ResGWOutEdgeIt e=bfs;
       if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-        Node v=res_graph.tail(e);
-        Node w=res_graph.head(e);
+        Node v=res_graph.source(e);
+        Node w=res_graph.target(e);
         pred.set(w, e);
         if (res_graph.valid(pred[v])) {
@@ -855 +855 @@
           free.set(w, res_graph.resCap(e)); 
         }
-        if (res_graph.head(e)==t) { _augment=true; break; }
+        if (res_graph.target(e)==t) { _augment=true; break; }
       }
         
@@ -867 +867 @@
         ResGWEdge e=pred[n];
         res_graph.augment(e, augment_value); 
-        n=res_graph.tail(e);
+        n=res_graph.source(e);
       }
     }
@@ -920 +920 @@
       if (res_graph.valid(e)) {
         if (bfs.isBNodeNewlyReached()) {
-          dist.set(res_graph.head(e), dist[res_graph.tail(e)]+1);
-          typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)], res_graph_to_F[res_graph.head(e)]);
+          dist.set(res_graph.target(e), dist[res_graph.source(e)]+1);
+          typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)], res_graph_to_F[res_graph.target(e)]);
           original_edge.update();
           original_edge.set(f, e);
@@ -927 +927 @@
           residual_capacity.set(f, res_graph.resCap(e));
         } else {
-          if (dist[res_graph.head(e)]==(dist[res_graph.tail(e)]+1)) {
-            typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)], res_graph_to_F[res_graph.head(e)]);
+          if (dist[res_graph.target(e)]==(dist[res_graph.source(e)]+1)) {
+            typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)], res_graph_to_F[res_graph.target(e)]);
             original_edge.update();
             original_edge.set(f, e);
@@ -982 +982 @@
           typename MG::Edge e=pred[n];
           res_graph.augment(original_edge[e], augment_value); 
-          n=F.tail(e);
+          n=F.source(e);
           if (residual_capacity[e]==augment_value) 
             F.erase(e); 
@@ -1016 +1016 @@
       ResGWOutEdgeIt e=bfs;
       if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-        dist.set(res_graph.head(e), dist[res_graph.tail(e)]+1);
+        dist.set(res_graph.target(e), dist[res_graph.source(e)]+1);
       }
       ++bfs;
@@ -1113 +1113 @@
           typename ErasingResGW::OutEdgeIt e=pred[n];
           res_graph.augment(e, augment_value);
-          n=erasing_res_graph.tail(e);
+          n=erasing_res_graph.source(e);
           if (res_graph.resCap(e)==0)
             erasing_res_graph.erase(e);