Index: src/work/marci/leda/comparison.cc
===================================================================
--- src/work/marci/leda/comparison.cc	(revision 617)
+++ src/work/marci/leda/comparison.cc	(revision 617)
@@ -0,0 +1,170 @@
+// -*- c++ -*-
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <cstdlib>
+
+#include <LEDA/graph.h>
+#include <LEDA/mcb_matching.h>
+#include <LEDA/list.h>
+#include <LEDA/graph_gen.h>
+
+#include <leda_graph_wrapper.h>
+#include <list_graph.h>
+//#include <smart_graph.h>
+//#include <dimacs.h>
+#include <hugo/time_measure.h>
+#include <for_each_macros.h>
+#include <hugo/graph_wrapper.h>
+#include <bipartite_graph_wrapper.h>
+#include <hugo/maps.h>
+#include <max_flow.h>
+
+/**
+ * Inicializalja a veletlenszamgeneratort.
+ * Figyelem, ez nem jo igazi random szamokhoz,
+ * erre ne bizzad a titkaidat!
+ */
+void random_init()
+{
+	unsigned int seed = getpid();
+	seed |= seed << 15;
+	seed ^= time(0);
+
+	srand(seed);
+}
+
+/**
+ * Egy veletlen int-et ad vissza 0 es m-1 kozott.
+ */
+int random(int m)
+{
+  return int( double(m) * rand() / (RAND_MAX + 1.0) );
+}
+
+using namespace hugo;
+
+int main() {
+  //for leda graph
+  leda::graph lg;
+  //lg.make_undirected();
+  typedef LedaGraphWrapper<leda::graph> Graph;
+  Graph g(lg);
+
+  //for UndirListGraph
+  //typedef UndirListGraph Graph; 
+  //Graph g;
+
+  typedef Graph::Node Node;
+  typedef Graph::NodeIt NodeIt;
+  typedef Graph::Edge Edge;
+  typedef Graph::EdgeIt EdgeIt;
+  typedef Graph::OutEdgeIt OutEdgeIt;
+
+  std::vector<Graph::Node> s_nodes;
+  std::vector<Graph::Node> t_nodes;
+
+  int a;
+  std::cout << "number of nodes in the first color class=";
+  std::cin >> a; 
+  int b;
+  std::cout << "number of nodes in the second color class=";
+  std::cin >> b; 
+  int m;
+  std::cout << "number of edges=";
+  std::cin >> m; 
+  int k;
+  std::cout << "A bipartite graph is a random group graph if the color classes \nA and B are partitiones to A_0, A_1, ..., A_{k-1} and B_0, B_1, ..., B_{k-1} \nas equally as possible \nand the edges from A_i goes to A_{i-1 mod k} and A_{i+1 mod k}.\n";
+  std::cout << "number of groups in LEDA random group graph=";
+  std::cin >> k; 
+  std::cout << std::endl;
+  
+  leda_list<leda_node> lS;
+  leda_list<leda_node> lT;
+  random_bigraph(lg, a, b, m, lS, lT, k);
+
+  Graph::NodeMap<int> ref_map(g, -1);
+  IterableBoolMap< Graph::NodeMap<int> > bipartite_map(ref_map);
+
+  //generating leda random group graph
+  leda_node ln;
+  forall(ln, lS) bipartite_map.insert(ln, false);
+  forall(ln, lT) bipartite_map.insert(ln, true);
+
+  //making bipartite graph
+  typedef BipartiteGraphWrapper<Graph> BGW;
+  BGW bgw(g, bipartite_map);
+
+
+  //st-wrapper
+  typedef stGraphWrapper<BGW> stGW;
+  stGW stgw(bgw);
+  ConstMap<stGW::Edge, int> const1map(1);
+  stGW::EdgeMap<int> flow(stgw);
+
+  Timer ts;
+
+  ts.reset();
+  FOR_EACH_LOC(stGW::EdgeIt, e, stgw) flow.set(e, 0);
+  MaxFlow<stGW, int, ConstMap<stGW::Edge, int>, stGW::EdgeMap<int> > 
+    max_flow_test(stgw, stgw.S_NODE, stgw.T_NODE, const1map, flow/*, true*/);
+  max_flow_test.run();
+  std::cout << "HUGO max matching algorithm based on preflow." << std::endl 
+	    << "Size of matching: " 
+	    << max_flow_test.flowValue() << std::endl;
+  std::cout << "elapsed time: " << ts << std::endl << std::endl;
+
+  ts.reset();  
+  leda_list<leda_edge> ml=MAX_CARD_BIPARTITE_MATCHING(lg);
+  std::cout << "LEDA max matching algorithm." << std::endl 
+	    << "Size of matching: " 
+	    << ml.size() << std::endl;
+  std::cout << "elapsed time: " << ts << std::endl << std::endl;
+
+//   ts.reset();
+//   FOR_EACH_LOC(stGW::EdgeIt, e, stgw) flow.set(e, 0);
+//   typedef ListGraph MutableGraph;
+//   while (max_flow_test.augmentOnBlockingFlow<MutableGraph>()) { }
+//   std::cout << "HUGO max matching algorithm based on blocking flow augmentation." 
+// 	    << std::endl << "Matching size: " 
+// 	    << max_flow_test.flowValue() << std::endl;
+//   std::cout << "elapsed time: " << ts << std::endl << std::endl;
+
+  {
+  ListGraph hg;
+  ListGraph::Node s=hg.addNode();  
+  ListGraph::Node t=hg.addNode();
+  BGW::NodeMap<ListGraph::Node> b_s_nodes(bgw);  
+  BGW::NodeMap<ListGraph::Node> b_t_nodes(bgw);
+  
+  FOR_EACH_INC_LOC(BGW::ClassNodeIt, n, bgw, BGW::S_CLASS) {
+    b_s_nodes.set(n, hg.addNode());
+    hg.addEdge(s, b_s_nodes[n]);
+  }
+  FOR_EACH_INC_LOC(BGW::ClassNodeIt, n, bgw, BGW::T_CLASS) {
+    b_t_nodes.set(n, hg.addNode());
+    hg.addEdge(b_t_nodes[n], t);
+  }
+
+  FOR_EACH_LOC(BGW::EdgeIt, e, bgw) 
+    hg.addEdge(b_s_nodes[bgw.tail(e)], b_t_nodes[bgw.head(e)]);
+
+  ConstMap<ListGraph::Edge, int> cm(1);
+  ListGraph::EdgeMap<int> flow(hg); //0
+  
+  Timer ts;
+
+  ts.reset();
+  MaxFlow<ListGraph, int, ConstMap<ListGraph::Edge, int>, 
+    ListGraph::EdgeMap<int> > 
+    max_flow_test(hg, s, t, cm, flow);
+  max_flow_test.run();
+  std::cout << "HUGO max matching algorithm on ListGraph by copying the graph, based on preflow." 
+	    << std::endl 
+	    << "Size of matching: " 
+	    << max_flow_test.flowValue() << std::endl;
+  std::cout << "elapsed time: " << ts << std::endl << std::endl;
+  }
+
+  return 0;
+}
Index: src/work/marci/leda/leda_graph_wrapper.h
===================================================================
--- src/work/marci/leda/leda_graph_wrapper.h	(revision 616)
+++ src/work/marci/leda/leda_graph_wrapper.h	(revision 617)
@@ -17,40 +17,25 @@
 #include <hugo/invalid.h>
 
