COIN-OR::LEMON - Graph Library

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


Ignore:
Timestamp:
11/13/04 13:53:28 (16 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/test
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • src/test/bfs_test.cc

    r959 r986  
    8484
    8585  for(EdgeIt e(G); e==INVALID; ++e) {
    86     Node u=G.tail(e);
    87     Node v=G.head(e);
     86    Node u=G.source(e);
     87    Node v=G.target(e);
    8888    check( !bfs_test.reached(u) ||
    8989           (bfs_test.dist(v) > bfs_test.dist(u)+1),
     
    9595    if ( bfs_test.pred(v)!=INVALID ) {
    9696      Edge e=bfs_test.pred(v);
    97       Node u=G.tail(e);
     97      Node u=G.source(e);
    9898      check(u==bfs_test.predNode(v),"Wrong tree.");
    9999      check(bfs_test.dist(v) - bfs_test.dist(u) == 1,
  • src/test/dfs_test.cc

    r959 r986  
    8484    if ( dfs_test.pred(v)!=INVALID ) {
    8585      Edge e=dfs_test.pred(v);
    86       Node u=G.tail(e);
     86      Node u=G.source(e);
    8787      check(u==dfs_test.predNode(v),"Wrong tree.");
    8888      check(dfs_test.dist(v) - dfs_test.dist(u) == 1,
  • src/test/dijkstra_heap_test.cc

    r921 r986  
    7474  EdgeIt e;
    7575  for(G.first(e); e!=INVALID; ++e) {
    76     Node u=G.tail(e);
    77     Node v=G.head(e);
     76    Node u=G.source(e);
     77    Node v=G.target(e);
    7878    if ( dijkstra_test.dist(v) - dijkstra_test.dist(u) > cap[e] )
    7979      if ( dijkstra_test.reached(u) ) {
    80         std::cout<<"Error! dist(head)-dist(tail)- edge_length= "
     80        std::cout<<"Error! dist(target)-dist(source)- edge_length= "
    8181                 <<dijkstra_test.dist(v) - dijkstra_test.dist(u)
    8282          - cap[e]<<std::endl;
     
    8989    if ( dijkstra_test.reached(v) ) {
    9090      Edge e=dijkstra_test.pred(v);
    91       Node u=G.tail(e);
     91      Node u=G.source(e);
    9292      if ( dijkstra_test.dist(v) - dijkstra_test.dist(u) != cap[e] ) {
    9393        std::cout<<"Error in a shortest path tree edge! Difference: "
     
    123123
    124124  for(G.first(e); e!=INVALID; ++e) {
    125     Node u=G.tail(e);
    126     Node v=G.head(e);
     125    Node u=G.source(e);
     126    Node v=G.target(e);
    127127    if ( dijkstra_test2.dist(v) - dijkstra_test2.dist(u) > cap[e] )
    128128      if ( dijkstra_test2.reached(u) ) {
    129         std::cout<<"Error! dist(head)-dist(tail)- edge_length= "
     129        std::cout<<"Error! dist(target)-dist(source)- edge_length= "
    130130                 <<dijkstra_test2.dist(v) - dijkstra_test2.dist(u)
    131131          - cap[e]<<std::endl;
     
    137137    if ( dijkstra_test2.reached(v) ) {
    138138      Edge e=dijkstra_test2.pred(v);
    139       Node u=G.tail(e);
     139      Node u=G.source(e);
    140140      if ( dijkstra_test2.dist(v) - dijkstra_test2.dist(u) != cap[e] ) {
    141141        std::cout<<"Error in a shortest path tree edge! Difference: "
  • src/test/dijkstra_test.cc

    r959 r986  
    9494
    9595  for(EdgeIt e(G); e!=INVALID; ++e) {
    96     Node u=G.tail(e);
    97     Node v=G.head(e);
     96    Node u=G.source(e);
     97    Node v=G.target(e);
    9898    check( !dijkstra_test.reached(u) ||
    9999           (dijkstra_test.dist(v) - dijkstra_test.dist(u) <= cap[e]),
    100            "dist(head)-dist(tail)- edge_length= "
     100           "dist(target)-dist(source)- edge_length= "
    101101           << dijkstra_test.dist(v) - dijkstra_test.dist(u)
    102102           - cap[e]);
     
    108108    if ( dijkstra_test.pred(v)!=INVALID ) {
    109109      Edge e=dijkstra_test.pred(v);
    110       Node u=G.tail(e);
     110      Node u=G.source(e);
    111111      check(u==dijkstra_test.predNode(v),"Wrong tree.");
    112112      check(dijkstra_test.dist(v) - dijkstra_test.dist(u) == cap[e],
  • src/test/graph_factory_test.cc

    r959 r986  
    2929This test makes consistency checks of list graph structures.
    3030
    31 G.addNode(), G.addEdge(), G.tail(), G.head()
     31G.addNode(), G.addEdge(), G.source(), G.target()
    3232
    3333\todo Checks for empty graphs and isolated points.
     
    4949
    5050  for(typename std::vector<Edge>::iterator p=ee.begin();p!=ee.end();p++)
    51     G.addEdge(G.head(*p),G.tail(*p));
     51    G.addEdge(G.target(*p),G.source(*p));
    5252}
    5353
  • src/test/graph_test.h

    r946 r986  
    5454    for(int i=0;i<nn;i++) {
    5555      check(e!=INVALID,"Wrong OutEdge list linking.");
    56       check(n==G.tail(e), "Wrong OutEdge list linking.");
     56      check(n==G.source(e), "Wrong OutEdge list linking.");
    5757      ++e;
    5858    }
     
    6666    for(int i=0;i<nn;i++) {
    6767      check(e!=INVALID,"Wrong InEdge list linking.");
    68       check(n==G.head(e), "Wrong InEdge list linking.");
     68      check(n==G.target(e), "Wrong InEdge list linking.");
    6969      ++e;
    7070    }
     
    8282
    8383  ///\file
    84   ///\todo Check head(), tail() as well;
     84  ///\todo Check target(), source() as well;
    8585
    8686 
  • src/test/path_test.cc

    r959 r986  
    4848  P.clear();                      //void clear() {}
    4949
    50   gn=P.head();                    //GraphNode/*It*/ head() const {return INVALID;}
    51   gn=P.tail();                    //GraphNode/*It*/ tail() const {return INVALID;}
     50  gn=P.target();                    //GraphNode/*It*/ target() const {return INVALID;}
     51  gn=P.source();                    //GraphNode/*It*/ source() const {return INVALID;}
    5252
    5353  ei=P.first(ei);                 //It& first(It &i) const { return i=It(*this); }
    5454
    55   ni=P.head(ei);                  //NodeIt head(const EdgeIt& e) const {}
    56   ni=P.tail(ei);                  //NodeIt tail(const EdgeIt& e) const {}
     55  ni=P.target(ei);                  //NodeIt target(const EdgeIt& e) const {}
     56  ni=P.source(ei);                  //NodeIt source(const EdgeIt& e) const {}
    5757
    5858
  • src/test/preflow_test.cc

    r959 r986  
    6868  int c=0;
    6969  for(SmartGraph::EdgeIt e(g); e!=INVALID; ++e) {
    70     if (cut[g.tail(e)] && !cut[g.head(e)]) c+=cap[e];
     70    if (cut[g.source(e)] && !cut[g.target(e)]) c+=cap[e];
    7171  }
    7272  return c;
  • src/test/sym_graph_test.cc

    r959 r986  
    3131This test makes consistency checks of list graph structures.
    3232
    33 G.addNode(), G.addEdge(), G.tail(), G.head()
     33G.addNode(), G.addEdge(), G.source(), G.target()
    3434
    3535\todo Checks for empty graphs and isolated points.
  • src/test/sym_graph_test.h

    r959 r986  
    7474        SymEdge se;
    7575        se=INVALID;
    76         n=G.tail(se);
    77         n=G.head(se);
     76        n=G.source(se);
     77        n=G.target(se);
    7878      }
    7979      // id tests
     
    175175
    176176  ///\file
    177   ///\todo Check head(), tail() as well;
     177  ///\todo Check target(), source() as well;
    178178
    179179 
  • src/test/test_tools.h

    r978 r986  
    106106
    107107  for(typename std::vector<Edge>::iterator p=ee.begin();p!=ee.end();p++)
    108     G.addEdge(G.head(*p),G.tail(*p));
     108    G.addEdge(G.target(*p),G.source(*p));
    109109}
    110110
Note: See TracChangeset for help on using the changeset viewer.