1.1 --- a/demo/tight_edge_filter_map.h	Fri Apr 07 09:52:30 2006 +0000
     1.2 +++ b/demo/tight_edge_filter_map.h	Fri Apr 07 09:54:35 2006 +0000
     1.3 @@ -32,14 +32,14 @@
     1.4      which are tight w.r.t. a node-potential and 
     1.5      edge-distance.
     1.6      
     1.7 -    Let \f$G=(V,A)\f$ be a directed graph (graph for short) and 
     1.8 -    let \f$\mathbb{F}\f$ be a number type. 
     1.9 +    Let \f$ G=(V,A) \f$ be a directed graph (graph for short) and 
    1.10 +    let \f$ \mathbb{F} \f$ be a number type. 
    1.11      Given a distance function 
    1.12 -    \f$d:E\to\mathbb{F}\f$, 
    1.13 -    \f$\pi:V\to\mathbb{F}\f$ is said to be a potetial 
    1.14 -    w.r.t. \f$d\f$ 
    1.15 +    \f$ d:E\to\mathbb{F} \f$, 
    1.16 +    \f$ \pi:V\to\mathbb{F} \f$ is said to be a potetial 
    1.17 +    w.r.t. \f$ d \f$ 
    1.18      if and only if 
    1.19 -    \f$\pi(v)\le d(uv)+\pi(u)\f$ holds for each edge \f$uv\in E\f$ 
    1.20 +    \f$ \pi(v)\le d(uv)+\pi(u) \f$ holds for each edge \f$ uv\in E \f$ 
    1.21      (or the reverse inequality holds for each edge). 
    1.22      An edge is said to be tight if this inequality holds with equality, 
    1.23      and the map returns \c true exactly for those edges. 

     2.1 --- a/doc/groups.dox	Fri Apr 07 09:52:30 2006 +0000
     2.2 +++ b/doc/groups.dox	Fri Apr 07 09:54:35 2006 +0000
     2.3 @@ -141,6 +141,13 @@
     2.4  */
     2.5  
     2.6  /**
     2.7 +@defgroup matching Matching algorithms in graphs and bipartite graphs
     2.8 +@ingroup galgs
     2.9 +\brief This group describes the algorithms
    2.10 +for find matchings in graphs and bipartite graphs.
    2.11 +*/
    2.12 +
    2.13 +/**
    2.14  @defgroup exceptions Exceptions
    2.15  This group contains the exceptions thrown by LEMON library
    2.16  */

     3.1 --- a/lemon/bellman_ford.h	Fri Apr 07 09:52:30 2006 +0000
     3.2 +++ b/lemon/bellman_ford.h	Fri Apr 07 09:54:35 2006 +0000
     3.3 @@ -155,7 +155,7 @@
     3.4    /// that all edge is non-negative in the graph then the dijkstra algorithm
     3.5    /// should be used rather.
     3.6    ///
     3.7 -  /// The complexity of the algorithm is O(n * e).
     3.8 +  /// The maximal time complexity of the algorithm is \f$ O(ne) \f$.
     3.9    ///
    3.10    /// The type of the length is determined by the
    3.11    /// \ref concept::ReadMap::Value "Value" of the length map.

     4.1 --- a/lemon/bucket_heap.h	Fri Apr 07 09:52:30 2006 +0000
     4.2 +++ b/lemon/bucket_heap.h	Fri Apr 07 09:54:35 2006 +0000
     4.3 @@ -37,9 +37,9 @@
     4.4    /// is a data structure for storing items with specified values called \e
     4.5    /// priorities in such a way that finding the item with minimum priority is
     4.6    /// efficient. The bucket heap is very simple implementation, it can store
     4.7 -  /// only integer priorities and it stores for each priority in the [0..C]
     4.8 -  /// range a list of items. So it should be used only when the priorities
     4.9 -  /// are small. It is not intended to use as dijkstra heap.
    4.10 +  /// only integer priorities and it stores for each priority in the 
    4.11 +  /// \f$ [0..C) \f$ range a list of items. So it should be used only when 
    4.12 +  /// the priorities are small. It is not intended to use as dijkstra heap.
    4.13    ///
    4.14    /// \param _Item Type of the items to be stored.  
    4.15    /// \param _ItemIntMap A read and writable Item int map, used internally

     5.1 --- a/lemon/floyd_warshall.h	Fri Apr 07 09:52:30 2006 +0000
     5.2 +++ b/lemon/floyd_warshall.h	Fri Apr 07 09:54:35 2006 +0000
     5.3 @@ -159,7 +159,7 @@
     5.4    /// should be used from each node rather and if the graph is sparse and
     5.5    /// there are negative circles then the johnson algorithm.
     5.6    ///
     5.7 -  /// The complexity of this algorithm is O(n^3 + e).
     5.8 +  /// The complexity of this algorithm is \f$ O(n^3+e) \f$.
     5.9    ///
    5.10    /// The type of the length is determined by the
    5.11    /// \ref concept::ReadMap::Value "Value" of the length map.

     6.1 --- a/lemon/fredman_tarjan.h	Fri Apr 07 09:52:30 2006 +0000
     6.2 +++ b/lemon/fredman_tarjan.h	Fri Apr 07 09:54:35 2006 +0000
     6.3 @@ -44,8 +44,8 @@
     6.4  
     6.5    ///Default traits class of FredmanTarjan class.
     6.6    ///\param GR Graph type.
     6.7 -  ///\param LM Type of cost map.
     6.8 -  template<class GR, class LM>
     6.9 +  ///\param CM Type of cost map.
    6.10 +  template<class GR, class CM>
    6.11    struct FredmanTarjanDefaultTraits{
    6.12      ///The graph type the algorithm runs on. 
    6.13      typedef GR UGraph;
    6.14 @@ -53,9 +53,9 @@
    6.15  
    6.16      ///The type of the map that stores the edge costs.
    6.17      ///It must meet the \ref concept::ReadMap "ReadMap" concept.
    6.18 -    typedef LM CostMap;
    6.19 +    typedef CM CostMap;
    6.20      //The type of the cost of the edges.
    6.21 -    typedef typename LM::Value Value;
    6.22 +    typedef typename CM::Value Value;
    6.23      ///The type of the map that stores whether an edge is in the
    6.24      ///spanning tree or not.
    6.25  
    6.26 @@ -76,61 +76,60 @@
    6.27    
    6.28    ///%FredmanTarjan algorithm class to find a minimum spanning tree.
    6.29    
    6.30 -  /// \ingroup spantree
    6.31 -  ///This class provides an efficient implementation of %FredmanTarjan algorithm
    6.32 -  ///whitch is sometimes a bit quicker than the Prim algorithm on larger graphs.
    6.33 -  ///Due to the structure of the algorithm, it has less controll functions than
    6.34 -  ///Prim.
    6.35 +  /// \ingroup spantree 
    6.36    ///
    6.37 -  ///The running time is O(e*B(e,n)) where e is the number of edges, n is the
    6.38 -  ///number of nodes in the graph and B(e,n) is min { i | log^(i) n <= e/n}
    6.39 -  ///( log^(i+1) n = log(log^(i)) n )
    6.40 +  ///This class provides an efficient implementation of %FredmanTarjan
    6.41 +  ///algorithm whitch is sometimes a bit quicker than the Prim
    6.42 +  ///algorithm on larger graphs.  Due to the structure of the
    6.43 +  ///algorithm, it has less controll functions than Prim.
    6.44    ///
    6.45 -  ///The edge costs are passed to the algorithm using a
    6.46 -  ///\ref concept::ReadMap "ReadMap",
    6.47 -  ///so it is easy to change it to any kind of cost.
    6.48 +  /// The running time is \f$ O(e\beta(e,n)) \f$ where 
    6.49 +  /// \f$ \beta(e,n) = \min\{ i | \log^{i}(n) \le e/n\} \f$ and 
    6.50 +  /// \f$ \log^{i+1}(n)=\log(\log^{i}(n)) \f$
    6.51    ///
    6.52 -  ///The type of the cost is determined by the
    6.53 -  ///\ref concept::ReadMap::Value "Value" of the cost map.
    6.54 +  ///The edge costs are passed to the algorithm using a \ref
    6.55 +  ///concept::ReadMap "ReadMap", so it is easy to change it to any
    6.56 +  ///kind of cost.
    6.57 +  ///
    6.58 +  ///The type of the cost is determined by the \ref
    6.59 +  ///concept::ReadMap::Value "Value" of the cost map.
    6.60    ///
    6.61    ///\param GR The graph type the algorithm runs on. The default value
    6.62    ///is \ref ListUGraph. The value of GR is not used directly by
    6.63 -  ///FredmanTarjan, it is only passed to \ref FredmanTarjanDefaultTraits.
    6.64 -  ///
    6.65 -  ///\param LM This read-only UEdgeMap determines the costs of the
    6.66 -  ///edges. It is read once for each edge, so the map may involve in
    6.67 -  ///relatively time consuming process to compute the edge cost if
    6.68 -  ///it is necessary. The default map type is \ref
    6.69 -  ///concept::UGraph::UEdgeMap "UGraph::UEdgeMap<int>". The value
    6.70 -  ///of LM is not used directly by FredmanTarjan, it is only passed to \ref
    6.71 +  ///FredmanTarjan, it is only passed to \ref
    6.72    ///FredmanTarjanDefaultTraits.
    6.73    ///
    6.74 -  ///\param TR Traits class to set
    6.75 -  ///various data types used by the algorithm.  The default traits
    6.76 -  ///class is \ref FredmanTarjanDefaultTraits
    6.77 -  ///"FredmanTarjanDefaultTraits<GR,LM>".  See \ref
    6.78 -  ///FredmanTarjanDefaultTraits for the documentation of a FredmanTarjan traits
    6.79 -  ///class.
    6.80 +  ///\param CM This read-only UEdgeMap determines the costs of the
    6.81 +  ///edges. It is read once for each edge, so the map may involve in
    6.82 +  ///relatively time consuming process to compute the edge cost if it
    6.83 +  ///is necessary. The default map type is \ref
    6.84 +  ///concept::UGraph::UEdgeMap "UGraph::UEdgeMap<int>". The value of
    6.85 +  ///CM is not used directly by FredmanTarjan, it is only passed to
    6.86 +  ///\ref FredmanTarjanDefaultTraits.
    6.87 +  ///
    6.88 +  ///\param TR Traits class to set various data types used by the
    6.89 +  ///algorithm.  The default traits class is \ref
    6.90 +  ///FredmanTarjanDefaultTraits "FredmanTarjanDefaultTraits<GR,CM>".
    6.91 +  ///See \ref FredmanTarjanDefaultTraits for the documentation of a
    6.92 +  ///FredmanTarjan traits class.
    6.93    ///
    6.94    ///\author Balazs Attila Mihaly
    6.95  
    6.96  #ifdef DOXYGEN
    6.97    template <typename GR,
    6.98 -	    typename LM,
    6.99 +	    typename CM,
   6.100  	    typename TR>
   6.101  #else
   6.102    template <typename GR=ListUGraph,
   6.103 -	    typename LM=typename GR::template UEdgeMap<int>,
   6.104 -	    typename TR=FredmanTarjanDefaultTraits<GR,LM> >
   6.105 +	    typename CM=typename GR::template UEdgeMap<int>,
   6.106 +	    typename TR=FredmanTarjanDefaultTraits<GR,CM> >
   6.107  #endif
   6.108    class FredmanTarjan {
   6.109    public:
   6.110 -    /**
   6.111 -     * \brief \ref Exception for uninitialized parameters.
   6.112 -     *
   6.113 -     * This error represents problems in the initialization
   6.114 -     * of the parameters of the algorithms.
   6.115 -     */
   6.116 +    ///\brief \ref Exception for uninitialized parameters.
   6.117 +    ///
   6.118 +    ///This error represents problems in the initialization
   6.119 +    ///of the parameters of the algorithms.
   6.120      class UninitializedParameter : public lemon::UninitializedParameter {
   6.121      public:
   6.122        virtual const char* exceptionName() const {

     7.1 --- a/lemon/graph_adaptor.h	Fri Apr 07 09:52:30 2006 +0000
     7.2 +++ b/lemon/graph_adaptor.h	Fri Apr 07 09:54:35 2006 +0000
     7.3 @@ -45,10 +45,6 @@
     7.4    ///
     7.5    ///Base type for the Graph Adaptors
     7.6    ///
     7.7 -  ///\warning Graph adaptors are in even
     7.8 -  ///more experimental state than the other
     7.9 -  ///parts of the lib. Use them at you own risk.
    7.10 -  ///
    7.11    ///This is the base type for most of LEMON graph adaptors. 
    7.12    ///This class implements a trivial graph adaptor i.e. it only wraps the 
    7.13    ///functions and types of the graph. The purpose of this class is to 
    7.14 @@ -252,10 +248,6 @@
    7.15    ///\brief A graph adaptor which reverses the orientation of the edges.
    7.16    ///\ingroup graph_adaptors
    7.17    ///
    7.18 -  ///\warning Graph adaptors are in even more experimental 
    7.19 -  ///state than the other
    7.20 -  ///parts of the lib. Use them at you own risk.
    7.21 -  ///
    7.22    /// If \c g is defined as
    7.23    ///\code
    7.24    /// ListGraph g;
    7.25 @@ -648,9 +640,6 @@
    7.26    /// \brief A graph adaptor for hiding nodes and edges from a graph.
    7.27    /// \ingroup graph_adaptors
    7.28    /// 
    7.29 -  /// \warning Graph adaptors are in even more experimental state than the
    7.30 -  /// other parts of the lib. Use them at you own risk.
    7.31 -  /// 
    7.32    /// SubGraphAdaptor shows the graph with filtered node-set and 
    7.33    /// edge-set. If the \c checked parameter is true then it filters the edgeset
    7.34    /// to do not get invalid edges without source or target.
    7.35 @@ -770,10 +759,6 @@
    7.36    ///\brief An adaptor for hiding nodes from a graph.
    7.37    ///\ingroup graph_adaptors
    7.38    ///
    7.39 -  ///\warning Graph adaptors are in even more experimental state
    7.40 -  ///than the other
    7.41 -  ///parts of the lib. Use them at you own risk.
    7.42 -  ///
    7.43    ///An adaptor for hiding nodes from a graph.
    7.44    ///This adaptor specializes SubGraphAdaptor in the way that only
    7.45    ///the node-set 
    7.46 @@ -827,9 +812,6 @@
    7.47  
    7.48    ///\brief An adaptor for hiding edges from a graph.
    7.49    ///
    7.50 -  ///\warning Graph adaptors are in even more experimental state
    7.51 -  ///than the other parts of the lib. Use them at you own risk.
    7.52 -  ///
    7.53    ///An adaptor for hiding edges from a graph.
    7.54    ///This adaptor specializes SubGraphAdaptor in the way that
    7.55    ///only the edge-set 
    7.56 @@ -1479,36 +1461,37 @@
    7.57    ///
    7.58    ///\ingroup graph_adaptors
    7.59    ///
    7.60 -  ///An adaptor for composing the residual graph for
    7.61 -  ///directed flow and circulation problems. 
    7.62 -//   ///Let \f$ G=(V, A) \f$ be a directed graph and let \f$ F \f$ be a 
    7.63 -//   ///number type. Let moreover 
    7.64 -//   ///\f$ f,c:A\to F \f$, be functions on the edge-set. 
    7.65 -//   ///In the appications of ResGraphAdaptor, \f$ f \f$ usually stands for a 
    7.66 -//   ///flow and \f$ c \f$ for a capacity function.   
    7.67 -//   ///Suppose that a graph instange \c g of type 
    7.68 -//   ///\c ListGraph implements \f$ G \f$.
    7.69 -//   ///\code
    7.70 -//   /// ListGraph g;
    7.71 -//   ///\endcode
    7.72 -//   ///Then RevGraphAdaptor implements the graph structure with node-set 
    7.73 -//   ///\f$ V \f$ and edge-set \f$ A_{forward}\cup A_{backward} \f$, where 
    7.74 -//   ///\f$ A_{forward}=\{uv : uv\in A, f(uv)<c(uv)\} \f$ and 
    7.75 -//   ///\f$ A_{backward}=\{vu : uv\in A, f(uv)>0\} \f$, 
    7.76 -//   ///i.e. the so called residual graph. 
    7.77 -//   ///When we take the union \f$ A_{forward}\cup A_{backward} \f$, 
    7.78 -//   ///multilicities are counted, i.e. if an edge is in both 
    7.79 -//   ///\f$ A_{forward} \f$ and \f$ A_{backward} \f$, then in the adaptor it 
    7.80 -//   ///appears twice. The following code shows how such an instance can be 
    7.81 -//   ///constructed.
    7.82 -//   ///\code
    7.83 -//   /// typedef ListGraph Graph;
    7.84 -//   /// Graph::EdgeMap<int> f(g);
    7.85 -//   /// Graph::EdgeMap<int> c(g);
    7.86 -//   /// ResGraphAdaptor<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > ga(g);
    7.87 -//   ///\endcode
    7.88 -//   ///\author Marton Makai
    7.89 -//   ///
    7.90 +  ///An adaptor for composing the residual graph for directed flow and
    7.91 +  ///circulation problems.  Let \f$ G=(V, A) \f$ be a directed graph
    7.92 +  ///and let \f$ F \f$ be a number type. Let moreover \f$ f,c:A\to F \f$,
    7.93 +  ///be functions on the edge-set.
    7.94 +  ///
    7.95 +  ///In the appications of ResGraphAdaptor, \f$ f \f$ usually stands
    7.96 +  ///for a flow and \f$ c \f$ for a capacity function.  Suppose that a
    7.97 +  ///graph instange \c g of type \c ListGraph implements \f$ G \f$.
    7.98 +  ///
    7.99 +  ///\code 
   7.100 +  ///  ListGraph g;
   7.101 +  ///\endcode 
   7.102 +  ///
   7.103 +  ///Then RevGraphAdaptor implements the graph structure with node-set
   7.104 +  /// \f$ V \f$ and edge-set \f$ A_{forward}\cup A_{backward} \f$,
   7.105 +  ///where \f$ A_{forward}=\{uv : uv\in A, f(uv)<c(uv)\} \f$ and 
   7.106 +  /// \f$ A_{backward}=\{vu : uv\in A, f(uv)>0\} \f$, i.e. the so called
   7.107 +  ///residual graph.  When we take the union 
   7.108 +  /// \f$ A_{forward}\cup A_{backward} \f$, multilicities are counted, i.e. 
   7.109 +  ///if an edge is in both \f$ A_{forward} \f$ and \f$ A_{backward} \f$, 
   7.110 +  ///then in the adaptor it appears twice. The following code shows how 
   7.111 +  ///such an instance can be constructed.
   7.112 +  ///
   7.113 +  ///\code 
   7.114 +  ///  typedef ListGraph Graph; 
   7.115 +  ///  Graph::EdgeMap<int> f(g);
   7.116 +  ///  Graph::EdgeMap<int> c(g); 
   7.117 +  ///  ResGraphAdaptor<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > ga(g); 
   7.118 +  ///\endcode
   7.119 +  ///\author Marton Makai
   7.120 +  ///
   7.121    template<typename Graph, typename Number, 
   7.122  	   typename CapacityMap, typename FlowMap,
   7.123             typename Tolerance = Tolerance<Number> >
   7.124 @@ -1685,10 +1668,6 @@
   7.125    ///\brief For blocking flows.
   7.126    ///\ingroup graph_adaptors
   7.127    ///
   7.128 -  ///\warning Graph adaptors are in even more
   7.129 -  ///experimental state than the other
   7.130 -  ///parts of the lib. Use them at you own risk.
   7.131 -  ///
   7.132    ///This graph adaptor is used for on-the-fly 
   7.133    ///Dinits blocking flow computations.
   7.134    ///For each node, an out-edge is stored which is used when the 

     8.1 --- a/lemon/johnson.h	Fri Apr 07 09:52:30 2006 +0000
     8.2 +++ b/lemon/johnson.h	Fri Apr 07 09:54:35 2006 +0000
     8.3 @@ -191,8 +191,8 @@
     8.4    /// that all edge is non-negative in the graph then the dijkstra algorithm
     8.5    /// should be used from each node.
     8.6    ///
     8.7 -  /// The complexity of this algorithm is $O(n^2 * log(n) + n * log(n) * e)$ or
     8.8 -  /// with fibonacci heap O(n^2 * log(n) + n * e). Usually the fibonacci heap
     8.9 +  /// The complexity of this algorithm is \f$ O(n^2\log(n)+n\log(n)e) \f$ or
    8.10 +  /// with fibonacci heap \f$ O(n^2\log(n)+ne) \f$. Usually the fibonacci heap
    8.11    /// implementation is slower than either binary heap implementation or the 
    8.12    /// Floyd-Warshall algorithm. 
    8.13    ///

     9.1 --- a/lemon/max_matching.h	Fri Apr 07 09:52:30 2006 +0000
     9.2 +++ b/lemon/max_matching.h	Fri Apr 07 09:54:35 2006 +0000
     9.3 @@ -24,14 +24,13 @@
     9.4  #include <lemon/unionfind.h>
     9.5  #include <lemon/graph_utils.h>
     9.6  
     9.7 -///\ingroup galgs
     9.8 +///\ingroup matching
     9.9  ///\file
    9.10 -///\brief Maximum matching algorithm.
    9.11 +///\brief Maximum matching algorithm in undirected graph.
    9.12  
    9.13  namespace lemon {
    9.14  
    9.15 -  /// \addtogroup galgs
    9.16 -  /// @{
    9.17 +  /// \ingroup matching
    9.18  
    9.19    ///Edmonds' alternating forest maximum matching algorithm.
    9.20  
    9.21 @@ -564,7 +563,6 @@
    9.22  
    9.23    }
    9.24  
    9.25 -  /// @}
    9.26    
    9.27  } //END OF NAMESPACE LEMON
    9.28  

    10.1 --- a/lemon/min_cost_arborescence.h	Fri Apr 07 09:52:30 2006 +0000
    10.2 +++ b/lemon/min_cost_arborescence.h	Fri Apr 07 09:54:35 2006 +0000
    10.3 @@ -97,10 +97,10 @@
    10.4    /// more sources should be given for the algorithm and it will calculate
    10.5    /// the minimum cost subgraph which are union of arborescences with the
    10.6    /// given sources and spans all the nodes which are reachable from the
    10.7 -  /// sources. The time complexity of the algorithm is O(n^2 + e).
    10.8 +  /// sources. The time complexity of the algorithm is \f$ O(n^2+e) \f$.
    10.9    ///
   10.10    /// The algorithm provides also an optimal dual solution to arborescence
   10.11 -  /// that way the optimality of the algorithm can be proofed easily.
   10.12 +  /// that way the optimality of the solution can be proofed easily.
   10.13    ///
   10.14    /// \param _Graph The graph type the algorithm runs on. The default value
   10.15    /// is \ref ListGraph. The value of _Graph is not used directly by

    11.1 --- a/lemon/min_cut.h	Fri Apr 07 09:52:30 2006 +0000
    11.2 +++ b/lemon/min_cut.h	Fri Apr 07 09:54:35 2006 +0000
    11.3 @@ -839,9 +839,10 @@
    11.4    /// to test how many links have to be destroyed in the netaux to split it 
    11.5    /// at least two distinict subnetaux.
    11.6    ///
    11.7 -  /// The complexity of the algorithm is O(n*e*log(n)) but with Fibonacci 
    11.8 -  /// heap it can be decreased to O(n*e+n^2*log(n)). When the neutral capacity 
    11.9 -  /// map is used then it uses BucketHeap which results O(n*e) time complexity.
   11.10 +  /// The complexity of the algorithm is \f$ O(ne\log(n)) \f$ but with
   11.11 +  /// Fibonacci heap it can be decreased to \f$ O(ne+n^2\log(n)) \f$. When
   11.12 +  /// the neutral capacity map is used then it uses BucketHeap which
   11.13 +  /// results \f$ O(ne) \f$ time complexity.
   11.14  #ifdef DOXYGEN
   11.15    template <typename _Graph, typename _CapacityMap, typename _Traits>
   11.16  #else

    12.1 --- a/lemon/prim.h	Fri Apr 07 09:52:30 2006 +0000
    12.2 +++ b/lemon/prim.h	Fri Apr 07 09:54:35 2006 +0000
    12.3 @@ -136,7 +136,7 @@
    12.4    /// \ingroup spantree
    12.5    ///This class provides an efficient implementation of %Prim algorithm.
    12.6    ///
    12.7 -  ///The running time is O(e*log n) where e is the number of edges and
    12.8 +  ///The running time is \f$ O(e\log(n)) \f$ where e is the number of edges and
    12.9    ///n is the number of nodes in the graph.
   12.10    ///
   12.11    ///The edge costs are passed to the algorithm using a

    13.1 --- a/lemon/radix_sort.h	Fri Apr 07 09:52:30 2006 +0000
    13.2 +++ b/lemon/radix_sort.h	Fri Apr 07 09:54:35 2006 +0000
    13.3 @@ -208,8 +208,9 @@
    13.4    /// This implemented radix sort is a special quick sort which pivot value
    13.5    /// is choosen to partite the items on the next bit. This way, let be
    13.6    /// \c c the maximal capacity and \c n the number of the items in
    13.7 -  /// the container, the time complexity of the algorithm \c O(log(c)*n)
    13.8 -  /// and the additional space complexity is \c O(log(c)).
    13.9 +  /// the container, the time complexity of the algorithm 
   13.10 +  /// \f$ O(\log(c)n) \f$ and the additional space complexity is 
   13.11 +  /// \f$ O(\log(c)) \f$.
   13.12    ///
   13.13    /// \param first The begin of the given range.
   13.14    /// \param last The end of the given range.
   13.15 @@ -429,8 +430,8 @@
   13.16    /// by each bytes in forward direction which sorts the container by the
   13.17    /// whole value. This way, let be \c c the maximal capacity of the integer 
   13.18    /// type and \c n the number of the items in
   13.19 -  /// the container, the time complexity of the algorithm \c O(log(c)*n)
   13.20 -  /// and the additional space complexity is \c O(n).
   13.21 +  /// the container, the time complexity of the algorithm \f$ O(\log(c)n) \f$
   13.22 +  /// and the additional space complexity is \f$ O(n) \f$.
   13.23    ///
   13.24    /// This sorting algorithm is stable so the order of two equal element
   13.25    /// stay in the same order.

    14.1 --- a/lemon/ugraph_adaptor.h	Fri Apr 07 09:52:30 2006 +0000
    14.2 +++ b/lemon/ugraph_adaptor.h	Fri Apr 07 09:54:35 2006 +0000
    14.3 @@ -834,6 +834,8 @@
    14.4      return NodeSubUGraphAdaptor<const UGraph, const NodeFilterMap>(graph, nfm);
    14.5    }
    14.6  
    14.7 +  /// \ingroup graph_adaptors
    14.8 +  ///
    14.9    /// \brief An adaptor for hiding undirected edges from an undirected graph.
   14.10    ///
   14.11    /// \warning Graph adaptors are in even more experimental state