-/// The namespace of HugoLib
 namespace hugo {
 
-  // @defgroup empty_graph The LedaGraphWrapper class
-  // @{
-
-  /// A graph wrapperstructure for wrapping LEDA graphs in HUGO.
-  
-  /// This graph wrapper class wraps LEDA graph and LEDA parametrized graph
-  /// and then the generic algorithms and wrappers of HUGO can be used 
+  /// \brief A graph wrapper structure for wrapping LEDA graphs in HUGO.
+  ///
+  /// This graph wrapper class wraps LEDA graphs and LEDA parametrized graphs
+  /// to satisfy HUGO graph concepts.
+  /// Then the generic HUGOlib algorithms and wrappers can be used 
   /// with LEDA graphs. 
-  /// This class provides all the common features of a grapf structure,
-  /// however completely without implementations or real data structures
-  /// behind the interface.
-  /// All graph algorithms should compile with this class, but it will not
-  /// run properly, of course.
-  ///
-  /// It can be used for checking the interface compatibility,
-  /// or it can serve as a skeleton of a new graph structure.
-  /// 
-  /// Also, you will find here the full documentation of a certain graph
-  /// feature, the documentation of a real graph imlementation
-  /// like @ref ListGraph or
-  /// @ref SmartGraph will just refer to this structure.
+  /// \ingroup gwrapper
   template<typename Graph>
   class LedaGraphWrapper
   {
   protected:
-    Graph* _graph;
-    LedaGraphWrapper() : _graph(0) { }
-    void setGraph(Graph& __graph) { _graph=&__graph; }
+    Graph* l_graph;
+    LedaGraphWrapper() : l_graph(0) { }
+    void setGraph(Graph& _l_graph) { l_graph=&_l_graph; }
   public:
    
         //LedaGraphWrapper() { }
-    LedaGraphWrapper(Graph& __graph) : _graph(&__graph) { }
-    LedaGraphWrapper(const LedaGraphWrapper &G) : _graph(G._graph) { }
+    LedaGraphWrapper(Graph& _l_graph) : l_graph(&_l_graph) { }
+    LedaGraphWrapper(const LedaGraphWrapper &G) : l_graph(G.l_graph) { }
 
     template <typename T> class NodeMap;
@@ -73,7 +58,7 @@
     protected:
       template <typename T> friend class NodeMap;
-      leda_node _n;
+      leda_node l_n;
     public: //FIXME
-      Node(leda_node __n) : _n(__n) { } 
+      Node(leda_node _l_n) : l_n(_l_n) { } 
     public:
       /// @warning The default constructor sets the iterator
@@ -81,9 +66,9 @@
       Node() {}   //FIXME
       /// Initialize the iterator to be invalid
-      Node(Invalid) : _n(0) { }
+      Node(Invalid) : l_n(0) { }
       //Node(const Node &) {} 
-      bool operator==(Node n) const { return _n==n._n; } //FIXME
-      bool operator!=(Node n) const { return _n!=n._n; } //FIXME
-      operator leda_node () { return _n; }
+      bool operator==(Node n) const { return l_n==n.l_n; } //FIXME
+      bool operator!=(Node n) const { return l_n!=n.l_n; } //FIXME
+      operator leda_node () { return l_n; }
     };
     
@@ -97,5 +82,5 @@
       NodeIt(Invalid i) : Node(i) {}
       /// Sets the iterator to the first node of \c G.
-      NodeIt(const LedaGraphWrapper &G) : Node(G._graph->first_node()) { }
+      NodeIt(const LedaGraphWrapper &G) : Node(G.l_graph->first_node()) { }
       //NodeIt(const NodeIt &) {} //FIXME
     };
