Changeset 344:9b24714c3b1c in lemon-0.x for src

Timestamp:

04/17/04 00:00:11 (20 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@463

Message:

Some cosmetic changes and spell checking.

File:

• src/work/marci/graph_wrapper.h (modified) (3 diffs)

src/work/marci/graph_wrapper.h

@@ -9 +9 @@
   /// Graph wrappers
 
-  /// The main parts of HUGOlib are the different graph structures, 
+  /// A main parts of HUGOlib are the different graph structures, 
   /// generic graph algorithms, graph concepts which couple these, and 
   /// graph wrappers. While the previous ones are more or less clear, the 
   /// latter notion needs further explanation.
   /// Graph wrappers are graph classes which serve for considering graph 
-  /// structures in different ways. A short example makes the notion much more 
-  /// clear. 
-  /// Suppose that we have an instance \code g \endcode of a directed graph
-  /// type say \code ListGraph \endcode and an algorithm 
+  /// structures in different ways. A short example makes the notion much 
+  /// clearer. 
+  /// Suppose that we have an instance \c g of a directed graph
+  /// type say \c ListGraph and an algorithm 
   /// \code template<typename Graph> int algorithm(const Graph&); \endcode 
-  /// is needed to run on the reversed oriented graph. 
-  /// It can be expensive (in time or in memory usage) to copy 
-  /// \code g \endcode with the reversed orientation. 
+  /// is needed to run on the reversely oriented graph. 
+  /// It may be expensive (in time or in memory usage) to copy 
+  /// \c g with the reverse orientation. 
   /// Thus, a wrapper class
   /// \code template<typename Graph> class RevGraphWrapper; \endcode is used. 
@@ -30 +30 @@
   /// int result=algorithm(rgw);
   /// \endcode
-  /// After running the algorithm, the original graph \code g \endcode 
-  /// is untouched. Thus the above used graph wrapper is to consider the 
-  /// original graph with reversed orientation. 
+  /// After running the algorithm, the original graph \c g 
+  /// remains untouched. Thus the graph wrapper used above is to consider the 
+  /// original graph with reverse orientation. 
   /// This techniques gives rise to an elegant code, and 
   /// based on stable graph wrappers, complex algorithms can be 
   /// implemented easily. 
   /// In flow, circulation and bipartite matching problems, the residual 
-  /// graph is of particualar significance. Combining a wrapper impleneting 
-  /// this, shortest path algorithms and mimimum mean cycle algorithms, 
+  /// graph is of particular importance. Combining a wrapper implementing 
+  /// this, shortest path algorithms and minimum mean cycle algorithms, 
   /// a range of weighted and cardinality optimization algorithms can be 
   /// obtained. For lack of space, for other examples, 
-  /// the interested user is referred to the detailed domumentation of graph 
+  /// the interested user is referred to the detailed documentation of graph 
   /// wrappers. 
-  /// The behavior of graph wrappers are very different. Some of them keep 
+  /// The behavior of graph wrappers can be very different. Some of them keep 
   /// capabilities of the original graph while in other cases this would be 
-  /// meaningless. This means that the concepts that they are model of depend 
+  /// meaningless. This means that the concepts that they are a model of depend 
   /// on the graph wrapper, and the wrapped graph(s). 
-  /// If an edge of \code rgw \endcode is deleted, this is carried out by 
-  /// deleting the corresponding edge of \code g \endcode. But for a residual 
+  /// If an edge of \c rgw is deleted, this is carried out by 
+  /// deleting the corresponding edge of \c g. But for a residual 
   /// graph, this operation has no sense. 
   /// Let we stand one more example here to simplify your work. 
@@ -54 +54 @@
   /// \code template<typename Graph> class RevGraphWrapper; \endcode 
   /// has constructor 
-  /// \code RevGraphWrapper(Graph& _g); \endcode. 
+  /// <tt> RevGraphWrapper(Graph& _g)</tt>. 
   /// This means that in a situation, 
-  /// when a \code const ListGraph& \endcode reference to a graph is given, 
-  /// then it have to be instatiated with Graph=const ListGraph.
+  /// when a <tt> const ListGraph& </tt> reference to a graph is given, 
+  /// then it have to be instantiated with <tt>Graph=const ListGraph</tt>.
   /// \code
   /// int algorithm1(const ListGraph& g) {