1.1 --- a/lemon/hao_orlin.h	Thu Mar 05 10:13:20 2009 +0000
     1.2 +++ b/lemon/hao_orlin.h	Sun Mar 29 23:08:20 2009 +0200
     1.3 @@ -57,27 +57,27 @@
     1.4    /// undirected graph you can run just the first phase of the
     1.5    /// algorithm or you can use the algorithm of Nagamochi and Ibaraki
     1.6    /// which solves the undirected problem in
     1.7 -  /// \f$ O(nm + n^2 \log(n)) \f$ time: it is implemented in the
     1.8 +  /// \f$ O(nm + n^2 \log n) \f$ time: it is implemented in the
     1.9    /// NagamochiIbaraki algorithm class.
    1.10    ///
    1.11 -  /// \param _Digraph is the graph type of the algorithm.
    1.12 -  /// \param _CapacityMap is an edge map of capacities which should
    1.13 -  /// be any numreric type. The default type is _Digraph::ArcMap<int>.
    1.14 -  /// \param _Tolerance is the handler of the inexact computation. The
    1.15 -  /// default type for this is Tolerance<CapacityMap::Value>.
    1.16 +  /// \param GR The digraph class the algorithm runs on.
    1.17 +  /// \param CAP An arc map of capacities which can be any numreric type.
    1.18 +  /// The default type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
    1.19 +  /// \param TOL Tolerance class for handling inexact computations. The
    1.20 +  /// default tolerance type is \ref Tolerance "Tolerance<CAP::Value>".
    1.21  #ifdef DOXYGEN
    1.22 -  template <typename _Digraph, typename _CapacityMap, typename _Tolerance>
    1.23 +  template <typename GR, typename CAP, typename TOL>
    1.24  #else
    1.25 -  template <typename _Digraph,
    1.26 -            typename _CapacityMap = typename _Digraph::template ArcMap<int>,
    1.27 -            typename _Tolerance = Tolerance<typename _CapacityMap::Value> >
    1.28 +  template <typename GR,
    1.29 +            typename CAP = typename GR::template ArcMap<int>,
    1.30 +            typename TOL = Tolerance<typename CAP::Value> >
    1.31  #endif
    1.32    class HaoOrlin {
    1.33    private:
    1.34  
    1.35 -    typedef _Digraph Digraph;
    1.36 -    typedef _CapacityMap CapacityMap;
    1.37 -    typedef _Tolerance Tolerance;
    1.38 +    typedef GR Digraph;
    1.39 +    typedef CAP CapacityMap;
    1.40 +    typedef TOL Tolerance;
    1.41  
    1.42      typedef typename CapacityMap::Value Value;
    1.43  
    1.44 @@ -817,7 +817,7 @@
    1.45  
    1.46      /// \name Execution control
    1.47      /// The simplest way to execute the algorithm is to use
    1.48 -    /// one of the member functions called \c run(...).
    1.49 +    /// one of the member functions called \ref run().
    1.50      /// \n
    1.51      /// If you need more control on the execution,
    1.52      /// first you must call \ref init(), then the \ref calculateIn() or