Index: src/work/Doxyfile
===================================================================
--- src/work/Doxyfile	(revision 604)
+++ src/work/Doxyfile	(revision 613)
@@ -401,5 +401,6 @@
 			 marci/bfs_dfs.h \
 	  		 marci/bfs_dfs_misc.h \
-			 jacint/graph_gen.h
+			 jacint/graph_gen.h \
+			 marci/max_bipartite_matching.h
 
 # If the value of the INPUT tag contains directories, you can use the 
Index: c/work/marci/bipartite_matching_try_2.cc
===================================================================
--- src/work/marci/bipartite_matching_try_2.cc	(revision 602)
+++ 	(revision )
@@ -1,128 +1,0 @@
-// -*- c++ -*-
-#include <iostream>
-#include <fstream>
-#include <vector>
-#include <cstdlib>
-
-#include <list_graph.h>
-//#include <smart_graph.h>
-//#include <dimacs.h>
-#include <hugo/time_measure.h>
-#include <for_each_macros.h>
-#include <bfs_dfs.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() {
-  //typedef UndirListGraph Graph; 
-  typedef BipartiteGraph<ListGraph> Graph;
-  
-  typedef Graph::Node Node;
-  typedef Graph::NodeIt NodeIt;
-  typedef Graph::Edge Edge;
-  typedef Graph::EdgeIt EdgeIt;
-  typedef Graph::OutEdgeIt OutEdgeIt;
-
-  Graph g;
-
-  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; 
-  
-  std::cout << "Generatig a random bipartite graph..." << std::endl;
-  for (int i=0; i<a; ++i) s_nodes.push_back(g.addNode(false));
-  for (int i=0; i<b; ++i) t_nodes.push_back(g.addNode(true));
-
-  random_init();
-  for(int i=0; i<m; ++i) {
-    g.addEdge(s_nodes[random(a)], t_nodes[random(b)]);
-  }
-
-//   std::cout << "Edges of the bipartite graph:" << std::endl;
-//   FOR_EACH_LOC(EdgeIt, e, g) std::cout << e << " ";
-//   std::cout << std::endl;
-
-//   std::cout << "Nodes:" << std::endl;
-//   FOR_EACH_LOC(Graph::NodeIt, v, g) std::cout << v << " ";
-//   std::cout << std::endl;
-//   std::cout << "Nodes in T:" << std::endl;
-//   FOR_EACH_INC_LOC(Graph::ClassNodeIt, v, g, Graph::T_CLASS) std::cout << v << " ";
-//   std::cout << std::endl;
-//   std::cout << "Nodes in S:" << std::endl;
-//   FOR_EACH_INC_LOC(Graph::ClassNodeIt, v, g, Graph::S_CLASS) std::cout << v << " ";
-//   std::cout << std::endl;
-
-//   std::cout << "Erasing the first node..." << std::endl;
-//   NodeIt n;
-//   g.first(n);
-//   g.erase(n);
-//   std::cout << "Nodes of the bipartite graph:" << std::endl;
-//   FOR_EACH_GLOB(n, g) std::cout << n << " ";
-//   std::cout << std::endl;
-
-//   std::cout << "Nodes in T:" << std::endl;
-//   FOR_EACH_INC_LOC(Graph::ClassNodeIt, v, g, Graph::T_CLASS) std::cout << v << " ";
-//   std::cout << std::endl;
-//   std::cout << "Nodes in S:" << std::endl;
-//   FOR_EACH_INC_LOC(Graph::ClassNodeIt, v, g, Graph::S_CLASS) std::cout << v << " ";
-//   std::cout << std::endl;
-
-  typedef stGraphWrapper<Graph> stGW;
-  stGW stgw(g);
-  ConstMap<stGW::Edge, int> const1map(1);
-
-  Timer ts;
-  ts.reset();
-  stGW::EdgeMap<int> flow(stgw);
-  MaxFlow<stGW, int, ConstMap<stGW::Edge, int>, stGW::EdgeMap<int> > 
-    max_flow_test(stgw, stgw.S_NODE, stgw.T_NODE, const1map, flow);
-  max_flow_test.run();
-//  while (max_flow_test.augmentOnShortestPath()) { }
-//  typedef ListGraph MutableGraph;
-//  while (max_flow_test.augmentOnBlockingFlow1<MutableGraph>()) {
-//  while (max_flow_test.augmentOnBlockingFlow2()) {
-//   std::cout << max_flow_test.flowValue() << std::endl;
-//  }
-  std::cout << "max flow value: " << max_flow_test.flowValue() << std::endl;
-  std::cout << "elapsed time: " << ts << std::endl;
-//   FOR_EACH_LOC(stGW::EdgeIt, e, stgw) { 
-//     if (flow[e]) std::cout << e << std::endl; 
-//   }
-//   std::cout << std::endl;
-
-  return 0;
-}
Index: src/work/marci/bipartite_matching_try_3.cc
===================================================================
--- src/work/marci/bipartite_matching_try_3.cc	(revision 602)
+++ src/work/marci/bipartite_matching_try_3.cc	(revision 613)
@@ -132,5 +132,5 @@
   FOR_EACH_LOC(Graph::EdgeIt, e, g) gef.set(e, 0); 
   FOR_EACH_LOC(Graph::NodeIt, n, g) gnf.set(n, 0); 
