COIN-OR::LEMON - Graph Library

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


Ignore:
Timestamp:
11/13/04 13:53:28 (17 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:
1 edited

Legend:

Unmodified
Added
Removed
  • src/work/jacint/max_save.h

    r921 r986  
    259259        OutEdgeIt e;
    260260        for(g->first(e,w) ; g->valid(e); g->next(e)) {
    261           Node v=g->head(e);
     261          Node v=g->target(e);
    262262          if (!M[v] && (*flow)[e] < (*capacity)[e] ) {
    263263            queue.push(v);
     
    268268        InEdgeIt f;
    269269        for(g->first(f,w) ; g->valid(f); g->next(f)) {
    270           Node v=g->tail(f);
     270          Node v=g->source(f);
    271271          if (!M[v] && (*flow)[f] > 0 ) {
    272272            queue.push(v);
     
    305305        InEdgeIt e;
    306306        for(g->first(e,w) ; g->valid(e); g->next(e)) {
    307           Node v=g->tail(e);
     307          Node v=g->source(e);
    308308          if (M[v] && (*flow)[e] < (*capacity)[e] ) {
    309309            queue.push(v);
     
    314314        OutEdgeIt f;
    315315        for(g->first(f,w) ; g->valid(f); g->next(f)) {
    316           Node v=g->head(f);
     316          Node v=g->target(f);
    317317          if (M[v] && (*flow)[f] > 0 ) {
    318318            queue.push(v);
     
    370370           
    371371        if ( (*flow)[e] >= (*capacity)[e] ) continue;
    372         Node v=g->head(e);           
     372        Node v=g->target(e);           
    373373           
    374374        if( lev > level[v] ) { //Push is allowed now
     
    403403         
    404404          if( (*flow)[e] <= 0 ) continue;
    405           Node v=g->tail(e);
     405          Node v=g->source(e);
    406406         
    407407          if( lev > level[v] ) { //Push is allowed now
     
    457457                                  InEdgeIt e;
    458458                                  for(g->first(e,v); g->valid(e); g->next(e)) {
    459                                     Node w=g->tail(e);
     459                                    Node w=g->source(e);
    460460                                    if ( level[w] == n && w != s ) {
    461461                                      bfs_queue.push(w);
     
    475475                                    Num c=(*capacity)[e];
    476476                                    if ( c <= 0 ) continue;
    477                                     Node w=g->head(e);
     477                                    Node w=g->target(e);
    478478                                    if ( level[w] < n ) {         
    479479                                      if ( excess[w] <= 0 && w!=t ) active[level[w]].push(w);
     
    502502                                  for(g->first(e,v); g->valid(e); g->next(e)) {
    503503                                    if ( (*capacity)[e] <= (*flow)[e] ) continue;
    504                                     Node w=g->tail(e);
     504                                    Node w=g->source(e);
    505505                                    if ( level[w] == n && w != s ) {
    506506                                      bfs_queue.push(w);
     
    516516                                  for(g->first(f,v); g->valid(f); g->next(f)) {
    517517                                    if ( 0 >= (*flow)[f] ) continue;
    518                                     Node w=g->head(f);
     518                                    Node w=g->target(f);
    519519                                    if ( level[w] == n && w != s ) {
    520520                                      bfs_queue.push(w);
     
    535535                                    Num rem=(*capacity)[e]-(*flow)[e];
    536536                                    if ( rem <= 0 ) continue;
    537                                     Node w=g->head(e);
     537                                    Node w=g->target(e);
    538538                                    if ( level[w] < n ) {         
    539539                                      if ( excess[w] <= 0 && w!=t ) active[level[w]].push(w);
     
    547547                                  {
    548548                                    if ( (*flow)[f] <= 0 ) continue;
    549                                     Node w=g->tail(f);
     549                                    Node w=g->source(f);
    550550                                    if ( level[w] < n ) {         
    551551                                      if ( excess[w] <= 0 && w!=t ) active[level[w]].push(w);
     
    645645      //        return dist[n]; }
    646646      //       bool get(const typename MapGraphWrapper::Edge& e) const {
    647       //        return (dist.get(g->tail(e))<dist.get(g->head(e))); }
     647      //        return (dist.get(g->source(e))<dist.get(g->target(e))); }
    648648      bool operator[](const typename MapGraphWrapper::Edge& e) const {
    649         return (dist[g->tail(e)]<dist[g->head(e)]);
     649        return (dist[g->source(e)]<dist[g->target(e)]);
    650650      }
    651651    };
     
    784784      for(g->first(e,v); g->valid(e); g->next(e)) {
    785785        if ( (*capacity)[e] <= (*flow)[e] ) continue;
    786         Node u=g->tail(e);
     786        Node u=g->source(e);
    787787        if ( level[u] >= n ) {
    788788          bfs_queue.push(u);
     
    795795      for(g->first(f,v); g->valid(f); g->next(f)) {
    796796        if ( 0 >= (*flow)[f] ) continue;
    797         Node u=g->head(f);
     797        Node u=g->target(f);
    798798        if ( level[u] >= n ) {
    799799          bfs_queue.push(u);
     
    847847      ResGWOutEdgeIt e=bfs;
    848848      if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    849         Node v=res_graph.tail(e);
    850         Node w=res_graph.head(e);
     849        Node v=res_graph.source(e);
     850        Node w=res_graph.target(e);
    851851        pred.set(w, e);
    852852        if (res_graph.valid(pred[v])) {
     
    855855          free.set(w, res_graph.resCap(e));
    856856        }
    857         if (res_graph.head(e)==t) { _augment=true; break; }
     857        if (res_graph.target(e)==t) { _augment=true; break; }
    858858      }
    859859       
     
    867867        ResGWEdge e=pred[n];
    868868        res_graph.augment(e, augment_value);
    869         n=res_graph.tail(e);
     869        n=res_graph.source(e);
    870870      }
    871871    }
     
    920920      if (res_graph.valid(e)) {
    921921        if (bfs.isBNodeNewlyReached()) {
    922           dist.set(res_graph.head(e), dist[res_graph.tail(e)]+1);
    923           typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)], res_graph_to_F[res_graph.head(e)]);
     922          dist.set(res_graph.target(e), dist[res_graph.source(e)]+1);
     923          typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)], res_graph_to_F[res_graph.target(e)]);
    924924          original_edge.update();
    925925          original_edge.set(f, e);
     
    927927          residual_capacity.set(f, res_graph.resCap(e));
    928928        } else {
    929           if (dist[res_graph.head(e)]==(dist[res_graph.tail(e)]+1)) {
    930             typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)], res_graph_to_F[res_graph.head(e)]);
     929          if (dist[res_graph.target(e)]==(dist[res_graph.source(e)]+1)) {
     930            typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)], res_graph_to_F[res_graph.target(e)]);
    931931            original_edge.update();
    932932            original_edge.set(f, e);
     
    982982          typename MG::Edge e=pred[n];
    983983          res_graph.augment(original_edge[e], augment_value);
    984           n=F.tail(e);
     984          n=F.source(e);
    985985          if (residual_capacity[e]==augment_value)
    986986            F.erase(e);
     
    10161016      ResGWOutEdgeIt e=bfs;
    10171017      if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    1018         dist.set(res_graph.head(e), dist[res_graph.tail(e)]+1);
     1018        dist.set(res_graph.target(e), dist[res_graph.source(e)]+1);
    10191019      }
    10201020      ++bfs;
     
    11131113          typename ErasingResGW::OutEdgeIt e=pred[n];
    11141114          res_graph.augment(e, augment_value);
    1115           n=erasing_res_graph.tail(e);
     1115          n=erasing_res_graph.source(e);
    11161116          if (res_graph.resCap(e)==0)
    11171117            erasing_res_graph.erase(e);
Note: See TracChangeset for help on using the changeset viewer.