@@ -106,7 +91,7 @@
     protected:
       template <typename T> friend class EdgeMap;
-      leda_edge _e;
+      leda_edge l_e;
     public: //FIXME
-      Edge(leda_edge __e) : _e(__e) { } 
+      Edge(leda_edge _l_e) : l_e(_l_e) { } 
     public:
       /// @warning The default constructor sets the iterator
@@ -114,9 +99,9 @@
       Edge() {}   //FIXME
       /// Initialize the iterator to be invalid
-      Edge(Invalid) : _e(0) {}
+      Edge(Invalid) : l_e(0) {}
       //Edge(const Edge &) {} 
-      bool operator==(Edge e) const { return _e==e._e; } //FIXME
-      bool operator!=(Edge e) const { return _e!=e._e; } //FIXME 
-      operator leda_edge () { return _e; }
+      bool operator==(Edge e) const { return l_e==e.l_e; } //FIXME
+      bool operator!=(Edge e) const { return l_e!=e.l_e; } //FIXME 
+      operator leda_edge () { return l_e; }
     };
     
@@ -136,5 +121,5 @@
       ///@param n the node
       ///@param G the graph
-      OutEdgeIt(const LedaGraphWrapper & G, Node n) : Edge(G._graph->first_adj_edge(n._n)) { }
+      OutEdgeIt(const LedaGraphWrapper & G, Node n) : Edge(G.l_graph->first_adj_edge(n.l_n)) { }
     };
 
@@ -146,5 +131,5 @@
       /// Initialize the iterator to be invalid
       InEdgeIt(Invalid i) : Edge(i) {}
