COIN-OR::LEMON - Graph Library

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


Ignore:
Timestamp:
04/17/04 00:00:11 (16 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:
1 edited

Legend:

Unmodified
Added
Removed
  • src/work/marci/graph_wrapper.h

    r341 r344  
    99  /// Graph wrappers
    1010
    11   /// The main parts of HUGOlib are the different graph structures,
     11  /// A main parts of HUGOlib are the different graph structures,
    1212  /// generic graph algorithms, graph concepts which couple these, and
    1313  /// graph wrappers. While the previous ones are more or less clear, the
    1414  /// latter notion needs further explanation.
    1515  /// Graph wrappers are graph classes which serve for considering graph
    16   /// structures in different ways. A short example makes the notion much more
    17   /// clear.
    18   /// Suppose that we have an instance \code g \endcode of a directed graph
    19   /// type say \code ListGraph \endcode and an algorithm
     16  /// structures in different ways. A short example makes the notion much
     17  /// clearer.
     18  /// Suppose that we have an instance \c g of a directed graph
     19  /// type say \c ListGraph and an algorithm
    2020  /// \code template<typename Graph> int algorithm(const Graph&); \endcode
    21   /// is needed to run on the reversed oriented graph.
    22   /// It can be expensive (in time or in memory usage) to copy
    23   /// \code g \endcode with the reversed orientation.
     21  /// is needed to run on the reversely oriented graph.
     22  /// It may be expensive (in time or in memory usage) to copy
     23  /// \c g with the reverse orientation.
    2424  /// Thus, a wrapper class
    2525  /// \code template<typename Graph> class RevGraphWrapper; \endcode is used.
     
    3030  /// int result=algorithm(rgw);
    3131  /// \endcode
    32   /// After running the algorithm, the original graph \code g \endcode
    33   /// is untouched. Thus the above used graph wrapper is to consider the
    34   /// original graph with reversed orientation.
     32  /// After running the algorithm, the original graph \c g
     33  /// remains untouched. Thus the graph wrapper used above is to consider the
     34  /// original graph with reverse orientation.
    3535  /// This techniques gives rise to an elegant code, and
    3636  /// based on stable graph wrappers, complex algorithms can be
    3737  /// implemented easily.
    3838  /// In flow, circulation and bipartite matching problems, the residual
    39   /// graph is of particualar significance. Combining a wrapper impleneting
    40   /// this, shortest path algorithms and mimimum mean cycle algorithms,
     39  /// graph is of particular importance. Combining a wrapper implementing
     40  /// this, shortest path algorithms and minimum mean cycle algorithms,
    4141  /// a range of weighted and cardinality optimization algorithms can be
    4242  /// obtained. For lack of space, for other examples,
    43   /// the interested user is referred to the detailed domumentation of graph
     43  /// the interested user is referred to the detailed documentation of graph
    4444  /// wrappers.
    45   /// The behavior of graph wrappers are very different. Some of them keep
     45  /// The behavior of graph wrappers can be very different. Some of them keep
    4646  /// capabilities of the original graph while in other cases this would be
    47   /// meaningless. This means that the concepts that they are model of depend
     47  /// meaningless. This means that the concepts that they are a model of depend
    4848  /// on the graph wrapper, and the wrapped graph(s).
    49   /// If an edge of \code rgw \endcode is deleted, this is carried out by
    50   /// deleting the corresponding edge of \code g \endcode. But for a residual
     49  /// If an edge of \c rgw is deleted, this is carried out by
     50  /// deleting the corresponding edge of \c g. But for a residual
    5151  /// graph, this operation has no sense.
    5252  /// Let we stand one more example here to simplify your work.
     
    5454  /// \code template<typename Graph> class RevGraphWrapper; \endcode
    5555  /// has constructor
    56   /// \code RevGraphWrapper(Graph& _g); \endcode.
     56  /// <tt> RevGraphWrapper(Graph& _g)</tt>.
    5757  /// This means that in a situation,
    58   /// when a \code const ListGraph& \endcode reference to a graph is given,
    59   /// then it have to be instatiated with Graph=const ListGraph.
     58  /// when a <tt> const ListGraph& </tt> reference to a graph is given,
     59  /// then it have to be instantiated with <tt>Graph=const ListGraph</tt>.
    6060  /// \code
    6161  /// int algorithm1(const ListGraph& g) {
Note: See TracChangeset for help on using the changeset viewer.