COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

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


Ignore:
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/marci
Files:
31 edited

Legend:

Unmodified
Added
Removed

  • src/work/marci/augmenting_flow.h

    r970 r986  
    211211        OutEdgeIt e;
    212212        for(g->first(e,w) ; e!=INVALID; ++e) {
    213           Node v=g->head(e);
     213          Node v=g->target(e);
    214214          if (!M[v] && (*flow)[e] < (*capacity)[e] ) {
    215215            queue.push(v);
    … …  
    220220        InEdgeIt f;
    221221        for(g->first(f,w) ; f!=INVALID; ++f) {
    222           Node v=g->tail(f);
     222          Node v=g->source(f);
    223223          if (!M[v] && (*flow)[f] > 0 ) {
    224224            queue.push(v);
    … …  
    271271      ResGWEdge e=bfs;
    272272      if (e!=INVALID && bfs.isBNodeNewlyReached()) {
    273         Node v=res_graph.tail(e);
    274         Node w=res_graph.head(e);
     273        Node v=res_graph.source(e);
     274        Node w=res_graph.target(e);
    275275        pred.set(w, e);
    276276        if (pred[v]!=INVALID) {
    … …  
    279279          free.set(w, res_cap[e]);
    280280        }
    281         if (res_graph.head(e)==t) { _augment=true; break; }
     281        if (res_graph.target(e)==t) { _augment=true; break; }
    282282      }
    283283
    … …  
    291291        ResGWEdge e=pred[n];
    292292        res_graph.augment(e, augment_value);
    293         n=res_graph.tail(e);
     293        n=res_graph.source(e);
    294294      }
    295295    }
    … …  
    330330      ResGWEdge e=bfs;
    331331      if (e!=INVALID && bfs.isBNodeNewlyReached()) {
    332         Node v=res_graph.tail(e);
    333         Node w=res_graph.head(e);
     332        Node v=res_graph.source(e);
     333        Node w=res_graph.target(e);
    334334        pred.set(w, e);
    335335        if (pred[v]!=INVALID) {
    … …  
    338338          free.set(w, res_cap[e]);
    339339        }
    340         if (res_graph.head(e)==t) { _augment=true; break; }
     340        if (res_graph.target(e)==t) { _augment=true; break; }
    341341      }
    342342
    … …  
    350350        ResGWEdge e=pred[n];
    351351        res_graph.augment(e, augment_value);
    352         n=res_graph.tail(e);
     352        n=res_graph.source(e);
    353353      }
    354354    }
    … …  
    396396      if (e!=INVALID) {
    397397        if (bfs.isBNodeNewlyReached()) {
    398           dist.set(res_graph.head(e), dist[res_graph.tail(e)]+1);
    399           typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)],
    400                                         res_graph_to_F[res_graph.head(e)]);
     398          dist.set(res_graph.target(e), dist[res_graph.source(e)]+1);
     399          typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)],
     400                                        res_graph_to_F[res_graph.target(e)]);
    401401          //original_edge.update();
    402402          original_edge.set(f, e);
    … …  
    404404          residual_capacity.set(f, res_cap[e]);
    405405        } else {
    406           if (dist[res_graph.head(e)]==(dist[res_graph.tail(e)]+1)) {
    407             typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)],
    408                                           res_graph_to_F[res_graph.head(e)]);
     406          if (dist[res_graph.target(e)]==(dist[res_graph.source(e)]+1)) {
     407            typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)],
     408                                          res_graph_to_F[res_graph.target(e)]);
    409409            //original_edge.update();
    410410            original_edge.set(f, e);
    … …  
    434434        if (typename MG::Edge(dfs)!=INVALID) {
    435435          if (dfs.isBNodeNewlyReached()) {
    436             typename MG::Node v=F.tail(dfs);
    437             typename MG::Node w=F.head(dfs);
     436            typename MG::Node v=F.source(dfs);
     437            typename MG::Node w=F.target(dfs);
    438438            pred.set(w, dfs);
    439439            if (pred[v]!=INVALID) {
    … …  
    460460          typename MG::Edge e=pred[n];
    461461          res_graph.augment(original_edge[e], augment_value);
    462           n=F.tail(e);
     462          n=F.source(e);
    463463          if (residual_capacity[e]==augment_value)
    464464            F.erase(e);
    … …  
    499499      ResGWEdge e=bfs;
    500500      if (e!=INVALID && bfs.isBNodeNewlyReached())
    501         potential.set(res_graph.head(e), potential[res_graph.tail(e)]+1);
     501        potential.set(res_graph.target(e), potential[res_graph.source(e)]+1);
    502502      ++bfs;
    503503    }
    … …  
    554554          if (dfs.isBNodeNewlyReached()) {
    555555           
    556             typename ErasingResGW::Node v=erasing_res_graph.tail(dfs);
    557             typename ErasingResGW::Node w=erasing_res_graph.head(dfs);
     556            typename ErasingResGW::Node v=erasing_res_graph.source(dfs);
     557            typename ErasingResGW::Node w=erasing_res_graph.target(dfs);
    558558
    559559            pred.set(w, typename ErasingResGW::Edge(dfs));
    … …  
    586586          typename ErasingResGW::Edge e=pred[n];
    587587          res_graph.augment(e, augment_value);
    588           n=erasing_res_graph.tail(e);
     588          n=erasing_res_graph.source(e);
    589589          if (res_cap[e]==0)
    590590            erasing_res_graph.erase(e);

  • src/work/marci/bfs_dfs.h

    r921 r986  
    6464        //graph->first(actual_edge, s);
    6565        if (actual_edge!=INVALID) {
    66           Node w=graph->head(actual_edge);
     66          Node w=graph->target(actual_edge);
    6767          if (!reached[w]) {
    6868            bfs_queue.push(w);
    … …  
    8686        //++actual_edge;
    8787        if (actual_edge!=INVALID) {
    88           Node w=graph->head(actual_edge);
     88          Node w=graph->target(actual_edge);
    8989          if (!reached[w]) {
    9090            bfs_queue.push(w);
    … …  
    101101          //graph->first(actual_edge, bfs_queue.front());
    102102          if (actual_edge!=INVALID) {
    103             Node w=graph->head(actual_edge);
     103            Node w=graph->target(actual_edge);
    104104            if (!reached[w]) {
    105105              bfs_queue.push(w);
    … …  
    125125    bool isANodeExamined() const { return actual_edge==INVALID; }
    126126    /// Returns a-node of the actual edge, so does if the edge is invalid.
    127     Node tail() const { return bfs_queue.front(); }
     127    Node source() const { return bfs_queue.front(); }
    128128    /// \pre The actual edge have to be valid.
    129     Node head() const { return graph->head(actual_edge); }
     129    Node target() const { return graph->target(actual_edge); }
    130130    /// Guess what?
    131131    /// \deprecated
    … …  
    187187      if (this->graph->valid(this->actual_edge) && this->b_node_newly_reached)
    188188      {
    189         pred.set(this->head(), this->actual_edge);
    190         dist.set(this->head(), dist[this->tail()]);
     189        pred.set(this->target(), this->actual_edge);
     190        dist.set(this->target(), dist[this->source()]);
    191191      }
    192192      return *this;
    … …  
    247247      actual_edge=dfs_stack.top();
    248248      if (actual_edge!=INVALID/*.valid()*/) {
    249         Node w=graph->head(actual_edge);
     249        Node w=graph->target(actual_edge);
    250250        actual_node=w;
    251251        if (!reached[w]) {
    … …  
    256256          b_node_newly_reached=true;
    257257        } else {
    258           actual_node=graph->tail(actual_edge);
     258          actual_node=graph->source(actual_edge);
    259259          ++dfs_stack.top();
    260260          b_node_newly_reached=false;
    … …  
    277277    bool isANodeExamined() const { return actual_edge==INVALID; }
    278278    /// Returns a-node of the actual edge, so does if the edge is invalid.
    279     Node tail() const { return actual_node; /*FIXME*/}
     279    Node source() const { return actual_node; /*FIXME*/}
    280280    /// Returns b-node of the actual edge.
    281281    /// \pre The actual edge have to be valid.
    282     Node head() const { return graph->head(actual_edge); }
     282    Node target() const { return graph->target(actual_edge); }
    283283    /// Guess what?
    284284    /// \deprecated
    … …  
    334334      if (this->graph->valid(this->actual_edge) && this->b_node_newly_reached)
    335335      {
    336         pred.set(this->head(), this->actual_edge);
     336        pred.set(this->target(), this->actual_edge);
    337337      }
    338338      return *this;

  • src/work/marci/bfs_mm.h

    r944 r986  
    7272        //graph->first(actual_edge, s);
    7373        if (actual_edge!=INVALID) {
    74           Node w=graph->head(actual_edge);
     74          Node w=graph->target(actual_edge);
    7575          if (!(*reached_map)[w]) {
    7676            bfs_queue.push(w);
    … …  
    9494        //++actual_edge;
    9595        if (actual_edge!=INVALID) {
    96           Node w=graph->head(actual_edge);
     96          Node w=graph->target(actual_edge);
    9797          if (!(*reached_map)[w]) {
    9898            bfs_queue.push(w);
    … …  
    109109          //graph->first(actual_edge, bfs_queue.front());
    110110          if (actual_edge!=INVALID) {
    111             Node w=graph->head(actual_edge);
     111            Node w=graph->target(actual_edge);
    112112            if (!(*reached_map)[w]) {
    113113              bfs_queue.push(w);
    … …  
    133133    bool isANodeExamined() const { return actual_edge==INVALID; }
    134134    /// Returns a-node of the actual edge, so does if the edge is invalid.
    135     Node tail() const { return bfs_queue.front(); }
     135    Node source() const { return bfs_queue.front(); }
    136136    /// \pre The actual edge have to be valid.
    137     Node head() const { return graph->head(actual_edge); }
     137    Node target() const { return graph->target(actual_edge); }
    138138    /// Guess what?
    139139    /// \deprecated
    … …  
    232232      if ((this->actual_edge)!=INVALID && this->b_node_newly_reached)
    233233      {
    234         pred_map->set(this->head(), this->actual_edge);
    235         pred_node_map->set(this->head(), this->tail());
    236         dist_map->set(this->head(), (*dist_map)[this->tail()]);
     234        pred_map->set(this->target(), this->actual_edge);
     235        pred_node_map->set(this->target(), this->source());
     236        dist_map->set(this->target(), (*dist_map)[this->source()]);
    237237      }
    238238      return *this;
    … …  
    458458      actual_edge=dfs_stack.top();
    459459      if (actual_edge!=INVALID/*.valid()*/) {
    460         Node w=graph->head(actual_edge);
     460        Node w=graph->target(actual_edge);
    461461        actual_node=w;
    462462        if (!reached[w]) {
    … …  
    467467          b_node_newly_reached=true;
    468468        } else {
    469           actual_node=graph->tail(actual_edge);
     469          actual_node=graph->source(actual_edge);
    470470          ++dfs_stack.top();
    471471          b_node_newly_reached=false;
    … …  
    488488    bool isANodeExamined() const { return actual_edge==INVALID; }
    489489    /// Returns a-node of the actual edge, so does if the edge is invalid.
    490     Node tail() const { return actual_node; /*FIXME*/}
     490    Node source() const { return actual_node; /*FIXME*/}
    491491    /// Returns b-node of the actual edge.
    492492    /// \pre The actual edge have to be valid.
    493     Node head() const { return graph->head(actual_edge); }
     493    Node target() const { return graph->target(actual_edge); }
    494494    /// Guess what?
    495495    /// \deprecated
    … …  
    545545      if (this->graph->valid(this->actual_edge) && this->b_node_newly_reached)
    546546      {
    547         pred.set(this->head(), this->actual_edge);
     547        pred.set(this->target(), this->actual_edge);
    548548      }
    549549      return *this;

  • src/work/marci/bfs_mm_test.cc

    r959 r986  
    9292
    9393//   for(EdgeIt e(G); e==INVALID; ++e) {
    94 //     Node u=G.tail(e);
    95 //     Node v=G.head(e);
     94//     Node u=G.source(e);
     95//     Node v=G.target(e);
    9696//     check( !bfs_test.reached(u) ||
    9797//         (bfs_test.dist(v) > bfs_test.dist(u)+1),
    … …  
    103103//     if ( bfs_test.pred(v)!=INVALID ) {
    104104//       Edge e=bfs_test.pred(v);
    105 //       Node u=G.tail(e);
     105//       Node u=G.source(e);
    106106//       check(u==bfs_test.predNode(v),"Wrong tree.");
    107107//       check(bfs_test.dist(v) - bfs_test.dist(u) == 1,

  • src/work/marci/bfsit_vs_byhand.cc

    r944 r986  
    4949      bfs_queue.pop();
    5050      for(OutEdgeIt e(g,v); e!=INVALID; ++e) {
    51         Node w=g.head(e);
     51        Node w=g.target(e);
    5252        if (!reached[w]) {
    5353          bfs_queue.push(w);
    … …  
    7171      ++bfs;
    7272      if (Graph::Edge(bfs)!=INVALID && bfs.isBNodeNewlyReached())
    73         pred.set(bfs.head(), Graph::Edge(bfs));
     73        pred.set(bfs.target(), Graph::Edge(bfs));
    7474    }
    7575  }

  • src/work/marci/bipartite_graph_wrapper.h

    r921 r986  
    168168//     InEdgeIt& next(InEdgeIt& i) const { this->graph->next(i.e); return i; }
    169169
    170 //     Node tail(const Edge& e) {
    171 //       if (!(*(this->s_false_t_true_map))[this->graph->tail(e)])
    172 //      return Node(this->graph->tail(e));
     170//     Node source(const Edge& e) {
     171//       if (!(*(this->s_false_t_true_map))[this->graph->source(e)])
     172//      return Node(this->graph->source(e));
    173173//       else
    174 //      return Node(this->graph->head(e));     
    175 //     }
    176 //     Node head(const Edge& e) {
    177 //       if (!(*(this->s_false_t_true_map))[this->graph->tail(e)])
    178 //      return Node(this->graph->head(e));
     174//      return Node(this->graph->target(e));   
     175//     }
     176//     Node target(const Edge& e) {
     177//       if (!(*(this->s_false_t_true_map))[this->graph->source(e)])
     178//      return Node(this->graph->target(e));
    179179//       else
    180 //      return Node(this->graph->tail(e));     
     180//      return Node(this->graph->source(e));   
    181181//     }
    182182
    … …  
    253253
    254254    /// A new edge is inserted.
    255     ///\pre \c tail have to be in \c S_Class and \c head in \c T_Class.
    256     Edge addEdge(const Node& tail, const Node& head) {
    257       return Parent::graph->addEdge(tail, head);
     255    ///\pre \c source have to be in \c S_Class and \c target in \c T_Class.
     256    Edge addEdge(const Node& source, const Node& target) {
     257      return Parent::graph->addEdge(source, target);
    258258    }
    259259
    … …  
    696696    }   
    697697
    698     Node tail(const Edge& e) const {
     698    Node source(const Edge& e) const {
    699699      switch (e.spec) {
    700700      case 0:
    701         return Node(this->graph->tail(e));
     701        return Node(this->graph->source(e));
    702702        break;
    703703      case 1:
    … …  
    710710      }
    711711    }
    712     Node head(const Edge& e) const {
     712    Node target(const Edge& e) const {
    713713      switch (e.spec) {
    714714      case 0:
    715         return Node(this->graph->head(e));
     715        return Node(this->graph->target(e));
    716716        break;
    717717      case 1:
    … …  
    733733    }
    734734 
    735     Node aNode(const OutEdgeIt& e) const { return tail(e); }
    736     Node aNode(const InEdgeIt& e) const { return head(e); }
    737     Node bNode(const OutEdgeIt& e) const { return head(e); }
    738     Node bNode(const InEdgeIt& e) const { return tail(e); }
     735    Node aNode(const OutEdgeIt& e) const { return source(e); }
     736    Node aNode(const InEdgeIt& e) const { return target(e); }
     737    Node bNode(const OutEdgeIt& e) const { return target(e); }
     738    Node bNode(const InEdgeIt& e) const { return source(e); }
    739739
    740740    void addNode() const { }
    … …  
    742742   
    743743//    Node addNode() const { return Node(this->graph->addNode()); }
    744 //    Edge addEdge(const Node& tail, const Node& head) const {
    745 //      return Edge(this->graph->addEdge(tail, head)); }
     744//    Edge addEdge(const Node& source, const Node& target) const {
     745//      return Edge(this->graph->addEdge(source, target)); }
    746746
    747747//    void erase(const Node& i) const { this->graph->erase(i); }

  • src/work/marci/bipartite_graph_wrapper_test.cc

    r921 r986  
    8888  cout << "Edges of the bipartite graph:" << endl;
    8989  for (BGW::EdgeIt e(bgw); e!=INVALID; ++e)
    90     cout << g.id(bgw.tail(e)) << "->" << g.id(bgw.head(e)) << endl;
     90    cout << g.id(bgw.source(e)) << "->" << g.id(bgw.target(e)) << endl;
    9191
    9292  BGW::NodeMap<int> dbyj(bgw);

  • src/work/marci/experiment/edmonds_karp.h

    r921 r986  
    4141      //Edge(const Edge& e) : resG(e.resG), sym(e.sym) { }
    4242      Number free() const {
    43         if (resG->G.aNode(sym)==resG->G.tail(sym)) {
     43        if (resG->G.aNode(sym)==resG->G.source(sym)) {
    4444          return (resG->capacity.get(sym)-resG->flow.get(sym));
    4545        } else {
    … …  
    4949      bool valid() const { return sym.valid(); }
    5050      void augment(Number a) const {
    51         if (resG->G.aNode(sym)==resG->G.tail(sym)) {
     51        if (resG->G.aNode(sym)==resG->G.source(sym)) {
    5252          resG->flow.set(sym, resG->flow.get(sym)+a);
    5353          //resG->flow[sym]+=a;
    … …  
    9797    }
    9898
    99     Node tail(Edge e) const { return G.aNode(e.sym); }
    100     Node head(Edge e) const { return G.bNode(e.sym); }
     99    Node source(Edge e) const { return G.aNode(e.sym); }
     100    Node target(Edge e) const { return G.bNode(e.sym); }
    101101
    102102    Node aNode(OutEdgeIt e) const { return G.aNode(e.sym); }
    … …  
    224224    }
    225225
    226     Node tail(Edge e) const {
     226    Node source(Edge e) const {
    227227      return ((e.out_or_in) ? G.aNode(e.out) : G.aNode(e.in)); }
    228     Node head(Edge e) const {
     228    Node target(Edge e) const {
    229229      return ((e.out_or_in) ? G.bNode(e.out) : G.bNode(e.in)); }
    230230
    … …  
    288288        ResGWOutEdgeIt e=bfs;
    289289        if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    290           Node v=res_graph.tail(e);
    291           Node w=res_graph.head(e);
     290          Node v=res_graph.source(e);
     291          Node w=res_graph.target(e);
    292292          pred.set(w, e);
    293293          if (res_graph.valid(pred.get(v))) {
    … …  
    296296            free.set(w, res_graph.resCap(e));
    297297          }
    298           if (res_graph.head(e)==t) { _augment=true; break; }
     298          if (res_graph.target(e)==t) { _augment=true; break; }
    299299        }
    300300       
    … …  
    308308          ResGWEdge e=pred.get(n);
    309309          res_graph.augment(e, augment_value);
    310           n=res_graph.tail(e);
     310          n=res_graph.source(e);
    311311        }
    312312      }
    … …  
    325325      int get(const typename MapGraphWrapper::Node& n) const { return dist[n]; }
    326326      bool get(const typename MapGraphWrapper::Edge& e) const {
    327         return (dist.get(gw.tail(e))<dist.get(gw.head(e)));
     327        return (dist.get(gw.source(e))<dist.get(gw.target(e)));
    328328      }
    329329    };
    … …  
    344344        ResGWOutEdgeIt e=bfs;
    345345        if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    346           dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
     346          dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
    347347        }
    348348        ++bfs;
    … …  
    370370        typename FilterResGW::EdgeIt e;
    371371        for(filter_res_graph.first(e); filter_res_graph.valid(e); filter_res_graph.next(e)) {
    372           //if (dist.get(res_graph.head(e))==dist.get(res_graph.tail(e))+1) {
    373           typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
     372          //if (dist.get(res_graph.target(e))==dist.get(res_graph.source(e))+1) {
     373          typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
    374374          original_edge.update();
    375375          original_edge.set(f, e);
    … …  
    424424            typename MG::Edge e=pred.get(n);
    425425            res_graph.augment(original_edge.get(e), augment_value);
    426             n=F.tail(e);
     426            n=F.source(e);
    427427            if (residual_capacity.get(e)==augment_value)
    428428              F.erase(e);
    … …  
    469469        if (res_graph.valid(e)) {
    470470          if (bfs.isBNodeNewlyReached()) {
    471             dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
    472             typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
     471            dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
     472            typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
    473473            original_edge.update();
    474474            original_edge.set(f, e);
    … …  
    476476            residual_capacity.set(f, res_graph.resCap(e));
    477477          } else {
    478             if (dist.get(res_graph.head(e))==(dist.get(res_graph.tail(e))+1)) {
    479               typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
     478            if (dist.get(res_graph.target(e))==(dist.get(res_graph.source(e))+1)) {
     479              typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
    480480              original_edge.update();
    481481              original_edge.set(f, e);
    … …  
    532532            typename MG::Edge e=pred.get(n);
    533533            res_graph.augment(original_edge.get(e), augment_value);
    534             n=F.tail(e);
     534            n=F.source(e);
    535535            if (residual_capacity.get(e)==augment_value)
    536536              F.erase(e);
    … …  
    558558        ResGWOutEdgeIt e=bfs;
    559559        if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    560           dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
     560          dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
    561561        }
    562562        ++bfs;
    … …  
    634634            typename ErasingResGW::OutEdgeIt e=pred.get(n);
    635635            res_graph.augment(e, augment_value);
    636             n=erasing_res_graph.tail(e);
     636            n=erasing_res_graph.source(e);
    637637            if (res_graph.resCap(e)==0)
    638638              erasing_res_graph.erase(e);
    … …  
    669669//      typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::OutEdgeIt e=bfs;
    670670//      if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    671 //        dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
     671//        dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
    672672//      }
    673673//      ++bfs; 
    … …  
    723723//          EAugEdge e=pred.get(n);
    724724//          res_graph.augment(e, augment_value);
    725 //          n=res_graph.tail(e);
     725//          n=res_graph.source(e);
    726726//          if (res_graph.free(e)==0)
    727727//            res_graph.erase(e);
    … …  
    818818//      AugOutEdgeIt e=bfs;
    819819//      if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    820 //        Node v=res_graph.tail(e);
    821 //        Node w=res_graph.head(e);
     820//        Node v=res_graph.source(e);
     821//        Node w=res_graph.target(e);
    822822//        pred.set(w, e);
    823823//        if (res_graph.valid(pred.get(v))) {
    … …  
    826826//          free.set(w, res_graph.free(e));
    827827//        }
    828 //        n=res_graph.head(e);
     828//        n=res_graph.target(e);
    829829//        if (T->get(n) && (used.get(n)<1) ) {
    830830//          //Number u=0;
    … …  
    848848//        AugEdge e=pred.get(n);
    849849//        res_graph.augment(e, augment_value);
    850 //        n=res_graph.tail(e);
     850//        n=res_graph.source(e);
    851851//      }
    852852//      used.set(n, 1); //mind2 vegen jav
    … …  
    889889// //   AugOutEdgeIt e=bfs;
    890890// //   if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    891 // //     dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
     891// //     dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
    892892// //   }
    893893       
    … …  
    911911// //       //which are in some shortest paths
    912912// //       for(typename AugGraph::EdgeIt e=res_graph.template first<typename AugGraph::EdgeIt>(); res_graph.valid(e); res_graph.next(e)) {
    913 // //   if (dist.get(res_graph.head(e))==dist.get(res_graph.tail(e))+1) {
    914 // //     typename MutableGraph::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
     913// //   if (dist.get(res_graph.target(e))==dist.get(res_graph.source(e))+1) {
     914// //     typename MutableGraph::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
    915915// //     original_edge.update();
    916916// //     original_edge.set(f, e);
    … …  
    964964// //       typename MutableGraph::Edge e=pred.get(n);
    965965// //       res_graph.augment(original_edge.get(e), augment_value);
    966 // //       n=F.tail(e);
     966// //       n=F.source(e);
    967967// //       if (residual_capacity.get(e)==augment_value)
    968968// //         F.erase(e);
    … …  
    10151015//      typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::OutEdgeIt e=bfs;
    10161016//      if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    1017 //        dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
     1017//        dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
    10181018//      }
    10191019//      ++bfs; 
    … …  
    10921092//          EAugEdge e=pred.get(n);
    10931093//          res_graph.augment(e, augment_value);
    1094 //          n=res_graph.tail(e);
     1094//          n=res_graph.source(e);
    10951095//          if (res_graph.free(e)==0)
    10961096//            res_graph.erase(e);
    … …  
    11851185// //   AugOutEdgeIt e=/*AugOutEdgeIt*/(bfs);
    11861186// //   if (e.valid() && bfs.isBNodeNewlyReached()) {
    1187 // //     Node v=res_graph.tail(e);
    1188 // //     Node w=res_graph.head(e);
     1187// //     Node v=res_graph.source(e);
     1188// //     Node w=res_graph.target(e);
    11891189// //     pred.set(w, e);
    11901190// //     if (pred.get(v).valid()) {
    … …  
    11931193// //       free.set(w, e.free());
    11941194// //     }
    1195 // //     if (TMap.get(res_graph.head(e))) {
     1195// //     if (TMap.get(res_graph.target(e))) {
    11961196// //       _augment=true;
    1197 // //       reached_t_node=res_graph.head(e);
     1197// //       reached_t_node=res_graph.target(e);
    11981198// //       break;
    11991199// //     }
    … …  
    12091209// //     AugEdge e=pred.get(n);
    12101210// //     e.augment(augment_value);
    1211 // //     n=res_graph.tail(e);
     1211// //     n=res_graph.source(e);
    12121212// //   }
    12131213// //       }

  • src/work/marci/experiment/edmonds_karp_1.h

    r921 r986  
    4242      //Edge(const Edge& e) : resG(e.resG), sym(e.sym) { }
    4343      Number free() const {
    44         if (resG->G.aNode(sym)==resG->G.tail(sym)) {
     44        if (resG->G.aNode(sym)==resG->G.source(sym)) {
    4545          return (resG->capacity.get(sym)-resG->flow.get(sym));
    4646        } else {
    … …  
    5050      bool valid() const { return sym.valid(); }
    5151      void augment(Number a) const {
    52         if (resG->G.aNode(sym)==resG->G.tail(sym)) {
     52        if (resG->G.aNode(sym)==resG->G.source(sym)) {
    5353          resG->flow.set(sym, resG->flow.get(sym)+a);
    5454          //resG->flow[sym]+=a;
    … …  
    9898    }
    9999
    100     Node tail(Edge e) const { return G.aNode(e.sym); }
    101     Node head(Edge e) const { return G.bNode(e.sym); }
     100    Node source(Edge e) const { return G.aNode(e.sym); }
     101    Node target(Edge e) const { return G.bNode(e.sym); }
    102102
    103103    Node aNode(OutEdgeIt e) const { return G.aNode(e.sym); }
    … …  
    225225    }
    226226
    227     Node tail(Edge e) const {
     227    Node source(Edge e) const {
    228228      return ((e.out_or_in) ? G.aNode(e.out) : G.aNode(e.in)); }
    229     Node head(Edge e) const {
     229    Node target(Edge e) const {
    230230      return ((e.out_or_in) ? G.bNode(e.out) : G.bNode(e.in)); }
    231231
    … …  
    287287        ResGWOutEdgeIt e=bfs;
    288288        if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    289           Node v=res_graph.tail(e);
    290           Node w=res_graph.head(e);
     289          Node v=res_graph.source(e);
     290          Node w=res_graph.target(e);
    291291          pred.set(w, e);
    292292          if (res_graph.valid(pred.get(v))) {
    … …  
    295295            free.set(w, res_graph.resCap(e));
    296296          }
    297           if (res_graph.head(e)==t) { _augment=true; break; }
     297          if (res_graph.target(e)==t) { _augment=true; break; }
    298298        }
    299299       
    … …  
    307307          ResGWEdge e=pred.get(n);
    308308          res_graph.augment(e, augment_value);
    309           n=res_graph.tail(e);
     309          n=res_graph.source(e);
    310310        }
    311311      }
    … …  
    324324      int get(const typename MapGraphWrapper::Node& n) const { return dist[n]; }
    325325      bool get(const typename MapGraphWrapper::Edge& e) const {
    326         return (dist.get(g->tail(e))<dist.get(g->head(e)));
     326        return (dist.get(g->source(e))<dist.get(g->target(e)));
    327327      }
    328328    };
    … …  
    343343        ResGWOutEdgeIt e=bfs;
    344344        if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    345           dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
     345          dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
    346346        }
    347347        ++bfs;
    … …  
    369369        typename FilterResGW::EdgeIt e;
    370370        for(filter_res_graph.first(e); filter_res_graph.valid(e); filter_res_graph.next(e)) {
    371           //if (dist.get(res_graph.head(e))==dist.get(res_graph.tail(e))+1) {
    372           typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
     371          //if (dist.get(res_graph.target(e))==dist.get(res_graph.source(e))+1) {
     372          typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
    373373          original_edge.update();
    374374          original_edge.set(f, e);
    … …  
    423423            typename MG::Edge e=pred.get(n);
    424424            res_graph.augment(original_edge.get(e), augment_value);
    425             n=F.tail(e);
     425            n=F.source(e);
    426426            if (residual_capacity.get(e)==augment_value)
    427427              F.erase(e);
    … …  
    468468        if (res_graph.valid(e)) {
    469469          if (bfs.isBNodeNewlyReached()) {
    470             dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
    471             typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
     470            dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
     471            typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
    472472            original_edge.update();
    473473            original_edge.set(f, e);
    … …  
    475475            residual_capacity.set(f, res_graph.resCap(e));
    476476          } else {
    477             if (dist.get(res_graph.head(e))==(dist.get(res_graph.tail(e))+1)) {
    478               typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
     477            if (dist.get(res_graph.target(e))==(dist.get(res_graph.source(e))+1)) {
     478              typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
    479479              original_edge.update();
    480480              original_edge.set(f, e);
    … …  
    531531            typename MG::Edge e=pred.get(n);
    532532            res_graph.augment(original_edge.get(e), augment_value);
    533             n=F.tail(e);
     533            n=F.source(e);
    534534            if (residual_capacity.get(e)==augment_value)
    535535              F.erase(e);
    … …  
    557557        ResGWOutEdgeIt e=bfs;
    558558        if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    559           dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
     559          dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
    560560        }
    561561        ++bfs;
    … …  
    633633            typename ErasingResGW::OutEdgeIt e=pred.get(n);
    634634            res_graph.augment(e, augment_value);
    635             n=erasing_res_graph.tail(e);
     635            n=erasing_res_graph.source(e);
    636636            if (res_graph.resCap(e)==0)
    637637              erasing_res_graph.erase(e);
    … …  
    728728//      AugOutEdgeIt e=bfs;
    729729//      if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    730 //        Node v=res_graph.tail(e);
    731 //        Node w=res_graph.head(e);
     730//        Node v=res_graph.source(e);
     731//        Node w=res_graph.target(e);
    732732//        pred.set(w, e);
    733733//        if (res_graph.valid(pred.get(v))) {
    … …  
    736736//          free.set(w, res_graph.free(e));
    737737//        }
    738 //        n=res_graph.head(e);
     738//        n=res_graph.target(e);
    739739//        if (T->get(n) && (used.get(n)<1) ) {
    740740//          //Number u=0;
    … …  
    758758//        AugEdge e=pred.get(n);
    759759//        res_graph.augment(e, augment_value);
    760 //        n=res_graph.tail(e);
     760//        n=res_graph.source(e);
    761761//      }
    762762//      used.set(n, 1); //mind2 vegen jav
    … …  
    799799// //   AugOutEdgeIt e=bfs;
    800800// //   if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    801 // //     dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
     801// //     dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
    802802// //   }
    803803       
    … …  
    821821// //       //which are in some shortest paths
    822822// //       for(typename AugGraph::EdgeIt e=res_graph.template first<typename AugGraph::EdgeIt>(); res_graph.valid(e); res_graph.next(e)) {
    823 // //   if (dist.get(res_graph.head(e))==dist.get(res_graph.tail(e))+1) {
    824 // //     typename MutableGraph::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
     823// //   if (dist.get(res_graph.target(e))==dist.get(res_graph.source(e))+1) {
     824// //     typename MutableGraph::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
    825825// //     original_edge.update();
    826826// //     original_edge.set(f, e);
    … …  
    874874// //       typename MutableGraph::Edge e=pred.get(n);
    875875// //       res_graph.augment(original_edge.get(e), augment_value);
    876 // //       n=F.tail(e);
     876// //       n=F.source(e);
    877877// //       if (residual_capacity.get(e)==augment_value)
    878878// //         F.erase(e);
    … …  
    925925//      typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::OutEdgeIt e=bfs;
    926926//      if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    927 //        dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
     927//        dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
    928928//      }
    929929//      ++bfs; 
    … …  
    10021002//          EAugEdge e=pred.get(n);
    10031003//          res_graph.augment(e, augment_value);
    1004 //          n=res_graph.tail(e);
     1004//          n=res_graph.source(e);
    10051005//          if (res_graph.free(e)==0)
    10061006//            res_graph.erase(e);
    … …  
    10951095// //   AugOutEdgeIt e=/*AugOutEdgeIt*/(bfs);
    10961096// //   if (e.valid() && bfs.isBNodeNewlyReached()) {
    1097 // //     Node v=res_graph.tail(e);
    1098 // //     Node w=res_graph.head(e);
     1097// //     Node v=res_graph.source(e);
     1098// //     Node w=res_graph.target(e);
    10991099// //     pred.set(w, e);
    11001100// //     if (pred.get(v).valid()) {
    … …  
    11031103// //       free.set(w, e.free());
    11041104// //     }
    1105 // //     if (TMap.get(res_graph.head(e))) {
     1105// //     if (TMap.get(res_graph.target(e))) {
    11061106// //       _augment=true;
    1107 // //       reached_t_node=res_graph.head(e);
     1107// //       reached_t_node=res_graph.target(e);
    11081108// //       break;
    11091109// //     }
    … …  
    11191119// //     AugEdge e=pred.get(n);
    11201120// //     e.augment(augment_value);
    1121 // //     n=res_graph.tail(e);
     1121// //     n=res_graph.source(e);
    11221122// //   }
    11231123// //       }

  • src/work/marci/experiment/edmonds_karp_demo.cc

    r921 r986  
    105105    while (max_flow_test.augmentOnBlockingFlow<MutableGraph>()) {
    106106//     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) {
    107 //       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
    108 //     }
    109 //     std::cout<<std::endl;
    110       ++i;
    111     }
    112 
    113 //   std::cout << "maximum flow: "<< std::endl;
    114 //   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
    115 //     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
     107//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
     108//     }
     109//     std::cout<<std::endl;
     110      ++i;
     111    }
     112
     113//   std::cout << "maximum flow: "<< std::endl;
     114//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
     115//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
    116116//   }
    117117//   std::cout<<std::endl;
    … …  
    136136    while (max_flow_test.augmentOnBlockingFlow1<MutableGraph>()) {
    137137//     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) {
    138 //       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
    139 //     }
    140 //     std::cout<<std::endl;
    141       ++i;
    142     }
    143 
    144 //   std::cout << "maximum flow: "<< std::endl;
    145 //   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
    146 //     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
     138//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
     139//     }
     140//     std::cout<<std::endl;
     141      ++i;
     142    }
     143
     144//   std::cout << "maximum flow: "<< std::endl;
     145//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
     146//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
    147147//   }
    148148//   std::cout<<std::endl;
    … …  
    167167    while (max_flow_test.augmentOnBlockingFlow2()) {
    168168//     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) {
    169 //       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
    170 //     }
    171 //     std::cout<<std::endl;
    172       ++i;
    173     }
    174 
    175 //   std::cout << "maximum flow: "<< std::endl;
    176 //   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
    177 //     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
     169//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
     170//     }
     171//     std::cout<<std::endl;
     172      ++i;
     173    }
     174
     175//   std::cout << "maximum flow: "<< std::endl;
     176//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
     177//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
    178178//   }
    179179//   std::cout<<std::endl;
    … …  
    198198    while (max_flow_test.augmentOnShortestPath()) {
    199199//     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) {
    200 //       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
    201 //     }
    202 //     std::cout<<std::endl;
    203       ++i;
    204     }
    205 
    206 //   std::cout << "maximum flow: "<< std::endl;
    207 //   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
    208 //     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
     200//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
     201//     }
     202//     std::cout<<std::endl;
     203      ++i;
     204    }
     205
     206//   std::cout << "maximum flow: "<< std::endl;
     207//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
     208//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
    209209//   }
    210210//   std::cout<<std::endl;

  • src/work/marci/experiment/edmonds_karp_demo_1.cc

    r921 r986  
    105105    while (max_flow_test.augmentOnBlockingFlow<MutableGraph>()) {
    106106//     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) {
    107 //       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
    108 //     }
    109 //     std::cout<<std::endl;
    110       ++i;
    111     }
    112 
    113 //   std::cout << "maximum flow: "<< std::endl;
    114 //   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
    115 //     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
     107//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
     108//     }
     109//     std::cout<<std::endl;
     110      ++i;
     111    }
     112
     113//   std::cout << "maximum flow: "<< std::endl;
     114//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
     115//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
    116116//   }
    117117//   std::cout<<std::endl;
    … …  
    136136    while (max_flow_test.augmentOnBlockingFlow1<MutableGraph>()) {
    137137//     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) {
    138 //       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
    139 //     }
    140 //     std::cout<<std::endl;
    141       ++i;
    142     }
    143 
    144 //   std::cout << "maximum flow: "<< std::endl;
    145 //   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
    146 //     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
     138//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
     139//     }
     140//     std::cout<<std::endl;
     141      ++i;
     142    }
     143
     144//   std::cout << "maximum flow: "<< std::endl;
     145//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
     146//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
    147147//   }
    148148//   std::cout<<std::endl;
    … …  
    167167    while (max_flow_test.augmentOnBlockingFlow2()) {
    168168//     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) {
    169 //       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
    170 //     }
    171 //     std::cout<<std::endl;
    172       ++i;
    173     }
    174 
    175 //   std::cout << "maximum flow: "<< std::endl;
    176 //   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
    177 //     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
     169//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
     170//     }
     171//     std::cout<<std::endl;
     172      ++i;
     173    }
     174
     175//   std::cout << "maximum flow: "<< std::endl;
     176//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
     177//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
    178178//   }
    179179//   std::cout<<std::endl;
    … …  
    198198    while (max_flow_test.augmentOnShortestPath()) {
    199199//     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) {
    200 //       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
    201 //     }
    202 //     std::cout<<std::endl;
    203       ++i;
    204     }
    205 
    206 //   std::cout << "maximum flow: "<< std::endl;
    207 //   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
    208 //     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
     200//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
     201//     }
     202//     std::cout<<std::endl;
     203      ++i;
     204    }
     205
     206//   std::cout << "maximum flow: "<< std::endl;
     207//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
     208//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
    209209//   }
    210210//   std::cout<<std::endl;

  • src/work/marci/experiment/graph_wrapper.h

    r921 r986  
    9797      It e; first(e, v); return e; }
    9898
    99     Node head(const Edge& e) const { return graph->head(e); }
    100     Node tail(const Edge& e) const { return graph->tail(e); }
     99    Node target(const Edge& e) const { return graph->target(e); }
     100    Node source(const Edge& e) const { return graph->source(e); }
    101101
    102102    template<typename I> bool valid(const I& i) const
    … …  
    115115 
    116116    Node addNode() const { return graph->addNode(); }
    117     Edge addEdge(const Node& tail, const Node& head) const {
    118       return graph->addEdge(tail, head); }
     117    Edge addEdge(const Node& source, const Node& target) const {
     118      return graph->addEdge(source, target); }
    119119 
    120120    template<typename I> void erase(const I& i) const { graph->erase(i); }
    … …  
    246246      It e; this->first(e, v); return e; }
    247247
    248     Node head(const Edge& e) const { return gw.head(e); }
    249     Node tail(const Edge& e) const { return gw.tail(e); }
     248    Node target(const Edge& e) const { return gw.target(e); }
     249    Node source(const Edge& e) const { return gw.source(e); }
    250250
    251251    template<typename I> bool valid(const I& i) const { return gw.valid(i); }
    … …  
    261261 
    262262    Node addNode() const { return gw.addNode(); }
    263     Edge addEdge(const Node& tail, const Node& head) const {
    264       return gw.addEdge(tail, head); }
     263    Edge addEdge(const Node& source, const Node& target) const {
     264      return gw.addEdge(source, target); }
    265265 
    266266    template<typename I> void erase(const I& i) const { gw.erase(i); }
    … …  
    323323//       It e; first(e, v); return e; }
    324324
    325 //     Node head(const Edge& e) const { return graph->tail(e); }
    326 //     Node tail(const Edge& e) const { return graph->head(e); }
     325//     Node target(const Edge& e) const { return graph->source(e); }
     326//     Node source(const Edge& e) const { return graph->target(e); }
    327327 
    328328//     template<typename I> bool valid(const I& i) const
    … …  
    338338
    339339//     Node addNode() const { return graph->addNode(); }
    340 //     Edge addEdge(const Node& tail, const Node& head) const {
    341 //       return graph->addEdge(tail, head); }
     340//     Edge addEdge(const Node& source, const Node& target) const {
     341//       return graph->addEdge(source, target); }
    342342 
    343343//     int nodeNum() const { return graph->nodeNum(); }
    … …  
    404404//     //  It e; first(e, v); return e; }
    405405
    406 //     //Node head(const Edge& e) const { return graph->tail(e); }
    407 //     //Node tail(const Edge& e) const { return graph->head(e); }
     406//     //Node target(const Edge& e) const { return graph->source(e); }
     407//     //Node source(const Edge& e) const { return graph->target(e); }
    408408 
    409409//     //template<typename I> bool valid(const I& i) const
    … …  
    419419
    420420//     //Node addNode() const { return graph->addNode(); }
    421 //     //Edge addEdge(const Node& tail, const Node& head) const {
    422 //     //  return graph->addEdge(tail, head); }
     421//     //Edge addEdge(const Node& source, const Node& target) const {
     422//     //  return graph->addEdge(source, target); }
    423423 
    424424//     //int nodeNum() const { return graph->nodeNum(); }
    … …  
    468468      GraphWrapper<GraphWrapper>(_gw) { } 
    469469
    470     Node head(const Edge& e) const
    471       { return GraphWrapper<GraphWrapper>::tail(e); }
    472     Node tail(const Edge& e) const
    473       { return GraphWrapper<GraphWrapper>::head(e); }
     470    Node target(const Edge& e) const
     471      { return GraphWrapper<GraphWrapper>::source(e); }
     472    Node source(const Edge& e) const
     473      { return GraphWrapper<GraphWrapper>::target(e); }
    474474  };
    475475
    … …  
    600600//     OutEdgeIt& next(OutEdgeIt& e) const {
    601601//       if (e.out_or_in) {
    602 //      Node n=gw.tail(e.out);
     602//      Node n=gw.source(e.out);
    603603//      gw.next(e.out);
    604604//      if (!gw.valid(e.out)) {
    … …  
    613613
    614614//     Node aNode(const OutEdgeIt& e) const {
    615 //       if (e.out_or_in) return gw.tail(e); else return gw.head(e); }
     615//       if (e.out_or_in) return gw.source(e); else return gw.target(e); }
    616616//     Node bNode(const OutEdgeIt& e) const {
    617 //       if (e.out_or_in) return gw.head(e); else return gw.tail(e); }
     617//       if (e.out_or_in) return gw.target(e); else return gw.source(e); }
    618618
    619619//     typedef OutEdgeIt InEdgeIt;
    … …  
    633633//       It e; first(e, v); return e; }
    634634
    635 //     Node head(const Edge& e) const { return gw.head(e); }
    636 //     Node tail(const Edge& e) const { return gw.tail(e); }
     635//     Node target(const Edge& e) const { return gw.target(e); }
     636//     Node source(const Edge& e) const { return gw.source(e); }
    637637
    638638//     template<typename I> bool valid(const I& i) const
    … …  
    652652//     Node addNode() const { return gw.addNode(); }
    653653// // FIXME: ez igy nem jo, mert nem
    654 // //    Edge addEdge(const Node& tail, const Node& head) const {
    655 // //      return graph->addEdge(tail, head); }
     654// //    Edge addEdge(const Node& source, const Node& target) const {
     655// //      return graph->addEdge(source, target); }
    656656 
    657657//     template<typename I> void erase(const I& i) const { gw.erase(i); }
    … …  
    799799    OutEdgeIt& next(OutEdgeIt& e) const {
    800800      if (e.out_or_in) {
    801         Node n=gw.tail(e.out);
     801        Node n=gw.source(e.out);
    802802        gw.next(e.out);
    803803        if (!gw.valid(e.out)) { e.out_or_in=false; gw.first(e.in, n); }
    … …  
    809809
    810810    EdgeIt& next(EdgeIt& e) const {
    811       //NodeIt v=tail(e);
     811      //NodeIt v=source(e);
    812812      gw.next(e.out);
    813813      while (valid(e.v) && !gw.valid(e.out)) {
    … …  
    827827      It e; first(e, v); return e; }
    828828
    829 //    Node head(const Edge& e) const { return gw.head(e); }
    830 //    Node tail(const Edge& e) const { return gw.tail(e); }
     829//    Node target(const Edge& e) const { return gw.target(e); }
     830//    Node source(const Edge& e) const { return gw.source(e); }
    831831
    832832//    template<typename I> bool valid(const I& i) const
    … …  
    842842
    843843    Node aNode(const OutEdgeIt& e) const {
    844       if (e.out_or_in) return gw.tail(e); else return gw.head(e); }
     844      if (e.out_or_in) return gw.source(e); else return gw.target(e); }
    845845    Node bNode(const OutEdgeIt& e) const {
    846       if (e.out_or_in) return gw.head(e); else return gw.tail(e); }
     846      if (e.out_or_in) return gw.target(e); else return gw.source(e); }
    847847 
    848848//    Node addNode() const { return gw.addNode(); }
    849849
    850850// FIXME: ez igy nem jo, mert nem
    851 //    Edge addEdge(const Node& tail, const Node& head) const {
    852 //      return graph->addEdge(tail, head); }
     851//    Edge addEdge(const Node& source, const Node& target) const {
     852//      return graph->addEdge(source, target); }
    853853 
    854854//    template<typename I> void erase(const I& i) const { gw.erase(i); }
    … …  
    914914//       It e; first(e, v); return e; }
    915915
    916 //     Node head(const Edge& e) const { return graph->head(e); }
    917 //     Node tail(const Edge& e) const { return graph->tail(e); }
     916//     Node target(const Edge& e) const { return graph->target(e); }
     917//     Node source(const Edge& e) const { return graph->source(e); }
    918918 
    919919//     template<typename I> Node aNode(const I& e) const {
    … …  
    929929 
    930930//     Node addNode() { return graph->addNode(); }
    931 //     Edge addEdge(const Node& tail, const Node& head) {
    932 //       return graph->addEdge(tail, head); }
     931//     Edge addEdge(const Node& source, const Node& target) {
     932//       return graph->addEdge(source, target); }
    933933 
    934934//     template<typename I> void erase(const I& i) { graph->erase(i); }
    … …  
    11811181    }
    11821182
    1183     Node tail(Edge e) const {
     1183    Node source(Edge e) const {
    11841184      return ((e.out_or_in) ? gw.aNode(e.out) : gw.aNode(e.in)); }
    1185     Node head(Edge e) const {
     1185    Node target(Edge e) const {
    11861186      return ((e.out_or_in) ? gw.bNode(e.out) : gw.bNode(e.in)); }
    11871187
    … …  
    13121312      OutEdgeIt f=e;
    13131313      this->next(f);
    1314       first_out_edges->set(this->tail(e), f);
     1314      first_out_edges->set(this->source(e), f);
    13151315    }
    13161316  };
    … …  
    13821382//       It e; first(e, v); return e; }
    13831383
    1384 //     //Node head(const Edge& e) const { return gw.head(e); }
    1385 //     //Node tail(const Edge& e) const { return gw.tail(e); }
     1384//     //Node target(const Edge& e) const { return gw.target(e); }
     1385//     //Node source(const Edge& e) const { return gw.source(e); }
    13861386
    13871387//     //template<typename I> bool valid(const I& i) const
    … …  
    13971397 
    13981398//     //Node addNode() const { return gw.addNode(); }
    1399 //     //Edge addEdge(const Node& tail, const Node& head) const {
    1400 //     //  return gw.addEdge(tail, head); }
     1399//     //Edge addEdge(const Node& source, const Node& target) const {
     1400//     //  return gw.addEdge(source, target); }
    14011401 
    14021402//     //void erase(const OutEdgeIt& e) {
    1403 //     //  first_out_edge(this->tail(e))=e;
     1403//     //  first_out_edge(this->source(e))=e;
    14041404//     //}
    14051405//     void erase(const Edge& e) {
    14061406//       OutEdgeIt f(e);
    14071407//       next(f);
    1408 //       first_out_edges.set(this->tail(e), f);
     1408//       first_out_edges.set(this->source(e), f);
    14091409//     }
    14101410//     //template<typename I> void erase(const I& i) const { gw.erase(i); }
    … …  
    14601460//     OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
    14611461//       ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::first(e, n);
    1462 //       while (valid(e) && (dist.get(tail(e))/*+1!=*/>=dist.get(head(e))))
     1462//       while (valid(e) && (dist.get(source(e))/*+1!=*/>=dist.get(target(e))))
    14631463//      ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(e);
    14641464//       return e;
    … …  
    14711471//     OutEdgeIt& next(OutEdgeIt& e) const {
    14721472//       ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(e);
    1473 //       while (valid(e) && (dist.get(tail(e))/*+1!*/>=dist.get(head(e))))
     1473//       while (valid(e) && (dist.get(source(e))/*+1!*/>=dist.get(target(e))))
    14741474//      ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(e);
    14751475//       return e;
    … …  
    14831483//       OutEdgeIt f(e);
    14841484//       ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(f);
    1485 //       while (valid(f) && (dist.get(tail(f))/*+1!=*/>=dist.get(head(f))))
     1485//       while (valid(f) && (dist.get(source(f))/*+1!=*/>=dist.get(target(f))))
    14861486//      ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(f);
    1487 //       first_out_edges.set(this->tail(e), f);
     1487//       first_out_edges.set(this->source(e), f);
    14881488//     }
    14891489
    … …  
    15081508//       It e; first(e, v); return e; }
    15091509
    1510 //     //Node head(const Edge& e) const { return gw.head(e); }
    1511 //     //Node tail(const Edge& e) const { return gw.tail(e); }
     1510//     //Node target(const Edge& e) const { return gw.target(e); }
     1511//     //Node source(const Edge& e) const { return gw.source(e); }
    15121512
    15131513//     //template<typename I> bool valid(const I& i) const
    … …  
    15261526 
    15271527//     //Node addNode() const { return gw.addNode(); }
    1528 //     //Edge addEdge(const Node& tail, const Node& head) const {
    1529 //     //  return gw.addEdge(tail, head); }
     1528//     //Edge addEdge(const Node& source, const Node& target) const {
     1529//     //  return gw.addEdge(source, target); }
    15301530 
    15311531//     //template<typename I> void erase(const I& i) const { gw.erase(i); }
    … …  
    16701670//       It e; first(e, v); return e; }
    16711671
    1672 //     Node head(const Edge& e) const { return gw.head(e); }
    1673 //     Node tail(const Edge& e) const { return gw.tail(e); }
     1672//     Node target(const Edge& e) const { return gw.target(e); }
     1673//     Node source(const Edge& e) const { return gw.source(e); }
    16741674 
    16751675//     template<typename I> Node aNode(const I& e) const {
    … …  
    16851685 
    16861686//     Node addNode() { return gw.addNode(); }
    1687 //     Edge addEdge(const Node& tail, const Node& head) {
    1688 //       return gw.addEdge(tail, head); }
     1687//     Edge addEdge(const Node& source, const Node& target) {
     1688//       return gw.addEdge(source, target); }
    16891689 
    16901690//     template<typename I> void erase(const I& i) { gw.erase(i); }

  • src/work/marci/experiment/graph_wrapper_1.h

    r921 r986  
    9191      It e; this->first(e, v); return e; }
    9292
    93     Node head(const Edge& e) const { return graph->head(e); }
    94     Node tail(const Edge& e) const { return graph->tail(e); }
     93    Node target(const Edge& e) const { return graph->target(e); }
     94    Node source(const Edge& e) const { return graph->source(e); }
    9595
    9696    template<typename I> bool valid(const I& i) const {
    … …  
    109109 
    110110    Node addNode() const { return graph->addNode(); }
    111     Edge addEdge(const Node& tail, const Node& head) const {
    112       return graph->addEdge(tail, head); }
     111    Edge addEdge(const Node& source, const Node& target) const {
     112      return graph->addEdge(source, target); }
    113113 
    114114    template<typename I> void erase(const I& i) const { graph->erase(i); }
    … …  
    236236      It e; this->first(e, v); return e; }
    237237
    238     Node head(const Edge& e) const { return graph->head(e); }
    239     Node tail(const Edge& e) const { return graph->tail(e); }
     238    Node target(const Edge& e) const { return graph->target(e); }
     239    Node source(const Edge& e) const { return graph->source(e); }
    240240
    241241    template<typename I> bool valid(const I& i) const {
    … …  
    254254 
    255255    Node addNode() const { return graph->addNode(); }
    256     Edge addEdge(const Node& tail, const Node& head) const {
    257       return graph->addEdge(tail, head); }
     256    Edge addEdge(const Node& source, const Node& target) const {
     257      return graph->addEdge(source, target); }
    258258 
    259259    template<typename I> void erase(const I& i) const { graph->erase(i); }
    … …  
    317317//       It e; first(e, v); return e; }
    318318
    319 //     Node head(const Edge& e) const { return graph->tail(e); }
    320 //     Node tail(const Edge& e) const { return graph->head(e); }
     319//     Node target(const Edge& e) const { return graph->source(e); }
     320//     Node source(const Edge& e) const { return graph->target(e); }
    321321 
    322322//     template<typename I> bool valid(const I& i) const
    … …  
    332332
    333333//     Node addNode() const { return graph->addNode(); }
    334 //     Edge addEdge(const Node& tail, const Node& head) const {
    335 //       return graph->addEdge(tail, head); }
     334//     Edge addEdge(const Node& source, const Node& target) const {
     335//       return graph->addEdge(source, target); }
    336336 
    337337//     int nodeNum() const { return graph->nodeNum(); }
    … …  
    379379    RevGraphWrapper(Graph& _graph) : GraphWrapper<Graph>(_graph) { } 
    380380
    381     Node head(const Edge& e) const
    382       { return GraphWrapper<Graph>::tail(e); }
    383     Node tail(const Edge& e) const
    384       { return GraphWrapper<Graph>::head(e); }
     381    Node target(const Edge& e) const
     382      { return GraphWrapper<Graph>::source(e); }
     383    Node source(const Edge& e) const
     384      { return GraphWrapper<Graph>::target(e); }
    385385  };
    386386
    … …  
    512512//     OutEdgeIt& next(OutEdgeIt& e) const {
    513513//       if (e.out_or_in) {
    514 //      Node n=gw.tail(e.out);
     514//      Node n=gw.source(e.out);
    515515//      gw.next(e.out);
    516516//      if (!gw.valid(e.out)) {
    … …  
    525525
    526526//     Node aNode(const OutEdgeIt& e) const {
    527 //       if (e.out_or_in) return gw.tail(e); else return gw.head(e); }
     527//       if (e.out_or_in) return gw.source(e); else return gw.target(e); }
    528528//     Node bNode(const OutEdgeIt& e) const {
    529 //       if (e.out_or_in) return gw.head(e); else return gw.tail(e); }
     529//       if (e.out_or_in) return gw.target(e); else return gw.source(e); }
    530530
    531531//     typedef OutEdgeIt InEdgeIt;
    … …  
    545545//       It e; first(e, v); return e; }
    546546
    547 //     Node head(const Edge& e) const { return gw.head(e); }
    548 //     Node tail(const Edge& e) const { return gw.tail(e); }
     547//     Node target(const Edge& e) const { return gw.target(e); }
     548//     Node source(const Edge& e) const { return gw.source(e); }
    549549
    550550//     template<typename I> bool valid(const I& i) const
    … …  
    564564//     Node addNode() const { return gw.addNode(); }
    565565// // FIXME: ez igy nem jo, mert nem
    566 // //    Edge addEdge(const Node& tail, const Node& head) const {
    567 // //      return graph->addEdge(tail, head); }
     566// //    Edge addEdge(const Node& source, const Node& target) const {
     567// //      return graph->addEdge(source, target); }
    568568 
    569569//     template<typename I> void erase(const I& i) const { gw.erase(i); }
    … …  
    693693    OutEdgeIt& next(OutEdgeIt& e) const {
    694694      if (e.out_or_in) {
    695         Node n=graph->tail(e.out);
     695        Node n=graph->source(e.out);
    696696        graph->next(e.out);
    697697        if (!graph->valid(e.out)) { e.out_or_in=false; graph->first(e.in, n); }
    … …  
    703703
    704704    EdgeIt& next(EdgeIt& e) const {
    705       //NodeIt v=tail(e);
     705      //NodeIt v=source(e);
    706706      graph->next(e.out);
    707707      while (valid(e.v) && !graph->valid(e.out)) {
    … …  
    721721      It e; this->first(e, v); return e; }
    722722
    723 //    Node head(const Edge& e) const { return gw.head(e); }
    724 //    Node tail(const Edge& e) const { return gw.tail(e); }
     723//    Node target(const Edge& e) const { return gw.target(e); }
     724//    Node source(const Edge& e) const { return gw.source(e); }
    725725
    726726//    template<typename I> bool valid(const I& i) const
    … …  
    736736
    737737    Node aNode(const OutEdgeIt& e) const {
    738       if (e.out_or_in) return graph->tail(e); else return graph->head(e); }
     738      if (e.out_or_in) return graph->source(e); else return graph->target(e); }
    739739    Node bNode(const OutEdgeIt& e) const {
    740       if (e.out_or_in) return graph->head(e); else return graph->tail(e); }
     740      if (e.out_or_in) return graph->target(e); else return graph->source(e); }
    741741 
    742742//    Node addNode() const { return gw.addNode(); }
    743743
    744744// FIXME: ez igy nem jo, mert nem
    745 //    Edge addEdge(const Node& tail, const Node& head) const {
    746 //      return graph->addEdge(tail, head); }
     745//    Edge addEdge(const Node& source, const Node& target) const {
     746//      return graph->addEdge(source, target); }
    747747 
    748748//    template<typename I> void erase(const I& i) const { gw.erase(i); }
    … …  
    808808//       It e; first(e, v); return e; }
    809809
    810 //     Node head(const Edge& e) const { return graph->head(e); }
    811 //     Node tail(const Edge& e) const { return graph->tail(e); }
     810//     Node target(const Edge& e) const { return graph->target(e); }
     811//     Node source(const Edge& e) const { return graph->source(e); }
    812812 
    813813//     template<typename I> Node aNode(const I& e) const {
    … …  
    823823 
    824824//     Node addNode() { return graph->addNode(); }
    825 //     Edge addEdge(const Node& tail, const Node& head) {
    826 //       return graph->addEdge(tail, head); }
     825//     Edge addEdge(const Node& source, const Node& target) {
     826//       return graph->addEdge(source, target); }
    827827 
    828828//     template<typename I> void erase(const I& i) { graph->erase(i); }
    … …  
    10641064    }
    10651065
    1066     Node tail(Edge e) const {
     1066    Node source(Edge e) const {
    10671067      return ((e.out_or_in) ? graph->aNode(e.out) : graph->aNode(e.in)); }
    1068     Node head(Edge e) const {
     1068    Node target(Edge e) const {
    10691069      return ((e.out_or_in) ? graph->bNode(e.out) : graph->bNode(e.in)); }
    10701070
    … …  
    11931193      OutEdgeIt f=e;
    11941194      this->next(f);
    1195       first_out_edges->set(this->tail(e), f);
     1195      first_out_edges->set(this->source(e), f);
    11961196    }
    11971197  };
    … …  
    13111311//       It e; first(e, v); return e; }
    13121312
    1313 //     Node head(const Edge& e) const { return gw.head(e); }
    1314 //     Node tail(const Edge& e) const { return gw.tail(e); }
     1313//     Node target(const Edge& e) const { return gw.target(e); }
     1314//     Node source(const Edge& e) const { return gw.source(e); }
    13151315 
    13161316//     template<typename I> Node aNode(const I& e) const {
    … …  
    13261326 
    13271327//     Node addNode() { return gw.addNode(); }
    1328 //     Edge addEdge(const Node& tail, const Node& head) {
    1329 //       return gw.addEdge(tail, head); }
     1328//     Edge addEdge(const Node& source, const Node& target) {
     1329//       return gw.addEdge(source, target); }
    13301330 
    13311331//     template<typename I> void erase(const I& i) { gw.erase(i); }

  • src/work/marci/experiment/graph_wrapper_st_ostream_op.h

    r921 r986  
    167167    EdgeIt& next(EdgeIt& i) const { graph->next(i.e); return i; }   
    168168
    169     Node tail(const Edge& e) const {
    170       return Node(graph->tail(static_cast<typename Graph::Edge>(e))); }
    171     Node head(const Edge& e) const {
    172       return Node(graph->head(static_cast<typename Graph::Edge>(e))); }
     169    Node source(const Edge& e) const {
     170      return Node(graph->source(static_cast<typename Graph::Edge>(e))); }
     171    Node target(const Edge& e) const {
     172      return Node(graph->target(static_cast<typename Graph::Edge>(e))); }
    173173
    174174    bool valid(const Node& n) const {
    … …  
    186186 
    187187    Node addNode() const { return Node(graph->addNode()); }
    188     Edge addEdge(const Node& tail, const Node& head) const {
    189       return Edge(graph->addEdge(tail, head)); }
     188    Edge addEdge(const Node& source, const Node& target) const {
     189      return Edge(graph->addEdge(source, target)); }
    190190
    191191    void erase(const Node& i) const { graph->erase(i); }
    … …  
    273273      return Node(this->graph->bNode(e.e)); }
    274274
    275     Node tail(const Edge& e) const {
    276       return GraphWrapper<Graph>::head(e); }
    277     Node head(const Edge& e) const {
    278       return GraphWrapper<Graph>::tail(e); }
     275    Node source(const Edge& e) const {
     276      return GraphWrapper<Graph>::target(e); }
     277    Node target(const Edge& e) const {
     278      return GraphWrapper<Graph>::source(e); }
    279279
    280280  };
    … …  
    490490    OutEdgeIt& next(OutEdgeIt& e) const {
    491491      if (e.out_or_in) {
    492         typename Graph::Node n=this->graph->tail(e.out);
     492        typename Graph::Node n=this->graph->source(e.out);
    493493        this->graph->next(e.out);
    494494        if (!this->graph->valid(e.out)) {
    … …  
    507507
    508508    Node aNode(const OutEdgeIt& e) const {
    509       if (e.out_or_in) return this->graph->tail(e); else
    510         return this->graph->head(e); }
     509      if (e.out_or_in) return this->graph->source(e); else
     510        return this->graph->target(e); }
    511511    Node bNode(const OutEdgeIt& e) const {
    512       if (e.out_or_in) return this->graph->head(e); else
    513         return this->graph->tail(e); }
     512      if (e.out_or_in) return this->graph->target(e); else
     513        return this->graph->source(e); }
    514514  };
    515515 
    … …  
    725725    }
    726726
    727     Node tail(Edge e) const {
    728       return ((e.forward) ? this->graph->tail(e) : this->graph->head(e)); }
    729     Node head(Edge e) const {
    730       return ((e.forward) ? this->graph->head(e) : this->graph->tail(e)); }
     727    Node source(Edge e) const {
     728      return ((e.forward) ? this->graph->source(e) : this->graph->target(e)); }
     729    Node target(Edge e) const {
     730      return ((e.forward) ? this->graph->target(e) : this->graph->source(e)); }
    731731
    732732    Node aNode(OutEdgeIt e) const {
    … …  
    914914      OutEdgeIt f=e;
    915915      this->next(f);
    916       first_out_edges->set(this->tail(e), f.e);
     916      first_out_edges->set(this->source(e), f.e);
    917917    }
    918918  };
    … …  
    10421042    InEdgeIt& next(InEdgeIt& i) const { this->graph->next(i.e); return i; }
    10431043
    1044     Node tail(const Edge& e) {
    1045       if (!(*(this->s_false_t_true_map))[this->graph->tail(e)])
    1046         return Node(this->graph->tail(e));
     1044    Node source(const Edge& e) {
     1045      if (!(*(this->s_false_t_true_map))[this->graph->source(e)])
     1046        return Node(this->graph->source(e));
    10471047      else
    1048         return Node(this->graph->head(e));     
    1049     }
    1050     Node head(const Edge& e) {
    1051       if (!(*(this->s_false_t_true_map))[this->graph->tail(e)])
    1052         return Node(this->graph->head(e));
     1048        return Node(this->graph->target(e));   
     1049    }
     1050    Node target(const Edge& e) {
     1051      if (!(*(this->s_false_t_true_map))[this->graph->source(e)])
     1052        return Node(this->graph->target(e));
    10531053      else
    1054         return Node(this->graph->tail(e));     
     1054        return Node(this->graph->source(e));   
    10551055    }
    10561056
    … …  
    14701470    }   
    14711471
    1472     Node tail(const Edge& e) const {
     1472    Node source(const Edge& e) const {
    14731473      switch (e.spec) {
    14741474      case 0:
    1475         return Node(this->graph->tail(e));
     1475        return Node(this->graph->source(e));
    14761476        break;
    14771477      case 1:
    … …  
    14841484      }
    14851485    }
    1486     Node head(const Edge& e) const {
     1486    Node target(const Edge& e) const {
    14871487      switch (e.spec) {
    14881488      case 0:
    1489         return Node(this->graph->head(e));
     1489        return Node(this->graph->target(e));
    14901490        break;
    14911491      case 1:
    … …  
    15071507    }
    15081508 
    1509     Node aNode(const OutEdgeIt& e) const { return tail(e); }
    1510     Node aNode(const InEdgeIt& e) const { return head(e); }
    1511     Node bNode(const OutEdgeIt& e) const { return head(e); }
    1512     Node bNode(const InEdgeIt& e) const { return tail(e); }
     1509    Node aNode(const OutEdgeIt& e) const { return source(e); }
     1510    Node aNode(const InEdgeIt& e) const { return target(e); }
     1511    Node bNode(const OutEdgeIt& e) const { return target(e); }
     1512    Node bNode(const InEdgeIt& e) const { return source(e); }
    15131513
    15141514    void addNode() const { }
    … …  
    15161516   
    15171517//    Node addNode() const { return Node(this->graph->addNode()); }
    1518 //    Edge addEdge(const Node& tail, const Node& head) const {
    1519 //      return Edge(this->graph->addEdge(tail, head)); }
     1518//    Edge addEdge(const Node& source, const Node& target) const {
     1519//      return Edge(this->graph->addEdge(source, target)); }
    15201520
    15211521//    void erase(const Node& i) const { this->graph->erase(i); }

  • src/work/marci/experiment/iterator_bfs_demo.cc

    r921 r986  
    2323  string get(typename Graph::Edge e) const {
    2424    return
    25       (node_name_map.get(graph.tail(e))+"->"+node_name_map.get(graph.head(e)));
     25      (node_name_map.get(graph.source(e))+"->"+node_name_map.get(graph.target(e)));
    2626  }
    2727};

  • src/work/marci/experiment/iterator_bfs_demo_1.cc

    r921 r986  
    2323  string get(typename Graph::Edge e) const {
    2424    return
    25       (node_name_map.get(graph.tail(e))+"->"+node_name_map.get(graph.head(e)));
     25      (node_name_map.get(graph.source(e))+"->"+node_name_map.get(graph.target(e)));
    2626  }
    2727};

  • src/work/marci/experiment/list_graph.h

    r921 r986  
    123123      //ListGraph* G;
    124124      int id;
    125       node_item* _tail;
    126       node_item* _head;
     125      node_item* _source;
     126      node_item* _target;
    127127      edge_item* _next_out;
    128128      edge_item* _prev_out;
    … …  
    150150    }
    151151
    152     edge_item* _add_edge(node_item* _tail, node_item* _head) {
     152    edge_item* _add_edge(node_item* _source, node_item* _target) {
    153153      edge_item* e=new edge_item;
    154154      e->id=edge_id++;
    155       e->_tail=_tail;
    156       e->_head=_head;
    157      
    158       e->_prev_out=_tail->_last_out_edge;
    159       if (_tail->_last_out_edge) (_tail->_last_out_edge)->_next_out=e;
    160       _tail->_last_out_edge=e;
    161       if (!_tail->_first_out_edge) _tail->_first_out_edge=e;
     155      e->_source=_source;
     156      e->_target=_target;
     157     
     158      e->_prev_out=_source->_last_out_edge;
     159      if (_source->_last_out_edge) (_source->_last_out_edge)->_next_out=e;
     160      _source->_last_out_edge=e;
     161      if (!_source->_first_out_edge) _source->_first_out_edge=e;
    162162      e->_next_out=0;
    163163 
    164       e->_prev_in=_head->_last_in_edge;
    165       if (_head->_last_in_edge) (_head->_last_in_edge)->_next_in=e;
    166       _head->_last_in_edge=e;
    167       if (!_head->_first_in_edge) { _head->_first_in_edge=e; }
     164      e->_prev_in=_target->_last_in_edge;
     165      if (_target->_last_in_edge) (_target->_last_in_edge)->_next_in=e;
     166      _target->_last_in_edge=e;
     167      if (!_target->_first_in_edge) { _target->_first_in_edge=e; }
    168168      e->_next_in=0;
    169169
    … …  
    185185    void _delete_edge(edge_item* e) {
    186186      if (e->_next_out) (e->_next_out)->_prev_out=e->_prev_out; else
    187         (e->_tail)->_last_out_edge=e->_prev_out;
     187        (e->_source)->_last_out_edge=e->_prev_out;
    188188      if (e->_prev_out) (e->_prev_out)->_next_out=e->_next_out; else
    189         (e->_tail)->_first_out_edge=e->_next_out;
     189        (e->_source)->_first_out_edge=e->_next_out;
    190190      if (e->_next_in) (e->_next_in)->_prev_in=e->_prev_in; else
    191         (e->_head)->_last_in_edge=e->_prev_in;
     191        (e->_target)->_last_in_edge=e->_prev_in;
    192192      if (e->_prev_in) (e->_prev_in)->_next_in=e->_next_in; else
    193         (e->_head)->_first_in_edge=e->_next_in;
     193        (e->_target)->_first_in_edge=e->_next_in;
    194194
    195195      delete e;
    … …  
    197197    }
    198198
    199     void _set_tail(edge_item* e, node_item* _tail) {
     199    void _set_source(edge_item* e, node_item* _source) {
    200200      if (e->_next_out) (e->_next_out)->_prev_out=e->_prev_out; else
    201         (e->_tail)->_last_out_edge=e->_prev_out;
     201        (e->_source)->_last_out_edge=e->_prev_out;
    202202      if (e->_prev_out) (e->_prev_out)->_next_out=e->_next_out; else
    203         (e->_tail)->_first_out_edge=e->_next_out;
    204      
    205       e->_tail=_tail;
    206      
    207       e->_prev_out=_tail->_last_out_edge;
    208       if (_tail->_last_out_edge) (_tail->_last_out_edge)->_next_out=e;
    209       _tail->_last_out_edge=e;
    210       if (!_tail->_first_out_edge) _tail->_first_out_edge=e;
     203        (e->_source)->_first_out_edge=e->_next_out;
     204     
     205      e->_source=_source;
     206     
     207      e->_prev_out=_source->_last_out_edge;
     208      if (_source->_last_out_edge) (_source->_last_out_edge)->_next_out=e;
     209      _source->_last_out_edge=e;
     210      if (!_source->_first_out_edge) _source->_first_out_edge=e;
    211211      e->_next_out=0;
    212212    }
    213213
    214     void _set_head(edge_item* e, node_item* _head) {
     214    void _set_target(edge_item* e, node_item* _target) {
    215215      if (e->_next_in) (e->_next_in)->_prev_in=e->_prev_in; else
    216         (e->_head)->_last_in_edge=e->_prev_in;
     216        (e->_target)->_last_in_edge=e->_prev_in;
    217217      if (e->_prev_in) (e->_prev_in)->_next_in=e->_next_in; else
    218         (e->_head)->_first_in_edge=e->_next_in;
    219      
    220       e->_head=_head;
    221      
    222       e->_prev_in=_head->_last_in_edge;
    223       if (_head->_last_in_edge) (_head->_last_in_edge)->_next_in=e;
    224       _head->_last_in_edge=e;
    225       if (!_head->_first_in_edge) { _head->_first_in_edge=e; }
     218        (e->_target)->_first_in_edge=e->_next_in;
     219     
     220      e->_target=_target;
     221     
     222      e->_prev_in=_target->_last_in_edge;
     223      if (_target->_last_in_edge) (_target->_last_in_edge)->_next_in=e;
     224      _target->_last_in_edge=e;
     225      if (!_target->_first_in_edge) { _target->_first_in_edge=e; }
    226226      e->_next_in=0;
    227227    }
    … …  
    248248    //InEdgeIt firstInEdge(const Node v) const { return InEdgeIt(v); }
    249249    //SymEdgeIt firstSymEdge(const Node v) const { return SymEdgeIt(v); }
    250     Node tail(Edge e) const { return e.tailNode(); }
    251     Node head(Edge e) const { return e.headNode(); }
     250    Node source(Edge e) const { return e.sourceNode(); }
     251    Node target(Edge e) const { return e.targetNode(); }
    252252
    253253    Node aNode(const OutEdgeIt& e) const { return e.aNode(); }
    … …  
    278278    SymEdgeIt& /*getF*/first(SymEdgeIt& e, Node v) const {
    279279      e=SymEdgeIt(*this, v); return e; }
    280     //void getTail(Node& n, const Edge& e) const { n=tail(e); }
    281     //void getHead(Node& n, const Edge& e) const { n=head(e); }
     280    //void getSource(Node& n, const Edge& e) const { n=source(e); }
     281    //void getTarget(Node& n, const Edge& e) const { n=target(e); }
    282282
    283283    //void getANode(Node& n, const OutEdgeIt& e) const { n=e.aNode(); }
    … …  
    346346    }
    347347
    348     void setTail(Edge e, Node tail) {
    349       _set_tail(e.edge, tail.node);
    350     }
    351 
    352     void setHead(Edge e, Node head) {
    353       _set_head(e.edge, head.node);
     348    void setSource(Edge e, Node source) {
     349      _set_source(e.edge, source.node);
     350    }
     351
     352    void setTarget(Edge e, Node target) {
     353      _set_target(e.edge, target.node);
    354354    }
    355355
    … …  
    360360    }
    361361    friend std::ostream& operator<<(std::ostream& os, const Edge& i) {
    362       os << "(" << i.edge->_tail->id << "--" << i.edge->id << "->" << i.edge->_head->id << ")";
     362      os << "(" << i.edge->_source->id << "--" << i.edge->id << "->" << i.edge->_target->id << ")";
    363363      return os;
    364364    }
    … …  
    427427      friend bool operator!=(Edge u, Edge v) { return v.edge!=u.edge; }
    428428    protected:
    429       Node tailNode() const { return Node(edge->_tail); }
    430       Node headNode() const { return Node(edge->_head); }
     429      Node sourceNode() const { return Node(edge->_source); }
     430      Node targetNode() const { return Node(edge->_target); }
    431431    public:
    432432      friend std::ostream& operator<<(std::ostream& os, const Edge& i);
    … …  
    448448      EdgeIt(edge_item* _e) : Edge(_e) { }
    449449      EdgeIt& operator++() {
    450         node_item* v=edge->_tail;
     450        node_item* v=edge->_source;
    451451        edge=edge->_next_out;
    452452        while (v && !edge) { v=v->_next_node; if (v) edge=v->_first_out_edge; }
    … …  
    468468      OutEdgeIt& operator++() { edge=edge->_next_out; return *this; }
    469469    protected:
    470       Node aNode() const { return Node(edge->_tail); }
    471       Node bNode() const { return Node(edge->_head); }
     470      Node aNode() const { return Node(edge->_source); }
     471      Node bNode() const { return Node(edge->_target); }
    472472    };
    473473   
    … …  
    485485      InEdgeIt& operator++() { edge=edge->_next_in; return *this; }
    486486    protected:
    487       Node aNode() const { return Node(edge->_head); }
    488       Node bNode() const { return Node(edge->_tail); }
     487      Node aNode() const { return Node(edge->_target); }
     488      Node bNode() const { return Node(edge->_source); }
    489489    };
    490490
    … …  
    511511      SymEdgeIt& operator++() {
    512512        if (out_or_in) {
    513           node_item* v=edge->_tail;
     513          node_item* v=edge->_source;
    514514          edge=edge->_next_out;
    515515          if (!edge) { out_or_in=0; edge=v->_first_in_edge; }
    … …  
    521521    protected:
    522522      Node aNode() const {
    523         return (out_or_in) ? Node(edge->_tail) : Node(edge->_head); }
     523        return (out_or_in) ? Node(edge->_source) : Node(edge->_target); }
    524524      Node bNode() const {
    525         return (out_or_in) ? Node(edge->_head) : Node(edge->_tail); }
     525        return (out_or_in) ? Node(edge->_target) : Node(edge->_source); }
    526526    };
    527527

  • src/work/marci/graph_concept.h

    r921 r986  
    104104
    105105
    106     /// Gives back the head node of an edge.
    107     Node head(const Edge&) const { return INVALID; }
    108     /// Gives back the tail node of an edge.
    109     Node tail(const Edge&) const { return INVALID; }
     106    /// Gives back the target node of an edge.
     107    Node target(const Edge&) const { return INVALID; }
     108    /// Gives back the source node of an edge.
     109    Node source(const Edge&) const { return INVALID; }
    110110 
    111111    //   Node aNode(SymEdgeIt) const {}
    … …  
    143143    /// \brief Add a new edge to the graph.
    144144    ///
    145     /// Add a new edge to the graph with tail node \c tail
    146     /// and head node \c head.
     145    /// Add a new edge to the graph with source node \c source
     146    /// and target node \c target.
    147147    /// \return the new edge.
    148     Edge addEdge(const Node& tail, const Node& head) { return INVALID; }
     148    Edge addEdge(const Node& source, const Node& target) { return INVALID; }
    149149   
    150150    /// \brief Resets the graph.

  • src/work/marci/iterator_bfs_demo.cc

    r921 r986  
    2424  string operator[](typename Graph::Edge e) const {
    2525    return
    26       (node_name_map[graph.tail(e)]+"->"+node_name_map[graph.head(e)]);
     26      (node_name_map[graph.source(e)]+"->"+node_name_map[graph.target(e)]);
    2727  }
    2828};
    … …  
    9696      if (Graph::Edge(bfs)!=INVALID) {
    9797        cout << edge_name[bfs] << /*endl*/", " <<
    98           node_name[G.tail(bfs)] <<
    99           (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
    100           node_name[G.head(bfs)] <<
     98          node_name[G.source(bfs)] <<
     99          (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
     100          node_name[G.target(bfs)] <<
    101101          (bfs.isBNodeNewlyReached() ? ": is newly reached." :
    102102           ": is not newly reached.");
    103103      } else {
    104104        cout << "invalid" << /*endl*/", " <<
    105           node_name[bfs.tail()] <<
     105          node_name[bfs.source()] <<
    106106          (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
    107107         
    … …  
    130130      if (Graph::Edge(dfs)!=INVALID) {
    131131        cout << edge_name[dfs] << /*endl*/", " <<
    132           node_name[G.tail(dfs)] <<
    133           (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
    134           node_name[G.head(dfs)] <<
     132          node_name[G.source(dfs)] <<
     133          (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
     134          node_name[G.target(dfs)] <<
    135135          (dfs.isBNodeNewlyReached() ? ": is newly reached." :
    136136           ": is not newly reached.");
    137137      } else {
    138138        cout << "invalid" << /*endl*/", " <<
    139           node_name[dfs.tail()] <<
     139          node_name[dfs.source()] <<
    140140          (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
    141141         
    … …  
    172172      if (GW::Edge(bfs)!=INVALID) {
    173173        cout << edge_name[GW::Edge(bfs)] << /*endl*/", " <<
    174           node_name[gw.tail(bfs)] <<
    175           (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
    176           node_name[gw.head(bfs)] <<
     174          node_name[gw.source(bfs)] <<
     175          (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
     176          node_name[gw.target(bfs)] <<
    177177          (bfs.isBNodeNewlyReached() ? ": is newly reached." :
    178178           ": is not newly reached.");
    179179      } else {
    180180        cout << "invalid" << /*endl*/", " <<
    181           node_name[bfs.tail()] <<
     181          node_name[bfs.source()] <<
    182182          (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
    183183         
    … …  
    206206      if (GW::Edge(dfs)!=INVALID) {
    207207        cout << edge_name[GW::Edge(dfs)] << /*endl*/", " <<
    208           node_name[gw.tail(dfs)] <<
    209           (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
    210           node_name[gw.head(dfs)] <<
     208          node_name[gw.source(dfs)] <<
     209          (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
     210          node_name[gw.target(dfs)] <<
    211211          (dfs.isBNodeNewlyReached() ? ": is newly reached." :
    212212           ": is not newly reached.");
    213213      } else {
    214214        cout << "invalid" << /*endl*/", " <<
    215           node_name[dfs.tail()] <<
     215          node_name[dfs.source()] <<
    216216          (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
    217217         
    … …  
    311311    cout << "bfs and dfs iterator demo on the bidirected graph" << endl;
    312312//     for(GW::EdgeIt e(gw); e!=INVALID; ++e) {
    313 //       cout << node_name[gw.tail(e)] << "->" << node_name[gw.head(e)] << " ";
     313//       cout << node_name[gw.source(e)] << "->" << node_name[gw.target(e)] << " ";
    314314//     }
    315315    for(GW::NodeIt n(gw); n!=INVALID; ++n) {
    … …  
    335335      if (GW::Edge(bfs)!=INVALID) {
    336336        cout << edge_name[GW::Edge(bfs)] << /*endl*/", " <<
    337           node_name[gw.tail(bfs)] <<
    338           (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
    339           node_name[gw.head(bfs)] <<
     337          node_name[gw.source(bfs)] <<
     338          (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
     339          node_name[gw.target(bfs)] <<
    340340          (bfs.isBNodeNewlyReached() ? ": is newly reached." :
    341341           ": is not newly reached.");
    342342      } else {
    343343        cout << "invalid" << /*endl*/", " <<
    344           node_name[bfs.tail()] <<
     344          node_name[bfs.source()] <<
    345345          (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
    346346         
    … …  
    369369      if (GW::Edge(dfs)!=INVALID) {
    370370        cout << edge_name[GW::Edge(dfs)] << /*endl*/", " <<
    371           node_name[gw.tail(dfs)] <<
    372           (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
    373           node_name[gw.head(dfs)] <<
     371          node_name[gw.source(dfs)] <<
     372          (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
     373          node_name[gw.target(dfs)] <<
    374374          (dfs.isBNodeNewlyReached() ? ": is newly reached." :
    375375           ": is not newly reached.");
    376376      } else {
    377377        cout << "invalid" << /*endl*/", " <<
    378           node_name[dfs.tail()] <<
     378          node_name[dfs.source()] <<
    379379          (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") <<
    380380         

  • src/work/marci/leda/bipartite_matching_comparison.cc

    r921 r986  
    130130
    131131  FOR_EACH_LOC(BGW::EdgeIt, e, bgw)
    132     hg.addEdge(b_s_nodes[bgw.tail(e)], b_t_nodes[bgw.head(e)]);
     132    hg.addEdge(b_s_nodes[bgw.source(e)], b_t_nodes[bgw.target(e)]);
    133133
    134134  ConstMap<SageGraph::Edge, int> cm(1);

  • src/work/marci/leda/leda_graph_wrapper.h

    r921 r986  
    214214//     }
    215215
    216     ///Gives back the head node of an edge.
    217     Node head(Edge e) const {
     216    ///Gives back the target node of an edge.
     217    Node target(Edge e) const {
    218218      return Node(l_graph->target(e.l_e));
    219219    }
    220     ///Gives back the tail node of an edge.
    221     Node tail(Edge e) const {
     220    ///Gives back the source node of an edge.
     221    Node source(Edge e) const {
    222222      return Node(l_graph->source(e.l_e));
    223223    }
    224224 
    225     Node aNode(InEdgeIt e) const { return head(e); }
    226     Node aNode(OutEdgeIt e) const { return tail(e); }
     225    Node aNode(InEdgeIt e) const { return target(e); }
     226    Node aNode(OutEdgeIt e) const { return source(e); }
    227227    //   Node aNode(SymEdgeIt) const {}
    228228
    229     Node bNode(InEdgeIt e) const { return tail(e); }
    230     Node bNode(OutEdgeIt e) const { return head(e); }
     229    Node bNode(InEdgeIt e) const { return source(e); }
     230    Node bNode(OutEdgeIt e) const { return target(e); }
    231231    //   Node bNode(SymEdgeIt) const {}
    232232
    … …  
    245245 
    246246    Node addNode() const { return Node(l_graph->new_node()); }
    247     Edge addEdge(Node tail, Node head) const {
    248       return Edge(l_graph->new_edge(tail.l_n, head.l_n));
     247    Edge addEdge(Node source, Node target) const {
     248      return Edge(l_graph->new_edge(source.l_n, target.l_n));
    249249    }
    250250   

  • src/work/marci/leda/max_bipartite_matching_demo.cc

    r921 r986  
    104104//     cout << "out edges: ";
    105105//     for(OutEdgeIt e=G.first<OutEdgeIt>(n); G.valid(e); G.next(e))
    106 //       cout << G.id(G.tail(e)) << "->" << G.id(G.head(e)) << " ";
     106//       cout << G.id(G.source(e)) << "->" << G.id(G.target(e)) << " ";
    107107//     cout << "in edges: ";
    108108//     for(InEdgeIt e=G.first<InEdgeIt>(n); G.valid(e); G.next(e))
    109 //       cout << G.id(G.tail(e)) << "->" << G.id(G.head(e)) << " ";
     109//       cout << G.id(G.source(e)) << "->" << G.id(G.target(e)) << " ";
    110110//     cout << endl;
    111111//   }
    … …  
    124124    while (max_flow_test.augmentOnShortestPath()) {
    125125//       for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e)) 
    126 //      std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
     126//      std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
    127127//       std::cout<<std::endl;
    128128      ++i;
    … …  
    132132//     for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e)) 
    133133//       if (flow.get(e))
    134 //      std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
     134//      std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
    135135//     std::cout<<std::endl;
    136136//     std::cout << "edges which are not in this maximum matching: "<< std::endl;
    137137//     for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e)) 
    138138//       if (!flow.get(e))
    139 //      std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
     139//      std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
    140140//     std::cout<<std::endl;
    141141   
    … …  
    157157//     while (max_flow_test.augmentOnBlockingFlow2()) {
    158158// //       for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e)) 
    159 // //   std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
     159// //   std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
    160160// //       std::cout<<std::endl;
    161161//       ++i;
    … …  
    165165// //     for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e)) 
    166166// //       if (flow.get(e))
    167 // //   std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
     167// //   std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
    168168// //     std::cout<<std::endl;
    169169// //     std::cout << "edges which are not in this maximum matching: "<< std::endl;
    170170// //     for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e)) 
    171171// //       if (!flow.get(e))
    172 // //   std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
     172// //   std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
    173173// //     std::cout<<std::endl;
    174174   
    … …  
    199199//     for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e)) 
    200200//       if (flow.get(e))
    201 //      std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
     201//      std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
    202202//     std::cout<<std::endl;
    203203//     std::cout << "edges which are not in this maximum matching: "<< std::endl;
    204204//     for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e)) 
    205205//       if (!flow.get(e))
    206 //      std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
     206//      std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
    207207//     std::cout<<std::endl;
    208208   

  • src/work/marci/leda_bfs_dfs.cc

    r921 r986  
    2626  string get(typename Graph::Edge e) const {
    2727    return
    28       (node_name_map.get(graph.tail(e))+"->"+node_name_map.get(graph.head(e)));
     28      (node_name_map.get(graph.source(e))+"->"+node_name_map.get(graph.target(e)));
    2929  }
    3030};

  • src/work/marci/leda_graph_demo.cc

    r921 r986  
    3939//     cout << "out edges: ";
    4040//     for(OutEdgeIt e=G.first<OutEdgeIt>(n); G.valid(e); G.next(e))
    41 //       cout << G.id(G.tail(e)) << "-" << cap.get(e) << "->" << G.id(G.head(e)) << " ";
     41//       cout << G.id(G.source(e)) << "-" << cap.get(e) << "->" << G.id(G.target(e)) << " ";
    4242//     cout << "in edges: ";
    4343//     for(InEdgeIt e=G.first<InEdgeIt>(n); G.valid(e); G.next(e))
    44 //       cout << G.id(G.tail(e)) << "-" << cap.get(e) << "->" << G.id(G.head(e)) << " ";
     44//       cout << G.id(G.source(e)) << "-" << cap.get(e) << "->" << G.id(G.target(e)) << " ";
    4545//     cout << endl;
    4646//   }
    … …  
    6565    while (max_flow_test.augmentOnShortestPath()) {
    6666//     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) {
    67 //       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
     67//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
    6868//     }
    6969//     std::cout<<std::endl;
    … …  
    7373//   std::cout << "maximum flow: "<< std::endl;
    7474//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) {
    75 //     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
     75//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
    7676//   }
    7777//   std::cout<<std::endl;

  • src/work/marci/lp/max_flow_by_lp.cc

    r921 r986  
    6464
    6565    FOR_EACH_LOC(Graph::EdgeIt, e, g) {
    66       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
    67         std::cout << "Slackness does not hold!" << std::endl;
    68       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     66      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
     67        std::cout << "Slackness does not hold!" << std::endl;
     68      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    6969        std::cout << "Slackness does not hold!" << std::endl;
    7070    }
    … …  
    8080
    8181//     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
    82 //       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
    83 //      std::cout << "Slackness does not hold!" << std::endl;
    84 //       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     82//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
     83//      std::cout << "Slackness does not hold!" << std::endl;
     84//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    8585//      std::cout << "Slackness does not hold!" << std::endl;
    8686//     }
    … …  
    107107
    108108    FOR_EACH_LOC(Graph::EdgeIt, e, g) {
    109       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
    110         std::cout << "Slackness does not hold!" << std::endl;
    111       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     109      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
     110        std::cout << "Slackness does not hold!" << std::endl;
     111      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    112112        std::cout << "Slackness does not hold!" << std::endl;
    113113    }
    … …  
    136136
    137137    FOR_EACH_LOC(Graph::EdgeIt, e, g) {
    138       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
    139         std::cout << "Slackness does not hold!" << std::endl;
    140       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     138      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
     139        std::cout << "Slackness does not hold!" << std::endl;
     140      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    141141        std::cout << "Slackness does not hold!" << std::endl;
    142142    }
    … …  
    154154
    155155//     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
    156 //       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
    157 //      std::cout << "Slackness does not hold!" << std::endl;
    158 //       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     156//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
     157//      std::cout << "Slackness does not hold!" << std::endl;
     158//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    159159//      std::cout << "Slackness does not hold!" << std::endl;
    160160//     }
    … …  
    172172
    173173//     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
    174 //       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
    175 //      std::cout << "Slackness does not hold!" << std::endl;
    176 //       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     174//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
     175//      std::cout << "Slackness does not hold!" << std::endl;
     176//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    177177//      std::cout << "Slackness does not hold!" << std::endl;
    178178//     }

  • src/work/marci/max_flow_demo.cc

    r921 r986  
    4848
    4949    for(Graph::EdgeIt e(g); e!=INVALID; ++e) {
    50       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
     50      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
    5151        std::cout << "Slackness does not hold!" << std::endl;
    52       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     52      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    5353        std::cout << "Slackness does not hold!" << std::endl;
    5454    }
    … …  
    6464
    6565    for(Graph::EdgeIt e(g); e!=INVALID; ++e) {
    66       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
     66      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
    6767        std::cout << "Slackness does not hold!" << std::endl;
    68       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     68      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    6969        std::cout << "Slackness does not hold!" << std::endl;
    7070    }
    … …  
    9191
    9292    for(Graph::EdgeIt e(g); e!=INVALID; ++e) {
    93       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
     93      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
    9494        std::cout << "Slackness does not hold!" << std::endl;
    95       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     95      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    9696        std::cout << "Slackness does not hold!" << std::endl;
    9797    }
    … …  
    109109
    110110    for(Graph::EdgeIt e(g); e!=INVALID; ++e) {
    111       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
     111      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
    112112        std::cout << "Slackness does not hold!" << std::endl;
    113       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     113      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    114114        std::cout << "Slackness does not hold!" << std::endl;
    115115    }
    … …  
    127127
    128128    for(Graph::EdgeIt e(g); e!=INVALID; ++e) {
    129       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
     129      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
    130130        std::cout << "Slackness does not hold!" << std::endl;
    131       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     131      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    132132        std::cout << "Slackness does not hold!" << std::endl;
    133133    }
    … …  
    145145
    146146    for(Graph::EdgeIt e(g); e!=INVALID; ++e) {
    147       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
     147      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
    148148        std::cout << "Slackness does not hold!" << std::endl;
    149       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     149      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    150150        std::cout << "Slackness does not hold!" << std::endl;
    151151    }

  • src/work/marci/oldies/edmonds_karp.h

    r921 r986  
    6060        ResGWOutEdgeIt e=bfs;
    6161        if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    62           Node v=res_graph.tail(e);
    63           Node w=res_graph.head(e);
     62          Node v=res_graph.source(e);
     63          Node w=res_graph.target(e);
    6464          pred.set(w, e);
    6565          if (res_graph.valid(pred[v])) {
    … …  
    6868            free.set(w, res_graph.resCap(e));
    6969          }
    70           if (res_graph.head(e)==t) { _augment=true; break; }
     70          if (res_graph.target(e)==t) { _augment=true; break; }
    7171        }
    7272       
    … …  
    8080          ResGWEdge e=pred[n];
    8181          res_graph.augment(e, augment_value);
    82           n=res_graph.tail(e);
     82          n=res_graph.source(e);
    8383        }
    8484      }
    … …  
    102102//      return dist[n]; }
    103103//       bool get(const typename MapGraphWrapper::Edge& e) const {
    104 //      return (dist.get(g->tail(e))<dist.get(g->head(e))); }
     104//      return (dist.get(g->source(e))<dist.get(g->target(e))); }
    105105      bool operator[](const typename MapGraphWrapper::Edge& e) const {
    106         return (dist[g->tail(e)]<dist[g->head(e)]);
     106        return (dist[g->source(e)]<dist[g->target(e)]);
    107107      }
    108108    };
    … …  
    124124        ResGWOutEdgeIt e=bfs;
    125125        if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    126           dist.set(res_graph.head(e), dist[res_graph.tail(e)]+1);
     126          dist.set(res_graph.target(e), dist[res_graph.source(e)]+1);
    127127        }
    128128        ++bfs;
    … …  
    153153        typename FilterResGW::EdgeIt e;
    154154        for(filter_res_graph.first(e); filter_res_graph.valid(e); filter_res_graph.next(e)) {
    155           //if (dist.get(res_graph.head(e))==dist.get(res_graph.tail(e))+1) {
    156           typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)], res_graph_to_F[res_graph.head(e)]);
     155          //if (dist.get(res_graph.target(e))==dist.get(res_graph.source(e))+1) {
     156          typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)], res_graph_to_F[res_graph.target(e)]);
    157157          original_edge.update();
    158158          original_edge.set(f, e);
    … …  
    207207            typename MG::Edge e=pred[n];
    208208            res_graph.augment(original_edge[e], augment_value);
    209             n=F.tail(e);
     209            n=F.source(e);
    210210            if (residual_capacity[e]==augment_value)
    211211              F.erase(e);
    … …  
    255255        if (res_graph.valid(e)) {
    256256          if (bfs.isBNodeNewlyReached()) {
    257             dist.set(res_graph.head(e), dist[res_graph.tail(e)]+1);
    258             typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)], res_graph_to_F[res_graph.head(e)]);
     257            dist.set(res_graph.target(e), dist[res_graph.source(e)]+1);
     258            typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)], res_graph_to_F[res_graph.target(e)]);
    259259            original_edge.update();
    260260            original_edge.set(f, e);
    … …  
    262262            residual_capacity.set(f, res_graph.resCap(e));
    263263          } else {
    264             if (dist[res_graph.head(e)]==(dist[res_graph.tail(e)]+1)) {
    265               typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)], res_graph_to_F[res_graph.head(e)]);
     264            if (dist[res_graph.target(e)]==(dist[res_graph.source(e)]+1)) {
     265              typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)], res_graph_to_F[res_graph.target(e)]);
    266266              original_edge.update();
    267267              original_edge.set(f, e);
    … …  
    317317            typename MG::Edge e=pred[n];
    318318            res_graph.augment(original_edge[e], augment_value);
    319             n=F.tail(e);
     319            n=F.source(e);
    320320            if (residual_capacity[e]==augment_value)
    321321              F.erase(e);
    … …  
    344344        ResGWOutEdgeIt e=bfs;
    345345        if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    346           dist.set(res_graph.head(e), dist[res_graph.tail(e)]+1);
     346          dist.set(res_graph.target(e), dist[res_graph.source(e)]+1);
    347347        }
    348348        ++bfs;
    … …  
    441441            typename ErasingResGW::OutEdgeIt e=pred[n];
    442442            res_graph.augment(e, augment_value);
    443             n=erasing_res_graph.tail(e);
     443            n=erasing_res_graph.source(e);
    444444            if (res_graph.resCap(e)==0)
    445445              erasing_res_graph.erase(e);
    … …  
    536536//      AugOutEdgeIt e=bfs;
    537537//      if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    538 //        Node v=res_graph.tail(e);
    539 //        Node w=res_graph.head(e);
     538//        Node v=res_graph.source(e);
     539//        Node w=res_graph.target(e);
    540540//        pred.set(w, e);
    541541//        if (res_graph.valid(pred.get(v))) {
    … …  
    544544//          free.set(w, res_graph.free(e));
    545545//        }
    546 //        n=res_graph.head(e);
     546//        n=res_graph.target(e);
    547547//        if (T->get(n) && (used.get(n)<1) ) {
    548548//          //Num u=0;
    … …  
    566566//        AugEdge e=pred.get(n);
    567567//        res_graph.augment(e, augment_value);
    568 //        n=res_graph.tail(e);
     568//        n=res_graph.source(e);
    569569//      }
    570570//      used.set(n, 1); //mind2 vegen jav
    … …  
    607607// //   AugOutEdgeIt e=bfs;
    608608// //   if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    609 // //     dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
     609// //     dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
    610610// //   }
    611611       
    … …  
    629629// //       //which are in some shortest paths
    630630// //       for(typename AugGraph::EdgeIt e=res_graph.template first<typename AugGraph::EdgeIt>(); res_graph.valid(e); res_graph.next(e)) {
    631 // //   if (dist.get(res_graph.head(e))==dist.get(res_graph.tail(e))+1) {
    632 // //     typename MutableGraph::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
     631// //   if (dist.get(res_graph.target(e))==dist.get(res_graph.source(e))+1) {
     632// //     typename MutableGraph::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
    633633// //     original_edge.update();
    634634// //     original_edge.set(f, e);
    … …  
    682682// //       typename MutableGraph::Edge e=pred.get(n);
    683683// //       res_graph.augment(original_edge.get(e), augment_value);
    684 // //       n=F.tail(e);
     684// //       n=F.source(e);
    685685// //       if (residual_capacity.get(e)==augment_value)
    686686// //         F.erase(e);
    … …  
    733733//      typename ErasingResGraphWrapper<Graph, Num, FlowMap, CapMap>::OutEdgeIt e=bfs;
    734734//      if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
    735 //        dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
     735//        dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
    736736//      }
    737737//      ++bfs; 
    … …  
    810810//          EAugEdge e=pred.get(n);
    811811//          res_graph.augment(e, augment_value);
    812 //          n=res_graph.tail(e);
     812//          n=res_graph.source(e);
    813813//          if (res_graph.free(e)==0)
    814814//            res_graph.erase(e);
    … …  
    903903// //   AugOutEdgeIt e=/*AugOutEdgeIt*/(bfs);
    904904// //   if (e.valid() && bfs.isBNodeNewlyReached()) {
    905 // //     Node v=res_graph.tail(e);
    906 // //     Node w=res_graph.head(e);
     905// //     Node v=res_graph.source(e);
     906// //     Node w=res_graph.target(e);
    907907// //     pred.set(w, e);
    908908// //     if (pred.get(v).valid()) {
    … …  
    911911// //       free.set(w, e.free());
    912912// //     }
    913 // //     if (TMap.get(res_graph.head(e))) {
     913// //     if (TMap.get(res_graph.target(e))) {
    914914// //       _augment=true;
    915 // //       reached_t_node=res_graph.head(e);
     915// //       reached_t_node=res_graph.target(e);
    916916// //       break;
    917917// //     }
    … …  
    927927// //     AugEdge e=pred.get(n);
    928928// //     e.augment(augment_value);
    929 // //     n=res_graph.tail(e);
     929// //     n=res_graph.source(e);
    930930// //   }
    931931// //       }

  • src/work/marci/oldies/marci_graph_demo.cc

    r921 r986  
    3232    std::cout << " outdegree (OutEdgeIt): " << count(G.first<OutEdgeIt>(i)) << " ";
    3333    for(OutEdgeIt j=G.first<OutEdgeIt>(i); G.valid(j); G.next(j)) {
    34       std::cout << "(" << G.id(G.tail(j)) << "--" << G.id(j) << "->" << G.id(G.head(j)) << ") ";
     34      std::cout << "(" << G.id(G.source(j)) << "--" << G.id(j) << "->" << G.id(G.target(j)) << ") ";
    3535    }
    3636    std::cout << std::endl;
    … …  
    9090  }
    9191
    92   std::cout << "node and edge property values on the tails and heads of edges..." << std::endl;
     92  std::cout << "node and edge property values on the sources and targets of edges..." << std::endl;
    9393  for(EdgeIt j=G.first<EdgeIt>(); G.valid(j); G.next(j)) {
    94     std::cout << my_property_vector.get(G.tail(j)) << "--" << my_edge_property.get(j) << "-->" << my_property_vector.get(G.head(j)) << " ";
     94    std::cout << my_property_vector.get(G.source(j)) << "--" << my_edge_property.get(j) << "-->" << my_property_vector.get(G.target(j)) << " ";
    9595  }
    9696  std::cout << std::endl;
    … …  
    159159    std::cout << "out edges: ";
    160160    for(OutEdgeIt j=flowG.first<OutEdgeIt>(i); flowG.valid(j); flowG.next(j))
    161       std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
     161      std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
    162162    std::cout << "in edges: ";
    163163    for(InEdgeIt j=flowG.first<InEdgeIt>(i); flowG.valid(j); flowG.next(j))
    164       std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
     164      std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
    165165    std::cout << std::endl;
    166166  }
    … …  
    172172 
    173173
    174   //flowG.setTail(v3_t, v2);
    175   //flowG.setHead(v3_t, s);
     174  //flowG.setSource(v3_t, v2);
     175  //flowG.setTarget(v3_t, s);
    176176/*
    177177  for(NodeIt i=flowG.first<NodeIt>(); flowG.valid(i); flowG.next(i)) {
    … …  
    179179    std::cout << "out edges: ";
    180180    for(OutEdgeIt j=flowG.first<OutEdgeIt>(i); flowG.valid(j); flowG.next(j))
    181       std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
     181      std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
    182182    std::cout << "in edges: ";
    183183    for(InEdgeIt j=flowG.first<InEdgeIt>(i); flowG.valid(j); flowG.next(j))
    184       std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
     184      std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
    185185    std::cout << std::endl;
    186186  }
    187187 
    188188  for(EdgeIt e=flowG.first<EdgeIt>(); flowG.valid(e); flowG.next(e)) {
    189     std::cout << node_name.get(flowG.tail(e)) << "-"<< cap.get(e) << "->" << node_name.get(flowG.head(e)) << " ";
     189    std::cout << node_name.get(flowG.source(e)) << "-"<< cap.get(e) << "->" << node_name.get(flowG.target(e)) << " ";
    190190  }
    191191*/
    … …  
    197197      std::cout << "out edges: ";
    198198      for(OutEdgeIt j=flowG.first<OutEdgeIt>(i); flowG.valid(j); flowG.next(j))
    199         std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
     199        std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
    200200      std::cout << "in edges: ";
    201201      for(InEdgeIt j=flowG.first<InEdgeIt>(i); flowG.valid(j); flowG.next(j))
    202         std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
     202        std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
    203203      std::cout << std::endl;
    204204    }
    … …  
    211211      std::cout << "out edges: ";
    212212      for(OutEdgeIt j=flowG.first<OutEdgeIt>(i); flowG.valid(j); flowG.next(j))
    213         std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
     213        std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
    214214      std::cout << "in edges: ";
    215215      for(InEdgeIt j=flowG.first<InEdgeIt>(i); flowG.valid(j); flowG.next(j))
    216         std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
     216        std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
    217217      std::cout << std::endl;
    218218    }
    … …  
    229229    max_flow_test.augmentOnBlockingFlow<ListGraph>();
    230230    for(EdgeIt e=flowG.template first<EdgeIt>(); flowG.valid(e); flowG.next(e)) {
    231       std::cout<<"("<<flowG.tail(e)<< "-"<<flow.get(e)<<"->"<<flowG.head(e)<<") ";
     231      std::cout<<"("<<flowG.source(e)<< "-"<<flow.get(e)<<"->"<<flowG.target(e)<<") ";
    232232    }
    233233    std::cout<<std::endl;
    234234    max_flow_test.augmentOnBlockingFlow<ListGraph>();
    235235    for(EdgeIt e=flowG.template first<EdgeIt>(); flowG.valid(e); flowG.next(e)) {
    236       std::cout<<"("<<flowG.tail(e)<< "-"<<flow.get(e)<<"->"<<flowG.head(e)<<") ";
     236      std::cout<<"("<<flowG.source(e)<< "-"<<flow.get(e)<<"->"<<flowG.target(e)<<") ";
    237237    }
    238238    std::cout<<std::endl;*/
    … …  
    242242    while (max_flow_test.augmentOnShortestPath()) {
    243243      for(EdgeIt e=flowG.template first<EdgeIt>(); flowG.valid(e); flowG.next(e)) {
    244         std::cout<<"("<<flowG.tail(e)<< "-"<<flow.get(e)<<"->"<<flowG.head(e)<<") ";
     244        std::cout<<"("<<flowG.source(e)<< "-"<<flow.get(e)<<"->"<<flowG.target(e)<<") ";
    245245      }
    246246      std::cout<<std::endl;
    … …  
    261261    std::cout << "maximum flow: "<< std::endl;
    262262    for(EdgeIt e=flowG.template first<EdgeIt>(); flowG.valid(e); flowG.next(e)) {
    263       std::cout<<"("<<flowG.tail(e)<< "-"<<flow.get(e)<<"->"<<flowG.head(e)<<") ";
     263      std::cout<<"("<<flowG.source(e)<< "-"<<flow.get(e)<<"->"<<flowG.target(e)<<") ";
    264264    }
    265265    std::cout<<std::endl;

  • src/work/marci/preflow_bug.cc

    r921 r986  
    4646    Graph::EdgeIt e;
    4747    for (g.first(e); g.valid(e); g.next(e))
    48       cout << 1+g.id(g.tail(e)) << "->" << 1+g.id(g.head(e)) << " cap: " << cap[e] << " preflow: " << flow[e] << endl;
     48      cout << 1+g.id(g.source(e)) << "->" << 1+g.id(g.target(e)) << " cap: " << cap[e] << " preflow: " << flow[e] << endl;
    4949  }
    5050  {
    … …  
    7676    Graph::EdgeIt e;
    7777    for (g.first(e); g.valid(e); g.next(e)) {
    78       if (cut[g.tail(e)] && !cut[g.head(e)]) {
    79         cout << 1+g.id(g.tail(e)) << "->" << 1+g.id(g.head(e))
     78      if (cut[g.source(e)] && !cut[g.target(e)]) {
     79        cout << 1+g.id(g.source(e)) << "->" << 1+g.id(g.target(e))
    8080             << "(forward edge) flow: " << flow[e]
    8181             << " cap: " << cap[e]<< endl;
    … …  
    8383        std::cout << "Slackness does not hold!" << std::endl;
    8484      }
    85       if (!cut[g.tail(e)] && cut[g.head(e)]) {
    86         cout << 1+g.id(g.tail(e)) << "->" << 1+g.id(g.head(e))
     85      if (!cut[g.source(e)] && cut[g.target(e)]) {
     86        cout << 1+g.id(g.source(e)) << "->" << 1+g.id(g.target(e))
    8787             << "(backward edge) flow: " << flow[e] << endl;
    8888        if (flow[e]!=0)
    … …  
    106106
    107107//     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
    108 //       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
    109 //      std::cout << "Slackness does not hold!" << std::endl;
    110 //       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     108//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
     109//      std::cout << "Slackness does not hold!" << std::endl;
     110//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    111111//      std::cout << "Slackness does not hold!" << std::endl;
    112112//     }
    … …  
    122122
    123123//     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
    124 //       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
    125 //      std::cout << "Slackness does not hold!" << std::endl;
    126 //       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     124//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
     125//      std::cout << "Slackness does not hold!" << std::endl;
     126//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    127127//      std::cout << "Slackness does not hold!" << std::endl;
    128128//     }
    … …  
    149149
    150150//     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
    151 //       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
    152 //      std::cout << "Slackness does not hold!" << std::endl;
    153 //       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     151//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
     152//      std::cout << "Slackness does not hold!" << std::endl;
     153//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    154154//      std::cout << "Slackness does not hold!" << std::endl;
    155155//     }
    … …  
    178178
    179179//     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
    180 //       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
    181 //      std::cout << "Slackness does not hold!" << std::endl;
    182 //       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     180//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
     181//      std::cout << "Slackness does not hold!" << std::endl;
     182//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    183183//      std::cout << "Slackness does not hold!" << std::endl;
    184184//     }
    … …  
    196196
    197197//     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
    198 //       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
    199 //      std::cout << "Slackness does not hold!" << std::endl;
    200 //       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     198//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
     199//      std::cout << "Slackness does not hold!" << std::endl;
     200//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    201201//      std::cout << "Slackness does not hold!" << std::endl;
    202202//     }
    … …  
    214214
    215215//     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
    216 //       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e])
    217 //      std::cout << "Slackness does not hold!" << std::endl;
    218 //       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0)
     216//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e])
     217//      std::cout << "Slackness does not hold!" << std::endl;
     218//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0)
    219219//      std::cout << "Slackness does not hold!" << std::endl;
    220220//     }

  • src/work/marci/preflow_demo_athos.cc

    r921 r986  
    2929  //int cut_value=0;
    3030  //for(EachEdgeIt e=G.first<EachEdgeIt>(); e.valid(); ++e) {
    31   //  if (cut.get(G.tail(e)) && !cut.get(G.head(e))) cut_value+=cap.get(e);
     31  //  if (cut.get(G.source(e)) && !cut.get(G.target(e))) cut_value+=cap.get(e);
    3232  //}
    3333  double post_time=currTime();
    3434  //std::cout << "maximum flow: "<< std::endl;
    3535  //for(EachEdgeIt e=G.first<EachEdgeIt>(); e.valid(); ++e) {
    36   //  std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
     36  //  std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
    3737  //}
    3838  //std::cout<<std::endl;

  • src/work/marci/preflow_demo_jacint.cc

    r921 r986  
    3232  int cut_value=0;
    3333  for(EachEdgeIt e=G.first<EachEdgeIt>(); e.valid(); ++e) {
    34     if (cut.get(G.tail(e)) && !cut.get(G.head(e))) cut_value+=cap.get(e);
     34    if (cut.get(G.source(e)) && !cut.get(G.target(e))) cut_value+=cap.get(e);
    3535  }
    3636  double post_time=currTime();
    3737  //std::cout << "maximum flow: "<< std::endl;
    3838  //for(EachEdgeIt e=G.first<EachEdgeIt>(); e.valid(); ++e) {
    39   //  std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
     39  //  std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
    4040  //}
    4141  //std::cout<<std::endl;
    … …  
    5656  int cut_value=0;
    5757  for(EachEdgeIt e=G.first<EachEdgeIt>(); e.valid(); ++e) {
    58     if (cut.get(G.tail(e)) && !cut.get(G.head(e))) cut_value+=cap.get(e);
     58    if (cut.get(G.source(e)) && !cut.get(G.target(e))) cut_value+=cap.get(e);
    5959  }
    6060  double post_time=currTime();
    6161  //std::cout << "maximum flow: "<< std::endl;
    6262  //for(EachEdgeIt e=G.first<EachEdgeIt>(); e.valid(); ++e) {
    63   //  std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
     63  //  std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
    6464  //}
    6565  //std::cout<<std::endl;
Note: See TracChangeset for help on using the changeset viewer.