-      InEdgeIt(const LedaGraphWrapper & G, Node n) : Edge(G._graph->first_in_edge(n._n)) { }
+      InEdgeIt(const LedaGraphWrapper & G, Node n) : Edge(G.l_graph->first_in_edge(n.l_n)) { }
     };
 
@@ -157,5 +142,5 @@
       /// Initialize the iterator to be invalid
       EdgeIt(Invalid i) : Edge(i) {}
-      EdgeIt(const LedaGraphWrapper & G) : Edge(G._graph->first_edge()) { }
+      EdgeIt(const LedaGraphWrapper & G) : Edge(G.l_graph->first_edge()) { }
     };
 
@@ -190,15 +175,15 @@
     /// Go to the next node.
     NodeIt &next(NodeIt &i) const { 
-      i._n=_graph->succ_node(i._n); 
+      i.l_n=l_graph->succ_node(i.l_n); 
       return i; 
     }
     /// Go to the next incoming edge.
     InEdgeIt &next(InEdgeIt &i) const { 
-      i._e=_graph->in_succ(i._e); 
+      i.l_e=l_graph->in_succ(i.l_e); 
       return i;
     }
     /// Go to the next outgoing edge.
     OutEdgeIt &next(OutEdgeIt &i) const { 
-      i._e=_graph->adj_succ(i._e); 
+      i.l_e=l_graph->adj_succ(i.l_e); 
       return i;
     }
@@ -206,5 +191,5 @@
     /// Go to the next edge.
     EdgeIt &next(EdgeIt &i) const {      
-      i._e=_graph->succ_edge(i._e); 
+      i.l_e=l_graph->succ_edge(i.l_e); 
       return i; 
     }
@@ -226,9 +211,9 @@
     ///Gives back the head node of an edge.
     Node head(Edge e) const { 
-      return Node(_graph->target(e._e)); 
+      return Node(l_graph->target(e.l_e)); 
     }
     ///Gives back the tail node of an edge.
     Node tail(Edge e) const { 
-      return Node(_graph->source(e._e)); 
+      return Node(l_graph->source(e.l_e)); 
     }
   
@@ -242,28 +227,28 @@
 
     /// Checks if a node iterator is valid
-    bool valid(Node n) const { return n._n; }
+    bool valid(Node n) const { return n.l_n; }
     /// Checks if an edge iterator is valid
-    bool valid(Edge e) const { return e._e; }
+    bool valid(Edge e) const { return e.l_e; }
 
     ///Gives back the \e id of a node.
-    int id(Node n) const { return n._n->id(); }
+    int id(Node n) const { return n.l_n->id(); }
     ///Gives back the \e id of an edge.
-    int id(Edge e) const { return e._e->id(); }
+    int id(Edge e) const { return e.l_e->id(); }
 
     //void setInvalid(Node &) const {};
     //void setInvalid(Edge &) const {};
   
-    Node addNode() const { return Node(_graph->new_node()); }
+    Node addNode() const { return Node(l_graph->new_node()); }
     Edge addEdge(Node tail, Node head) const { 
-      return Edge(_graph->new_edge(tail._n, head._n));
-    }
-    
-    void erase(Node n) const { _graph->del_node(n._n); }
-    void erase(Edge e) const { _graph->del_edge(e._e); }
-
-    void clear() const { _graph->clear(); }
-
-    int nodeNum() const { return _graph->number_of_nodes(); }
-    int edgeNum() const { return _graph->number_of_edges(); }
+      return Edge(l_graph->new_edge(tail.l_n, head.l_n));
+    }
+    
+    void erase(Node n) const { l_graph->del_node(n.l_n); }
+    void erase(Edge e) const { l_graph->del_edge(e.l_e); }
+
+    void clear() const { l_graph->clear(); }
+
+    int nodeNum() const { return l_graph->number_of_nodes(); }
+    int edgeNum() const { return l_graph->number_of_edges(); }
 
     ///Read/write map from the nodes to type \c T.
@@ -275,14 +260,14 @@
       typedef Node KeyType;
 
