Index: src/work/Doxyfile
===================================================================
--- src/work/Doxyfile	(revision 766)
+++ src/work/Doxyfile	(revision 922)
@@ -18,5 +18,5 @@
 # by quotes) that should identify the project.
 
-PROJECT_NAME           = HugoLib
+PROJECT_NAME           = LEMON
 
 # The PROJECT_NUMBER tag can be used to enter a project or revision number. 
@@ -24,5 +24,5 @@
 # if some version control system is used.
 
-PROJECT_NUMBER         = 0.1
+PROJECT_NUMBER         = 0.2
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
@@ -396,6 +396,6 @@
                          ../../doc/maps.dox ../../doc/coding_style.dox \
                          ../../doc/groups.dox \
-                         ../hugo \
-                         ../hugo/skeletons \
+                         ../lemon \
+                         ../lemon/skeletons \
                          ../test/test_tools.h \
                          klao/path.h \
Index: src/work/athos/preflow_push.hh
===================================================================
--- src/work/athos/preflow_push.hh	(revision 505)
+++ 	(revision )
@@ -1,486 +1,0 @@
-#ifndef HUGO_PREFLOW_PUSH_HH
-#define HUGO_PREFLOW_PUSH_HH
-
-//#include <algorithm>
-#include <list>
-#include <vector>
-#include <queue>
-//#include "pf_hiba.hh"
-//#include <marci_list_graph.hh>
-//#include <marci_graph_traits.hh>
-#include <invalid.h>
-#include <graph_wrapper.h>
-//#include <reverse_bfs.hh>
-
-using namespace std;
-
-namespace hugo {
-
-  template <typename Graph, typename T>
-  class preflow_push {
-
-    //Useful typedefs
-    typedef typename Graph::Node Node;
-    typedef typename Graph::NodeIt NodeIt;
-    typedef typename Graph::Edge Edge;
-    typedef typename Graph::OutEdgeIt OutEdgeIt;
-    typedef typename Graph::InEdgeIt InEdgeIt;
-    typedef typename Graph::EdgeMap<T> CapacityType;
-
-    typedef ResGraphWrapper<const Graph,int,CapacityType,CapacityType> ResGraphType;
-
-
-    //---------------------------------------------
-    //Parameters of the algorithm
-    //---------------------------------------------
-    //Fully examine an active node until excess becomes 0
-    enum node_examination_t {examine_full, examine_to_relabel};
-    //No more implemented yet:, examine_only_one_edge};
-    node_examination_t node_examination;
-    //Which implementation to be used
-    enum implementation_t {impl_fifo, impl_highest_label};
-    //No more implemented yet:};
-    implementation_t implementation;
-    //---------------------------------------------
-    //Parameters of the algorithm
-    //---------------------------------------------
- 
-  private:
-    //input
-    Graph& G;
-    Node s;
-    Node t;
-    CapacityType &capacity;
-
-    //output
-    CapacityType preflow;
-    T maxflow_value;
-  
-    //auxiliary variables for computation
-    //The number of the nodes
-    int number_of_nodes;
-    //A nodemap for the level
-    typename Graph::NodeMap<int> level;
-    //A nodemap for the excess
-    typename Graph::NodeMap<T> excess;
-    
-    //Number of nodes on each level
-    vector<int> num_of_nodes_on_level;
-    
-    //For the FIFO implementation
-    list<Node> fifo_nodes;
-    //For 'highest label' implementation
-    int highest_active;
-    //int second_highest_active;
-    vector< list<Node> > active_nodes;
-
-  public:
-  
-    //Constructing the object using the graph, source, sink and capacity vector
-    preflow_push(
-		      Graph& _G, 
-		      Node _s, 
-		      Node _t, 
-		      typename Graph::EdgeMap<T> & _capacity)
-      : G(_G), s(_s), t(_t), 
-	capacity(_capacity), 
-	preflow(_G),
-	//Counting the number of nodes
-	//number_of_nodes(count(G.first<EachNodeIt>())),
-	number_of_nodes(G.nodeNum()),
-
-	level(_G),
-	excess(_G)//,
-        // Default constructor: active_nodes()
-    { 
-      //Simplest parameter settings
-      node_examination = examine_full;//examine_to_relabel;//
-      //Which implementation to be usedexamine_full
-      implementation = impl_highest_label;//impl_fifo;
- 
-      //
-      num_of_nodes_on_level.resize(2*number_of_nodes-1);
-      num_of_nodes_on_level.clear();
-
-      switch(implementation){
-      case impl_highest_label :{
-	active_nodes.clear();
-	active_nodes.resize(2*number_of_nodes-1);
-	
-	break;
-      }
-      default:
-	break;
-      }
-
-    }
-
-    //Returns the value of a maximal flow 
-    T run();
-  
-    typename Graph::EdgeMap<T>  getmaxflow(){
-      return preflow;
-    }
-
-
-  private:
-    //For testing purposes only
-    //Lists the node_properties
-    void write_property_vector(typename Graph::NodeMap<T> a,
-			       //node_property_vector<Graph, T> a, 
-			       char* prop_name="property"){
-      for(NodeIt i=G.template first<NodeIt>(); G.valid(i); G.next(i)) {
-	cout<<"Node id.: "<<G.id(i)<<", "<<prop_name<<" value: "<<a[i]<<endl;
-      }
-      cout<<endl;
-    }
-    /*
-    //Modifies the excess of the node and makes sufficient changes
-    void modify_excess(const Node& a ,T v){
-      //T old_value=excess[a];
-      excess[a] += v;
-    }
-  
-    //This private procedure is supposed to modify the preflow on edge j
-    //by value v (which can be positive or negative as well) 
-    //and maintain the excess on the head and tail
-    //Here we do not check whether this is possible or not
-    void modify_preflow(Edge j, const T& v){
-
-      //Modifiyng the edge
-      preflow[j] += v;
-
-
-      //Modifiyng the head
-      modify_excess(G.head(j),v);
-	
-      //Modifiyng the tail
-      modify_excess(G.tail(j),-v);
-
-    }
-    */
-    //Gives the active node to work with 
-    //(depending on the implementation to be used)
-    Node get_active_node(){
-      
-
-      switch(implementation) {
-      case impl_highest_label : {
-
-	//First need to find the highest label for which there's an active node
-	while( highest_active>=0 && active_nodes[highest_active].empty() ){ 
-	  --highest_active;
-	}
-
-	if( highest_active>=0) {
-	  
-
-	  Node a=active_nodes[highest_active].front();
-	  active_nodes[highest_active].pop_front();
-	  
-	  return a;
-	}
-	else {
-	  return INVALID;
-	}
-	
-	break;
-	
-      }
-      case impl_fifo : {
-
-	if( ! fifo_nodes.empty() ) {
-	  Node a=fifo_nodes.front();
-	  fifo_nodes.pop_front();
-	  return a;
-	}
-	else {
-	  return INVALID;
-	}
-	break;
-      }
-      }
-      //
-      return INVALID;
-    }
-
-    //Puts node 'a' among the active nodes
-    void make_active(const Node& a){
-      //s and t never become active
-      if (a!=s && a!= t){
-	switch(implementation){
-	case impl_highest_label :
-	  active_nodes[level[a]].push_back(a);
-	  break;
-	case impl_fifo :
-	  fifo_nodes.push_back(a);
-	  break;
-	}
-
-      }
-
-      //Update highest_active label
-      if (highest_active<level[a]){
-	highest_active=level[a];
-      }
-
-    }
-
-    //Changes the level of node a and make sufficent changes
-    void change_level_to(Node a, int new_value){
-      int seged = level[a];
-      level.set(a,new_value);
-      --num_of_nodes_on_level[seged];
-      ++num_of_nodes_on_level[new_value];
-    }
-
-    //Collection of things useful (or necessary) to do before running
-
-    void preprocess(){
-
-      //---------------------------------------
-      //Initialize parameters
-      //---------------------------------------
-
-      //Setting starting preflow, level and excess values to zero
-      //This can be important, if the algorithm is run more then once
-      for(NodeIt i=G.template first<NodeIt>(); G.valid(i); G.next(i)) {
-        level.set(i,0);
-        excess.set(i,0);
-	for(OutEdgeIt j=G.template first<OutEdgeIt>(i); G.valid(j); G.next(j)) 
-	  preflow.set(j, 0);
-      }
-      num_of_nodes_on_level[0]=number_of_nodes;
-      highest_active=0;
-      //---------------------------------------
-      //Initialize parameters
-      //---------------------------------------
-
-      
-      //------------------------------------
-      //This is the only part that uses BFS
-      //------------------------------------
-
-      /*Reverse_bfs from t, to find the starting level.*/
-      //Copyright: Jacint
-      change_level_to(t,0);
-
-      std::queue<Node> bfs_queue;
-      bfs_queue.push(t);
-
-      while (!bfs_queue.empty()) {
-
-	Node v=bfs_queue.front();	
-	bfs_queue.pop();
-	int l=level[v]+1;
-
-	InEdgeIt e;
-	for(G.first(e,v); G.valid(e); G.next(e)) {
-	  Node w=G.tail(e);
-	  if ( level[w] == number_of_nodes && w != s ) {
-	    bfs_queue.push(w);
-	    //Node first=level_list[l];
-	    //if ( G.valid(first) ) left.set(first,w);
-	    //right.set(w,first);
-	    //level_list[l]=w;
-	    change_level_to(w, l);
-	    //level.set(w, l);
-	  }
-	}
-      }
-      change_level_to(s,number_of_nodes);
-      //level.set(s,number_of_nodes);
-
-      /*
-      //Setting starting level values using reverse bfs
-      reverse_bfs<Graph> rev_bfs(G,t);
-      rev_bfs.run();
-      //write_property_vector(rev_bfs.dist,"rev_bfs");
-      for(NodeIt i=G.template first<NodeIt>(); G.valid(i); G.next(i)) {
-        change_level_to(i,rev_bfs.dist(i));
-	//level.put(i,rev_bfs.dist.get(i));
-      }
-      */
-      //------------------------------------
-      //This is the only part that uses BFS
-      //------------------------------------
-      
-      
-      //Starting level of s
-      change_level_to(s,number_of_nodes);
-      //level.put(s,number_of_nodes);
-      
-      
-      //we push as much preflow from s as possible to start with
-      for(OutEdgeIt j=G.template first<OutEdgeIt>(s); G.valid(j); G.next(j)){ 
-	modify_preflow(j,capacity[j] );
-	make_active(G.head(j));
-	int lev=level[G.head(j)];
-	if(highest_active<lev){
-	  highest_active=lev;
-	}
-      }
-      //cout<<highest_active<<endl;
-    } 
-
-    
-    //If the preflow is less than the capacity on the given edge
-    //then it is an edge in the residual graph
-    bool is_admissible_forward_edge(Edge j, int& new_level){
-
-      if (capacity[j]>preflow[j]){
-	if(level[G.tail(j)]==level[G.head(j)]+1){
-	  return true;
-	}
-	else{
-	  if (level[G.head(j)] < new_level)
-	    new_level=level[G.head(j)];
-	}
-      }
-      return false;
-    }
-
-    //If the preflow is greater than 0 on the given edge
-    //then the edge reversd is an edge in the residual graph
-    bool is_admissible_backward_edge(Edge j, int& new_level){
-      
-      if (0<preflow[j]){
-	if(level[G.tail(j)]==level[G.head(j)]-1){
-	 
-	  return true;
-	}
-	else{
-	  if (level[G.tail(j)] < new_level)
-	    new_level=level[G.tail(j)];
-	}
-	
-      }
-      return false;
-    }
-
- 
-  };  //class preflow_push  
-
-  template<typename Graph, typename T>
-    T preflow_push<Graph, T>::run() {
-    
-    //We need a residual graph
-    ResGraphType res_graph(G, preflow, capacity);
-    
-    preprocess();
-    //write_property_vector(level,"level");
-    T e,v;
-    Node a;
-    while (a=get_active_node(), G.valid(a)){
-      
-      bool go_to_next_node=false;
-      e = excess[a];
-      while (!go_to_next_node){
-
-	//Initial value for the new level for the active node we are dealing with
-	int new_level=2*number_of_nodes;
-
-
-	//Out edges from node a
-	{
-	  ResGraphType::OutEdgeIt j=res_graph.first(j,a);
-	  while (res_graph.valid(j) && e){
-	    if (is_admissible_forward_edge(j,new_level)){
-	      v=min(e,res_graph.resCap(j));
-	      e -= v;
-	      //New node might become active
-	      if (excess[res_graph.head(j)]==0){
-		make_active(res_graph.head(j));
-	      }
-	      res_graph.augment(j,v);
-	      excess[res_graph.tail(j)] -= v;
-	      excess[res_graph.head(j)] += v;
-	    }
-	    res_graph.next(j);
-	  }
-	}
-
-	/*
-	//Out edges from node a
-	{
-	  OutEdgeIt j=G.template first<OutEdgeIt>(a);
-	  while (G.valid(j) && e){
-
-	    if (is_admissible_forward_edge(j,new_level)){
-	      v=min(e,capacity[j] - preflow[j]);
-	      e -= v;
-	      //New node might become active
-	      if (excess[G.head(j)]==0){
-		make_active(G.head(j));
-	      }
-	      modify_preflow(j,v);
-	    }
-	    G.next(j);
-	  }
-	}
-	//In edges to node a
-	{
-	  InEdgeIt j=G.template first<InEdgeIt>(a);
-	  while (G.valid(j) && e){
-	    if (is_admissible_backward_edge(j,new_level)){
-	      v=min(e,preflow[j]);
-	      e -= v;
-	      //New node might become active
-	      if (excess[G.tail(j)]==0){
-		make_active(G.tail(j));
-	      }
-	      modify_preflow(j,-v);
-	    }
-	    G.next(j);
-	  }
-	}
-	*/
-
-	//if (G.id(a)==999)
-	//cout<<new_level<<" e: "<<e<<endl;
-	//cout<<G.id(a)<<" "<<new_level<<endl;
-
-	if (0==e){
-	  //Saturating push
-	  go_to_next_node=true;
-	}
-	else{//If there is still excess in node a
-	  
-	  //change_level_to(a,new_level+1);
-	  
-	  //Level remains empty
-	  if (num_of_nodes_on_level[level[a]]==1){
-	    change_level_to(a,number_of_nodes);
-	    //go_to_next_node=True;
-	  }
-	  else{
-	    change_level_to(a,new_level+1);
-	    //increase_level(a);
-	  }
-	  
-    
-	  
-
-	  switch(node_examination){
-	  case examine_to_relabel:
-	    make_active(a);
-
-	    go_to_next_node = true;
-	    break;
-	  default:
-	    break;
-	  }
-	  
-    
-	
-	}//if (0==e)
-      }
-    }
-    maxflow_value = excess[t];
-    return maxflow_value;
-  }//run
-
-
-}//namespace hugo
-
-#endif //PREFLOW_PUSH_HH
Index: src/work/deba/main.cpp
===================================================================
--- src/work/deba/main.cpp	(revision 703)
+++ src/work/deba/main.cpp	(revision 922)
@@ -5,5 +5,5 @@
 
 using namespace std;
-using namespace hugo;
+using namespace lemon;
 
 
Index: src/work/peter/Makefile
===================================================================
--- src/work/peter/Makefile	(revision 690)
+++ src/work/peter/Makefile	(revision 922)
@@ -1,6 +1,6 @@
 hier: hierarchygraph.h hierarchygraph_test.cc
-	g++ -Wall -W -I../.. -I../klao -I../../hugo hierarchygraph_test.cc -o test
+	g++ -Wall -W -I../.. -I../klao -I../../lemon hierarchygraph_test.cc -o test
 
 edge: edgepathgraph_test.cc edgepathgraph.h
-	g++ -Wall -W -I../.. -I../klao -I../../hugo edgepathgraph_test.cc -o test
+	g++ -Wall -W -I../.. -I../klao -I../../lemon edgepathgraph_test.cc -o test