1.1 --- a/src/work/marci/graph_wrapper.h	Fri Apr 16 21:35:25 2004 +0000
     1.2 +++ b/src/work/marci/graph_wrapper.h	Fri Apr 16 22:00:11 2004 +0000
     1.3 @@ -8,19 +8,19 @@
     1.4  
     1.5    /// Graph wrappers
     1.6  
     1.7 -  /// The main parts of HUGOlib are the different graph structures, 
     1.8 +  /// A main parts of HUGOlib are the different graph structures, 
     1.9    /// generic graph algorithms, graph concepts which couple these, and 
    1.10    /// graph wrappers. While the previous ones are more or less clear, the 
    1.11    /// latter notion needs further explanation.
    1.12    /// Graph wrappers are graph classes which serve for considering graph 
    1.13 -  /// structures in different ways. A short example makes the notion much more 
    1.14 -  /// clear. 
    1.15 -  /// Suppose that we have an instance \code g \endcode of a directed graph
    1.16 -  /// type say \code ListGraph \endcode and an algorithm 
    1.17 +  /// structures in different ways. A short example makes the notion much 
    1.18 +  /// clearer. 
    1.19 +  /// Suppose that we have an instance \c g of a directed graph
    1.20 +  /// type say \c ListGraph and an algorithm 
    1.21    /// \code template<typename Graph> int algorithm(const Graph&); \endcode 
    1.22 -  /// is needed to run on the reversed oriented graph. 
    1.23 -  /// It can be expensive (in time or in memory usage) to copy 
    1.24 -  /// \code g \endcode with the reversed orientation. 
    1.25 +  /// is needed to run on the reversely oriented graph. 
    1.26 +  /// It may be expensive (in time or in memory usage) to copy 
    1.27 +  /// \c g with the reverse orientation. 
    1.28    /// Thus, a wrapper class
    1.29    /// \code template<typename Graph> class RevGraphWrapper; \endcode is used. 
    1.30    /// The code looks as follows
    1.31 @@ -29,34 +29,34 @@
    1.32    /// RevGraphWrapper<ListGraph> rgw(g);
    1.33    /// int result=algorithm(rgw);
    1.34    /// \endcode
    1.35 -  /// After running the algorithm, the original graph \code g \endcode 
    1.36 -  /// is untouched. Thus the above used graph wrapper is to consider the 
    1.37 -  /// original graph with reversed orientation. 
    1.38 +  /// After running the algorithm, the original graph \c g 
    1.39 +  /// remains untouched. Thus the graph wrapper used above is to consider the 
    1.40 +  /// original graph with reverse orientation. 
    1.41    /// This techniques gives rise to an elegant code, and 
    1.42    /// based on stable graph wrappers, complex algorithms can be 
    1.43    /// implemented easily. 
    1.44    /// In flow, circulation and bipartite matching problems, the residual 
    1.45 -  /// graph is of particualar significance. Combining a wrapper impleneting 
    1.46 -  /// this, shortest path algorithms and mimimum mean cycle algorithms, 
    1.47 +  /// graph is of particular importance. Combining a wrapper implementing 
    1.48 +  /// this, shortest path algorithms and minimum mean cycle algorithms, 
    1.49    /// a range of weighted and cardinality optimization algorithms can be 
    1.50    /// obtained. For lack of space, for other examples, 
    1.51 -  /// the interested user is referred to the detailed domumentation of graph 
    1.52 +  /// the interested user is referred to the detailed documentation of graph 
    1.53    /// wrappers. 
    1.54 -  /// The behavior of graph wrappers are very different. Some of them keep 
    1.55 +  /// The behavior of graph wrappers can be very different. Some of them keep 
    1.56    /// capabilities of the original graph while in other cases this would be 
    1.57 -  /// meaningless. This means that the concepts that they are model of depend 
    1.58 +  /// meaningless. This means that the concepts that they are a model of depend 
    1.59    /// on the graph wrapper, and the wrapped graph(s). 
    1.60 -  /// If an edge of \code rgw \endcode is deleted, this is carried out by 
    1.61 -  /// deleting the corresponding edge of \code g \endcode. But for a residual 
    1.62 +  /// If an edge of \c rgw is deleted, this is carried out by 
    1.63 +  /// deleting the corresponding edge of \c g. But for a residual 
    1.64    /// graph, this operation has no sense. 
    1.65    /// Let we stand one more example here to simplify your work. 
    1.66    /// wrapper class
    1.67    /// \code template<typename Graph> class RevGraphWrapper; \endcode 
    1.68    /// has constructor 
    1.69 -  /// \code RevGraphWrapper(Graph& _g); \endcode. 
    1.70 +  /// <tt> RevGraphWrapper(Graph& _g)</tt>. 
    1.71    /// This means that in a situation, 
    1.72 -  /// when a \code const ListGraph& \endcode reference to a graph is given, 
    1.73 -  /// then it have to be instatiated with Graph=const ListGraph.
    1.74 +  /// when a <tt> const ListGraph& </tt> reference to a graph is given, 
    1.75 +  /// then it have to be instantiated with <tt>Graph=const ListGraph</tt>.
    1.76    /// \code
    1.77    /// int algorithm1(const ListGraph& g) {
    1.78    ///   RevGraphWrapper<const ListGraph> rgw(g);