Index: doc/groups.dox
===================================================================
 doc/groups.dox (revision 959)
+++ doc/groups.dox (revision 961)
@@ 264,4 +264,12 @@
/**
+@defgroup matrices Matrices
+@ingroup datas
+\brief Two dimensional data storages implemented in LEMON.
+
+This group contains two dimensional data storages implemented in LEMON.
+*/
+
+/**
@defgroup auxdat Auxiliary Data Structures
@ingroup datas
@@ 284,12 +292,4 @@
rectangular bounding box of a set of \ref lemon::dim2::Point
"dim2::Point"'s.
*/

/**
@defgroup matrices Matrices
@ingroup auxdat
\brief Two dimensional data storages implemented in LEMON.

This group contains two dimensional data storages implemented in LEMON.
*/
@@ 327,8 +327,4 @@
but the digraph should not contain directed cycles with negative total
length.
  \ref FloydWarshall "FloydWarshall" and \ref Johnson "Johnson" algorithms
 for solving the \e allpairs \e shortest \e paths \e problem when arc
 lenghts can be either positive or negative, but the digraph should
 not contain directed cycles with negative total length.
 \ref Suurballe A successive shortest path algorithm for finding
arcdisjoint paths between two nodes having minimum total length.
@@ 364,18 +360,8 @@
\f[ 0 \leq f(uv) \leq cap(uv) \quad \forall uv\in A \f]
LEMON contains several algorithms for solving maximum flow problems:
 \ref EdmondsKarp EdmondsKarp algorithm
 \ref edmondskarp72theoretical.
 \ref Preflow GoldbergTarjan's preflow pushrelabel algorithm
 \ref goldberg88newapproach.
 \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees
 \ref dinic70algorithm, \ref sleator83dynamic.
 \ref GoldbergTarjan !Preflow pushrelabel algorithm with dynamic trees
 \ref goldberg88newapproach, \ref sleator83dynamic.

In most cases the \ref Preflow algorithm provides the
fastest method for computing a maximum flow. All implementations
also provide functions to query the minimum cut, which is the dual
problem of maximum flow.
+\ref Preflow is an efficient implementation of GoldbergTarjan's
+preflow pushrelabel algorithm \ref goldberg88newapproach for finding
+maximum flows. It also provides functions to query the minimum cut,
+which is the dual problem of maximum flow.
\ref Circulation is a preflow pushrelabel algorithm implemented directly
@@ 434,6 +420,4 @@
 \ref HaoOrlin "HaoOrlin algorithm" for calculating minimum cut
in directed graphs.
 \ref NagamochiIbaraki "NagamochiIbaraki algorithm" for
 calculating minimum cut in undirected graphs.
 \ref GomoryHu "GomoryHu tree computation" for calculating
allpairs minimum cut in undirected graphs.
@@ 465,17 +449,17 @@
LEMON contains three algorithms for solving the minimum mean cycle problem:
 \ref KarpMmc Karp's original algorithm \ref amo93networkflows,
+ \ref Karp "Karp"'s original algorithm \ref amo93networkflows,
\ref dasdan98minmeancycle.
 \ref HartmannOrlinMmc HartmannOrlin's algorithm, which is an improved
+ \ref HartmannOrlin "HartmannOrlin"'s algorithm, which is an improved
version of Karp's algorithm \ref dasdan98minmeancycle.
 \ref HowardMmc Howard's policy iteration algorithm
+ \ref Howard "Howard"'s policy iteration algorithm
\ref dasdan98minmeancycle.
In practice, the \ref HowardMmc "Howard" algorithm proved to be by far the
most efficient one, though the best known theoretical bound on its running
time is exponential.
Both \ref KarpMmc "Karp" and \ref HartmannOrlinMmc "HartmannOrlin" algorithms
run in time O(ne) and use space O(n^{2}+e), but the latter one is
typically faster due to the applied early termination scheme.
+In practice, the Howard algorithm proved to be by far the most efficient
+one, though the best known theoretical bound on its running time is
+exponential.
+Both Karp and HartmannOrlin algorithms run in time O(ne) and use space
+O(n^{2}+e), but the latter one is typically faster due to the
+applied early termination scheme.
*/
@@ 498,14 +482,4 @@
The matching algorithms implemented in LEMON:
 \ref MaxBipartiteMatching HopcroftKarp augmenting path algorithm
 for calculating maximum cardinality matching in bipartite graphs.
 \ref PrBipartiteMatching Pushrelabel algorithm
 for calculating maximum cardinality matching in bipartite graphs.
 \ref MaxWeightedBipartiteMatching
 Successive shortest path algorithm for calculating maximum weighted
 matching and maximum weighted bipartite matching in bipartite graphs.
 \ref MinCostMaxBipartiteMatching
 Successive shortest path algorithm for calculating minimum cost maximum
 matching in bipartite graphs.
 \ref MaxMatching Edmond's blossom shrinking algorithm for calculating
maximum cardinality matching in general graphs.
@@ 552,13 +526,4 @@
/**
@defgroup approx Approximation Algorithms
@ingroup algs
\brief Approximation algorithms.

This group contains the approximation and heuristic algorithms
implemented in LEMON.
*/

/**
@defgroup auxalg Auxiliary Algorithms
@ingroup algs
@@ 589,21 +554,4 @@
The currently supported solvers are \ref glpk, \ref clp, \ref cbc,
\ref cplex, \ref soplex.
*/

/**
@defgroup lp_utils Tools for Lp and Mip Solvers
@ingroup lp_group
\brief Helper tools to the Lp and Mip solvers.

This group adds some helper tools to general optimization framework
implemented in LEMON.
*/

/**
@defgroup metah Metaheuristics
@ingroup gen_opt_group
\brief Metaheuristics for LEMON library.

This group contains some metaheuristic optimization tools.
*/