Index: src/work/marci/graph_wrapper.h
===================================================================
--- src/work/marci/graph_wrapper.h (revision 341)
+++ src/work/marci/graph_wrapper.h (revision 344)
@@ -9,17 +9,17 @@
/// 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 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 class RevGraphWrapper; \endcode is used.
@@ -30,23 +30,23 @@
/// 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,8 +54,8 @@
/// \code template class RevGraphWrapper; \endcode
/// has constructor
- /// \code RevGraphWrapper(Graph& _g); \endcode.
+ /// ` RevGraphWrapper(Graph& _g)`.
/// 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 ` const ListGraph& ` reference to a graph is given,
+ /// then it have to be instantiated with `Graph=const ListGraph`.
/// \code
/// int algorithm1(const ListGraph& g) {