-  MaxMatching<Graph, ConstMap<Graph::Edge, int>, ConstMap<Graph::Node, int>, 
+  MaxBipartiteMatching<Graph, ConstMap<Graph::Edge, int>, ConstMap<Graph::Node, int>, 
     Graph::EdgeMap<int>, Graph::NodeMap<int> > 
     matching_test(g, ge1, gn1, gef, gnf);
@@ -147,5 +147,5 @@
   FOR_EACH_LOC(Graph::EdgeIt, e, g) gef.set(e, 0); 
   //FOR_EACH_LOC(Graph::NodeIt, n, g) gnf.set(n, 0); 
-  MaxMatching<Graph, ConstMap<Graph::Edge, int>, ConstMap<Graph::Node, int>, 
+  MaxBipartiteMatching<Graph, ConstMap<Graph::Edge, int>, ConstMap<Graph::Node, int>, 
     Graph::EdgeMap<int>, Graph::NodeMap<int> > 
     matching_test_1(g, ge1, gn1, gef/*, gnf*/);
Index: src/work/marci/makefile
===================================================================
--- src/work/marci/makefile	(revision 555)
+++ src/work/marci/makefile	(revision 613)
@@ -5,5 +5,5 @@
 
 LEDABINARIES = leda_graph_demo leda_bfs_dfs max_bipartite_matching_demo
-BINARIES = max_flow_demo iterator_bfs_demo macro_test lg_vs_sg bfsit_vs_byhand bipartite_graph_wrapper_test bipartite_matching_try bipartite_matching_try_2 bipartite_matching_try_3 top_sort_test
+BINARIES = max_flow_demo iterator_bfs_demo macro_test lg_vs_sg bfsit_vs_byhand bipartite_graph_wrapper_test bipartite_matching_try bipartite_matching_try_3 top_sort_test
 #gw_vs_not preflow_demo_boost edmonds_karp_demo_boost preflow_demo_jacint preflow_demo_athos edmonds_karp_demo_alpar preflow_demo_leda
 
Index: src/work/marci/max_bipartite_matching.h
===================================================================
--- src/work/marci/max_bipartite_matching.h	(revision 559)
+++ src/work/marci/max_bipartite_matching.h	(revision 613)
@@ -34,5 +34,6 @@
   // };
 
-  /// A bipartite matching class.
+  /// \brief A bipartite matching class.
+  ///
   /// This class reduces the matching problem to a flow problem and 
   /// a preflow is used on a wrapper. Such a generic approach means that 
@@ -40,7 +41,8 @@
   /// a similar way. Due to the efficiency of the preflow algorithm, an 
   /// efficient matching framework is obtained.
+  /// \ingroup galgs
   template <typename Graph, typename EdgeCap, typename NodeCap, 
 	    typename EdgeFlow, typename NodeFlow>
-  class MaxMatching {
+  class MaxBipartiteMatching {
   protected:
     //   EdgeCap* edge_cap;
@@ -66,5 +68,5 @@
     ///\bug Note that the values in _edge_flow and _node_flow have 
     /// to form a flow.
-    MaxMatching(Graph& _g, EdgeCap& _edge_cap, NodeCap& _node_cap, 
+    MaxBipartiteMatching(Graph& _g, EdgeCap& _edge_cap, NodeCap& _node_cap, 
 		EdgeFlow& _edge_flow, NodeFlow& _node_flow) : 
       stgw(_g), 
@@ -77,5 +79,5 @@
     ///\bug Note that the values in _edge_flow and _node_flow have 
     /// to form a flow.
-    MaxMatching(Graph& _g, EdgeCap& _edge_cap, NodeCap& _node_cap, 
+    MaxBipartiteMatching(Graph& _g, EdgeCap& _edge_cap, NodeCap& _node_cap, 
 		EdgeFlow& _edge_flow/*, NodeFlow& _node_flow*/) : 
       stgw(_g), 
@@ -85,5 +87,5 @@
       mf(stgw, stgw.S_NODE, stgw.T_NODE, cap, flow) { }
     /// The class have a nontrivial destructor.
-    ~MaxMatching() { if (node_flow) delete node_flow; }
+    ~MaxBipartiteMatching() { if (node_flow) delete node_flow; }
     /// run computes the max matching.
     void run() { mf.run(); } 
