Index: src/test/bfs_test.cc
===================================================================
--- src/test/bfs_test.cc	(revision 959)
+++ src/test/bfs_test.cc	(revision 986)
@@ -84,6 +84,6 @@
 
   for(EdgeIt e(G); e==INVALID; ++e) {
-    Node u=G.tail(e);
-    Node v=G.head(e);
+    Node u=G.source(e);
+    Node v=G.target(e);
     check( !bfs_test.reached(u) ||
 	   (bfs_test.dist(v) > bfs_test.dist(u)+1),
@@ -95,5 +95,5 @@
     if ( bfs_test.pred(v)!=INVALID ) {
       Edge e=bfs_test.pred(v);
-      Node u=G.tail(e);
+      Node u=G.source(e);
       check(u==bfs_test.predNode(v),"Wrong tree.");
       check(bfs_test.dist(v) - bfs_test.dist(u) == 1,
Index: src/test/dfs_test.cc
===================================================================
--- src/test/dfs_test.cc	(revision 959)
+++ src/test/dfs_test.cc	(revision 986)
@@ -84,5 +84,5 @@
     if ( dfs_test.pred(v)!=INVALID ) {
       Edge e=dfs_test.pred(v);
-      Node u=G.tail(e);
+      Node u=G.source(e);
       check(u==dfs_test.predNode(v),"Wrong tree.");
       check(dfs_test.dist(v) - dfs_test.dist(u) == 1,
Index: src/test/dijkstra_heap_test.cc
===================================================================
--- src/test/dijkstra_heap_test.cc	(revision 921)
+++ src/test/dijkstra_heap_test.cc	(revision 986)
@@ -74,9 +74,9 @@
   EdgeIt e;
   for(G.first(e); e!=INVALID; ++e) {
-    Node u=G.tail(e);
-    Node v=G.head(e);
+    Node u=G.source(e);
+    Node v=G.target(e);
     if ( dijkstra_test.dist(v) - dijkstra_test.dist(u) > cap[e] )
       if ( dijkstra_test.reached(u) ) {
-	std::cout<<"Error! dist(head)-dist(tail)- edge_length= " 
+	std::cout<<"Error! dist(target)-dist(source)- edge_length= " 
 		 <<dijkstra_test.dist(v) - dijkstra_test.dist(u) 
 	  - cap[e]<<std::endl;
@@ -89,5 +89,5 @@
     if ( dijkstra_test.reached(v) ) {
       Edge e=dijkstra_test.pred(v);
-      Node u=G.tail(e);
+      Node u=G.source(e);
       if ( dijkstra_test.dist(v) - dijkstra_test.dist(u) != cap[e] ) {
 	std::cout<<"Error in a shortest path tree edge! Difference: " 
@@ -123,9 +123,9 @@
 
   for(G.first(e); e!=INVALID; ++e) {
-    Node u=G.tail(e);
-    Node v=G.head(e);
+    Node u=G.source(e);
+    Node v=G.target(e);
     if ( dijkstra_test2.dist(v) - dijkstra_test2.dist(u) > cap[e] )
       if ( dijkstra_test2.reached(u) ) {
-	std::cout<<"Error! dist(head)-dist(tail)- edge_length= " 
+	std::cout<<"Error! dist(target)-dist(source)- edge_length= " 
 		 <<dijkstra_test2.dist(v) - dijkstra_test2.dist(u) 
 	  - cap[e]<<std::endl;
@@ -137,5 +137,5 @@
     if ( dijkstra_test2.reached(v) ) {
       Edge e=dijkstra_test2.pred(v);
-      Node u=G.tail(e);
+      Node u=G.source(e);
       if ( dijkstra_test2.dist(v) - dijkstra_test2.dist(u) != cap[e] ) {
 	std::cout<<"Error in a shortest path tree edge! Difference: " 
Index: src/test/dijkstra_test.cc
===================================================================
--- src/test/dijkstra_test.cc	(revision 959)
+++ src/test/dijkstra_test.cc	(revision 986)
@@ -94,9 +94,9 @@
 
   for(EdgeIt e(G); e!=INVALID; ++e) {
-    Node u=G.tail(e);
-    Node v=G.head(e);
+    Node u=G.source(e);
+    Node v=G.target(e);
     check( !dijkstra_test.reached(u) ||
 	   (dijkstra_test.dist(v) - dijkstra_test.dist(u) <= cap[e]),
-	   "dist(head)-dist(tail)- edge_length= " 
+	   "dist(target)-dist(source)- edge_length= " 
 	   << dijkstra_test.dist(v) - dijkstra_test.dist(u) 
 	   - cap[e]);
@@ -108,5 +108,5 @@
     if ( dijkstra_test.pred(v)!=INVALID ) {
       Edge e=dijkstra_test.pred(v);
-      Node u=G.tail(e);
+      Node u=G.source(e);
       check(u==dijkstra_test.predNode(v),"Wrong tree.");
       check(dijkstra_test.dist(v) - dijkstra_test.dist(u) == cap[e],
Index: src/test/graph_factory_test.cc
===================================================================
--- src/test/graph_factory_test.cc	(revision 959)
+++ src/test/graph_factory_test.cc	(revision 986)
@@ -29,5 +29,5 @@
 This test makes consistency checks of list graph structures.
 
-G.addNode(), G.addEdge(), G.tail(), G.head()
+G.addNode(), G.addEdge(), G.source(), G.target()
 
 \todo Checks for empty graphs and isolated points.
@@ -49,5 +49,5 @@
 
   for(typename std::vector<Edge>::iterator p=ee.begin();p!=ee.end();p++)
-    G.addEdge(G.head(*p),G.tail(*p));
+    G.addEdge(G.target(*p),G.source(*p));
 }
 
Index: src/test/graph_test.h
===================================================================
--- src/test/graph_test.h	(revision 946)
+++ src/test/graph_test.h	(revision 986)
@@ -54,5 +54,5 @@
     for(int i=0;i<nn;i++) {
       check(e!=INVALID,"Wrong OutEdge list linking.");
-      check(n==G.tail(e), "Wrong OutEdge list linking.");
+      check(n==G.source(e), "Wrong OutEdge list linking.");
       ++e;
     }
@@ -66,5 +66,5 @@
     for(int i=0;i<nn;i++) {
       check(e!=INVALID,"Wrong InEdge list linking.");
-      check(n==G.head(e), "Wrong InEdge list linking.");
+      check(n==G.target(e), "Wrong InEdge list linking.");
       ++e;
     }
@@ -82,5 +82,5 @@
 
   ///\file
-  ///\todo Check head(), tail() as well;
+  ///\todo Check target(), source() as well;
 
   
Index: src/test/path_test.cc
===================================================================
--- src/test/path_test.cc	(revision 959)
+++ src/test/path_test.cc	(revision 986)
@@ -48,11 +48,11 @@
   P.clear();                      //void clear() {}
 
-  gn=P.head();                    //GraphNode/*It*/ head() const {return INVALID;}
-  gn=P.tail();                    //GraphNode/*It*/ tail() const {return INVALID;}
+  gn=P.target();                    //GraphNode/*It*/ target() const {return INVALID;}
+  gn=P.source();                    //GraphNode/*It*/ source() const {return INVALID;}
 
   ei=P.first(ei);                 //It& first(It &i) const { return i=It(*this); }
 
-  ni=P.head(ei);                  //NodeIt head(const EdgeIt& e) const {}
-  ni=P.tail(ei);                  //NodeIt tail(const EdgeIt& e) const {}
+  ni=P.target(ei);                  //NodeIt target(const EdgeIt& e) const {}
+  ni=P.source(ei);                  //NodeIt source(const EdgeIt& e) const {}
 
 
Index: src/test/preflow_test.cc
===================================================================
--- src/test/preflow_test.cc	(revision 959)
+++ src/test/preflow_test.cc	(revision 986)
@@ -68,5 +68,5 @@
   int c=0;
   for(SmartGraph::EdgeIt e(g); e!=INVALID; ++e) {
-    if (cut[g.tail(e)] && !cut[g.head(e)]) c+=cap[e];
+    if (cut[g.source(e)] && !cut[g.target(e)]) c+=cap[e];
   }
   return c;
Index: src/test/sym_graph_test.cc
===================================================================
--- src/test/sym_graph_test.cc	(revision 959)
+++ src/test/sym_graph_test.cc	(revision 986)
@@ -31,5 +31,5 @@
 This test makes consistency checks of list graph structures.
 
-G.addNode(), G.addEdge(), G.tail(), G.head()
+G.addNode(), G.addEdge(), G.source(), G.target()
 
 \todo Checks for empty graphs and isolated points.
Index: src/test/sym_graph_test.h
===================================================================
--- src/test/sym_graph_test.h	(revision 959)
+++ src/test/sym_graph_test.h	(revision 986)
@@ -74,6 +74,6 @@
 	SymEdge se;
 	se=INVALID;
-	n=G.tail(se);
-	n=G.head(se);
+	n=G.source(se);
+	n=G.target(se);
       }
       // id tests
@@ -175,5 +175,5 @@
 
   ///\file
-  ///\todo Check head(), tail() as well;
+  ///\todo Check target(), source() as well;
 
   
Index: src/test/test_tools.h
===================================================================
--- src/test/test_tools.h	(revision 978)
+++ src/test/test_tools.h	(revision 986)
@@ -106,5 +106,5 @@
 
   for(typename std::vector<Edge>::iterator p=ee.begin();p!=ee.end();p++)
-    G.addEdge(G.head(*p),G.tail(*p));
+    G.addEdge(G.target(*p),G.source(*p));
 }