-      NodeMap(const LedaGraphWrapper &G) : leda_stuff(*(G._graph)) {}
-      NodeMap(const LedaGraphWrapper &G, T t) : leda_stuff(*(G._graph), t) {}
-
-      void set(Node i, T t) { leda_stuff[i._n]=t; }
-      T get(Node i) const { return leda_stuff[i._n]; }  //FIXME: Is it necessary
-      T &operator[](Node i) { return leda_stuff[i._n]; }
-      const T &operator[](Node i) const { return leda_stuff[i._n]; }
+      NodeMap(const LedaGraphWrapper &G) : leda_stuff(*(G.l_graph)) {}
+      NodeMap(const LedaGraphWrapper &G, T t) : leda_stuff(*(G.l_graph), t) {}
+
+      void set(Node i, T t) { leda_stuff[i.l_n]=t; }
+      T get(Node i) const { return leda_stuff[i.l_n]; }  //FIXME: Is it necessary
+      T &operator[](Node i) { return leda_stuff[i.l_n]; }
+      const T &operator[](Node i) const { return leda_stuff[i.l_n]; }
 
       void update() { /*leda_stuff.init(leda_stuff.get_graph());*/ }
-      //void update(T a) { leda_stuff.init(leda_stuff.get_graph()/**(G._graph)*/, a); }   //FIXME: Is it necessary
+      //void update(T a) { leda_stuff.init(leda_stuff.get_graph()/**(G.l_graph)*/, a); }   //FIXME: Is it necessary
     };
 
@@ -295,18 +280,23 @@
       typedef Edge KeyType;
 
-      EdgeMap(const LedaGraphWrapper &G) : leda_stuff(*(G._graph)) {}
-      EdgeMap(const LedaGraphWrapper &G, T t) : leda_stuff(*(G._graph), t) {}
-
-      void set(Edge i, T t) { leda_stuff[i._e]=t; }
-      T get(Edge i) const { return leda_stuff[i._e]; }  //FIXME: Is it necessary
-      T &operator[](Edge i) { return leda_stuff[i._e]; }
-      const T &operator[](Edge i) const { return leda_stuff[i._e]; }
+      EdgeMap(const LedaGraphWrapper &G) : leda_stuff(*(G.l_graph)) {}
+      EdgeMap(const LedaGraphWrapper &G, T t) : leda_stuff(*(G.l_graph), t) {}
+
+      void set(Edge i, T t) { leda_stuff[i.l_e]=t; }
+      T get(Edge i) const { return leda_stuff[i.l_e]; }  //FIXME: Is it necessary
+      T &operator[](Edge i) { return leda_stuff[i.l_e]; }
+      const T &operator[](Edge i) const { return leda_stuff[i.l_e]; }
 
       void update() { /*leda_stuff.init(leda_stuff.get_graph());*/ }
-      //void update(T a) { leda_stuff.init(leda_stuff.get_graph()/**(G._graph)*/, a); }   //FIXME: Is it necessary
+      //void update(T a) { leda_stuff.init(leda_stuff.get_graph()/**(G.l_graph)*/, a); }   //FIXME: Is it necessary
     };
 
   };
 
+
+  /// \brief LEDA graph template.
+  ///
+  /// This graph stucture uses LEDA graphs for physical storage.
+  /// \ingroup graphs
   template<typename Graph>
   class LedaGraph : public LedaGraphWrapper<Graph> {
@@ -320,25 +310,5 @@
   };
 
-  // @}
-
 } //namespace hugo
 
-
-
-// class EmptyBipGraph : public EmptyGraph
-// {
-//   class ANode {};
-//   class BNode {};
-
-//   ANode &next(ANode &) {}
-//   BNode &next(BNode &) {}
-
-//   ANode &getFirst(ANode &) const {}
-//   BNode &getFirst(BNode &) const {}
-
-//   enum NodeClass { A = 0, B = 1 };
-//   NodeClass getClass(Node n) {}
-
-// }
-
 #endif // HUGO_LEDA_GRAPH_WRAPPER_H
Index: src/work/marci/leda/makefile
===================================================================
--- src/work/marci/leda/makefile	(revision 616)
+++ src/work/marci/leda/makefile	(revision 617)
@@ -5,5 +5,5 @@
 LDFLAGS = -L$(LEDAROOT) -lG -lL -lm
 
-BINARIES = bipartite_matching_leda bipartite_matching_leda_gen
+BINARIES = bipartite_matching_leda bipartite_matching_leda_gen comparison
 
 include ../../makefile
