COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Ticket #331: 331-doc-impr2-e20173729589.patch

File 331-doc-impr2-e20173729589.patch, 28.6 KB (added by Peter Kovacs, 15 years ago)

  • doc/min_cost_flow.dox 

    # HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1258132206 -3600
# Node ID e201737295892296801648f7302dd0b3e65d6beb
# Parent  9ae88e7c04a7188bed92911c7eb2ea90d065d2e6
Small doc fixes in several files (#331)

diff --git a/doc/min_cost_flow.dox b/doc/min_cost_flow.dox
    a b  
    7878   - if \f$lower(uv)<f(uv)<upper(uv)\f$, then \f$cost^\pi(uv)=0\f$;
    7979   - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.
    8080 - For all \f$u\in V\f$ nodes:
    81    - \f$\pi(u)<=0\f$;
     81   - \f$\pi(u)\leq 0\f$;
    8282   - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
    8383     then \f$\pi(u)=0\f$.
    8484 
    … …  
    145145   - if \f$lower(uv)<f(uv)<upper(uv)\f$, then \f$cost^\pi(uv)=0\f$;
    146146   - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.
    147147 - For all \f$u\in V\f$ nodes:
    148    - \f$\pi(u)>=0\f$;
     148   - \f$\pi(u)\geq 0\f$;
    149149   - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
    150150     then \f$\pi(u)=0\f$.
    151151

  • lemon/bellman_ford.h 

    diff --git a/lemon/bellman_ford.h b/lemon/bellman_ford.h
    a b  
    299299    ///
    300300    /// \ref named-templ-param "Named parameter" for setting
    301301    /// \c OperationTraits type.
    302     /// For more information see \ref BellmanFordDefaultOperationTraits.
     302    /// For more information, see \ref BellmanFordDefaultOperationTraits.
    303303    template <class T>
    304304    struct SetOperationTraits
    305305      : public BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> > {
    … …  
    717717    /// is not reached from the root(s) or if \c v is a root.
    718718    ///
    719719    /// The shortest path tree used here is equal to the shortest path
    720     /// tree used in \ref predNode() and \predMap().
     720    /// tree used in \ref predNode() and \ref predMap().
    721721    ///
    722722    /// \pre Either \ref run() or \ref init() must be called before
    723723    /// using this function.
    … …  
    732732    /// is not reached from the root(s) or if \c v is a root.
    733733    ///
    734734    /// The shortest path tree used here is equal to the shortest path
    735     /// tree used in \ref predArc() and \predMap().
     735    /// tree used in \ref predArc() and \ref predMap().
    736736    ///
    737737    /// \pre Either \ref run() or \ref init() must be called before
    738738    /// using this function.

  • lemon/bfs.h 

    diff --git a/lemon/bfs.h b/lemon/bfs.h
    a b  
    6363
    6464    ///The type of the map that indicates which nodes are processed.
    6565    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    66     ///By default it is a NullMap.
     66    ///By default, it is a NullMap.
    6767    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    6868    ///Instantiates a \c ProcessedMap.
    6969
    … …  
    852852
    853853    ///The type of the map that indicates which nodes are processed.
    854854    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    855     ///By default it is a NullMap.
     855    ///By default, it is a NullMap.
    856856    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    857857    ///Instantiates a ProcessedMap.
    858858

  • lemon/circulation.h 

    diff --git a/lemon/circulation.h b/lemon/circulation.h
    a b  
    306306    /// The Elevator should have standard constructor interface to be
    307307    /// able to automatically created by the algorithm (i.e. the
    308308    /// digraph and the maximum level should be passed to it).
    309     /// However an external elevator object could also be passed to the
     309    /// However, an external elevator object could also be passed to the
    310310    /// algorithm with the \ref elevator(Elevator&) "elevator()" function
    311311    /// before calling \ref run() or \ref init().
    312312    /// \sa SetElevator

  • lemon/concepts/digraph.h 

    diff --git a/lemon/concepts/digraph.h b/lemon/concepts/digraph.h
    a b  
    107107      /// Iterator class for the nodes.
    108108
    109109      /// This iterator goes through each node of the digraph.
    110       /// Its usage is quite simple, for example you can count the number
     110      /// Its usage is quite simple, for example, you can count the number
    111111      /// of nodes in a digraph \c g of type \c %Digraph like this:
    112112      ///\code
    113113      /// int count=0;
    … …  
    196196
    197197      /// This iterator goes trough the \e outgoing arcs of a certain node
    198198      /// of a digraph.
    199       /// Its usage is quite simple, for example you can count the number
     199      /// Its usage is quite simple, for example, you can count the number
    200200      /// of outgoing arcs of a node \c n
    201201      /// in a digraph \c g of type \c %Digraph as follows.
    202202      ///\code
    … …  
    241241
    242242      /// This iterator goes trough the \e incoming arcs of a certain node
    243243      /// of a digraph.
    244       /// Its usage is quite simple, for example you can count the number
     244      /// Its usage is quite simple, for example, you can count the number
    245245      /// of incoming arcs of a node \c n
    246246      /// in a digraph \c g of type \c %Digraph as follows.
    247247      ///\code
    … …  
    285285      /// Iterator class for the arcs.
    286286
    287287      /// This iterator goes through each arc of the digraph.
    288       /// Its usage is quite simple, for example you can count the number
     288      /// Its usage is quite simple, for example, you can count the number
    289289      /// of arcs in a digraph \c g of type \c %Digraph as follows:
    290290      ///\code
    291291      /// int count=0;

  • lemon/concepts/graph.h 

    diff --git a/lemon/concepts/graph.h b/lemon/concepts/graph.h
    a b  
    140140      /// Iterator class for the nodes.
    141141
    142142      /// This iterator goes through each node of the graph.
    143       /// Its usage is quite simple, for example you can count the number
     143      /// Its usage is quite simple, for example, you can count the number
    144144      /// of nodes in a graph \c g of type \c %Graph like this:
    145145      ///\code
    146146      /// int count=0;
    … …  
    228228      /// Iterator class for the edges.
    229229
    230230      /// This iterator goes through each edge of the graph.
    231       /// Its usage is quite simple, for example you can count the number
     231      /// Its usage is quite simple, for example, you can count the number
    232232      /// of edges in a graph \c g of type \c %Graph as follows:
    233233      ///\code
    234234      /// int count=0;
    … …  
    272272
    273273      /// This iterator goes trough the incident undirected edges
    274274      /// of a certain node of a graph.
    275       /// Its usage is quite simple, for example you can compute the
     275      /// Its usage is quite simple, for example, you can compute the
    276276      /// degree (i.e. the number of incident edges) of a node \c n
    277277      /// in a graph \c g of type \c %Graph as follows.
    278278      ///
    … …  
    369369      /// Iterator class for the arcs.
    370370
    371371      /// This iterator goes through each directed arc of the graph.
    372       /// Its usage is quite simple, for example you can count the number
     372      /// Its usage is quite simple, for example, you can count the number
    373373      /// of arcs in a graph \c g of type \c %Graph as follows:
    374374      ///\code
    375375      /// int count=0;
    … …  
    413413
    414414      /// This iterator goes trough the \e outgoing directed arcs of a
    415415      /// certain node of a graph.
    416       /// Its usage is quite simple, for example you can count the number
     416      /// Its usage is quite simple, for example, you can count the number
    417417      /// of outgoing arcs of a node \c n
    418418      /// in a graph \c g of type \c %Graph as follows.
    419419      ///\code
    … …  
    461461
    462462      /// This iterator goes trough the \e incoming directed arcs of a
    463463      /// certain node of a graph.
    464       /// Its usage is quite simple, for example you can count the number
     464      /// Its usage is quite simple, for example, you can count the number
    465465      /// of incoming arcs of a node \c n
    466466      /// in a graph \c g of type \c %Graph as follows.
    467467      ///\code
    … …  
    587587      ///
    588588      /// Returns the first node of the given edge.
    589589      ///
    590       /// Edges don't have source and target nodes, however methods
     590      /// Edges don't have source and target nodes, however, methods
    591591      /// u() and v() are used to query the two end-nodes of an edge.
    592592      /// The orientation of an edge that arises this way is called
    593593      /// the inherent direction, it is used to define the default
    … …  
    600600      ///
    601601      /// Returns the second node of the given edge.
    602602      ///
    603       /// Edges don't have source and target nodes, however methods
     603      /// Edges don't have source and target nodes, however, methods
    604604      /// u() and v() are used to query the two end-nodes of an edge.
    605605      /// The orientation of an edge that arises this way is called
    606606      /// the inherent direction, it is used to define the default

  • lemon/concepts/graph_components.h 

    diff --git a/lemon/concepts/graph_components.h b/lemon/concepts/graph_components.h
    a b  
    1818
    1919///\ingroup graph_concepts
    2020///\file
    21 ///\brief The concept of graph components.
     21///\brief The concepts of graph components.
    2222
    2323#ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H
    2424#define LEMON_CONCEPTS_GRAPH_COMPONENTS_H

  • lemon/counter.h 

    diff --git a/lemon/counter.h b/lemon/counter.h
    a b  
    212212
    213213  /// 'Do nothing' version of Counter.
    214214
    215   /// This class can be used in the same way as \ref Counter however it
     215  /// This class can be used in the same way as \ref Counter, but it
    216216  /// does not count at all and does not print report on destruction.
    217217  ///
    218218  /// Replacing a \ref Counter with a \ref NoCounter makes it possible

  • lemon/dfs.h 

    diff --git a/lemon/dfs.h b/lemon/dfs.h
    a b  
    6363
    6464    ///The type of the map that indicates which nodes are processed.
    6565    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    66     ///By default it is a NullMap.
     66    ///By default, it is a NullMap.
    6767    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    6868    ///Instantiates a \c ProcessedMap.
    6969
    … …  
    782782
    783783    ///The type of the map that indicates which nodes are processed.
    784784    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    785     ///By default it is a NullMap.
     785    ///By default, it is a NullMap.
    786786    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    787787    ///Instantiates a ProcessedMap.
    788788

  • lemon/dijkstra.h 

    diff --git a/lemon/dijkstra.h b/lemon/dijkstra.h
    a b  
    132132
    133133    ///The type of the map that indicates which nodes are processed.
    134134    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    135     ///By default it is a NullMap.
     135    ///By default, it is a NullMap.
    136136    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    137137    ///Instantiates a \c ProcessedMap.
    138138
    … …  
    426426    ///automatically created by the algorithm (i.e. the digraph should be
    427427    ///passed to the constructor of the cross reference and the cross
    428428    ///reference should be passed to the constructor of the heap).
    429     ///However external heap and cross reference objects could also be
     429    ///However, external heap and cross reference objects could also be
    430430    ///passed to the algorithm using the \ref heap() function before
    431431    ///calling \ref run(Node) "run()" or \ref init().
    432432    ///\sa SetHeap
    … …  
    447447    ///
    448448    ///\ref named-templ-param "Named parameter" for setting
    449449    ///\c OperationTraits type.
    450     /// For more information see \ref DijkstraDefaultOperationTraits.
     450    /// For more information, see \ref DijkstraDefaultOperationTraits.
    451451    template <class T>
    452452    struct SetOperationTraits
    453453      : public Dijkstra<Digraph, LengthMap, SetOperationTraitsTraits<T> > {
    … …  
    996996
    997997    ///The type of the map that indicates which nodes are processed.
    998998    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    999     ///By default it is a NullMap.
     999    ///By default, it is a NullMap.
    10001000    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    10011001    ///Instantiates a ProcessedMap.
    10021002

  • lemon/gomory_hu.h 

    diff --git a/lemon/gomory_hu.h b/lemon/gomory_hu.h
    a b  
    294294    ///
    295295    /// \pre \ref run() must be called before using this function.
    296296    template <typename CutMap>
    297     Value minCutMap(const Node& s, ///<
     297    Value minCutMap(const Node& s,
    298298                    const Node& t,
    299                     ///<
    300299                    CutMap& cutMap
    301                     ///<
    302300                    ) const {
    303301      Node sn = s, tn = t;
    304302      bool s_root=false;
    … …  
    394392                   /// MinCutNodeIt(gomory, t, s, false);
    395393                   /// \endcode
    396394                   /// does not necessarily give the same set of nodes.
    397                    /// However it is ensured that
     395                   /// However, it is ensured that
    398396                   /// \code
    399397                   /// MinCutNodeIt(gomory, s, t, true);
    400398                   /// \endcode

  • lemon/graph_to_eps.h 

    diff --git a/lemon/graph_to_eps.h b/lemon/graph_to_eps.h
    a b  
    142142  ///Constructor
    143143  ///\param gr  Reference to the graph to be printed.
    144144  ///\param ost Reference to the output stream.
    145   ///By default it is <tt>std::cout</tt>.
     145  ///By default, it is <tt>std::cout</tt>.
    146146  ///\param pros If it is \c true, then the \c ostream referenced by \c os
    147147  ///will be explicitly deallocated by the destructor.
    148148  DefaultGraphToEpsTraits(const GR &gr, std::ostream& ost = std::cout,
    … …  
    512512
    513513  ///Turn on/off pre-scaling
    514514
    515   ///By default graphToEps() rescales the whole image in order to avoid
     515  ///By default, graphToEps() rescales the whole image in order to avoid
    516516  ///very big or very small bounding boxes.
    517517  ///
    518518  ///This (p)rescaling can be turned off with this function.
    … …  
    11141114///Generates an EPS file from a graph.
    11151115///\param g Reference to the graph to be printed.
    11161116///\param os Reference to the output stream.
    1117 ///By default it is <tt>std::cout</tt>.
     1117///By default, it is <tt>std::cout</tt>.
    11181118///
    11191119///This function also has a lot of
    11201120///\ref named-templ-func-param "named parameters",
    … …  
    11261126///              .arcWidthScale(.4).run();
    11271127///\endcode
    11281128///
    1129 ///For more detailed examples see the \ref graph_to_eps_demo.cc demo file.
     1129///For more detailed examples, see the \ref graph_to_eps_demo.cc demo file.
    11301130///
    11311131///\warning Don't forget to put the \ref GraphToEps::run() "run()"
    11321132///to the end of the parameter list.

  • lemon/hypercube_graph.h 

    diff --git a/lemon/hypercube_graph.h b/lemon/hypercube_graph.h
    a b  
    287287  /// Two nodes are connected in the graph if and only if their indices
    288288  /// differ only on one position in the binary form.
    289289  /// This class is completely static and it needs constant memory space.
    290   /// Thus you can neither add nor delete nodes or edges, however 
     290  /// Thus you can neither add nor delete nodes or edges, however,
    291291  /// the structure can be resized using resize().
    292292  ///
    293293  /// This type fully conforms to the \ref concepts::Graph "Graph concept".

  • lemon/lgf_reader.h 

    diff --git a/lemon/lgf_reader.h b/lemon/lgf_reader.h
    a b  
    427427  ///   run();
    428428  ///\endcode
    429429  ///
    430   /// By default the reader uses the first section in the file of the
     430  /// By default, the reader uses the first section in the file of the
    431431  /// proper type. If a section has an optional name, then it can be
    432432  /// selected for reading by giving an optional name parameter to the
    433433  /// \c nodes(), \c arcs() or \c attributes() functions.
    … …  
    22212221    /// and the comment lines are filtered out, and the leading
    22222222    /// whitespaces are trimmed from each processed string.
    22232223    ///
    2224     /// For example let's see a section, which contain several
     2224    /// For example, let's see a section, which contain several
    22252225    /// integers, which should be inserted into a vector.
    22262226    ///\code
    22272227    ///  @numbers

  • lemon/list_graph.h 

    diff --git a/lemon/list_graph.h b/lemon/list_graph.h
    a b  
    391391    /// This function changes the target node of the given arc \c a to \c n.
    392392    ///
    393393    ///\note \c ArcIt and \c OutArcIt iterators referencing the changed
    394     ///arc remain valid, however \c InArcIt iterators are invalidated.
     394    ///arc remain valid, but \c InArcIt iterators are invalidated.
    395395    ///
    396396    ///\warning This functionality cannot be used together with the Snapshot
    397397    ///feature.
    … …  
    403403    /// This function changes the source node of the given arc \c a to \c n.
    404404    ///
    405405    ///\note \c InArcIt iterators referencing the changed arc remain
    406     ///valid, however \c ArcIt and \c OutArcIt iterators are invalidated.
     406    ///valid, but \c ArcIt and \c OutArcIt iterators are invalidated.
    407407    ///
    408408    ///\warning This functionality cannot be used together with the Snapshot
    409409    ///feature.
    … …  
    549549    /// \warning Node and arc deletions and other modifications (e.g.
    550550    /// reversing, contracting, splitting arcs or nodes) cannot be
    551551    /// restored. These events invalidate the snapshot.
    552     /// However the arcs and nodes that were added to the digraph after
     552    /// However, the arcs and nodes that were added to the digraph after
    553553    /// making the current snapshot can be removed without invalidating it.
    554554    class Snapshot {
    555555    protected:
    … …  
    12671267    /// This function changes the second node of the given edge \c e to \c n.
    12681268    ///
    12691269    ///\note \c EdgeIt iterators referencing the changed edge remain
    1270     ///valid, however \c ArcIt iterators referencing the changed edge and
     1270    ///valid, but \c ArcIt iterators referencing the changed edge and
    12711271    ///all other iterators whose base node is the changed node are also
    12721272    ///invalidated.
    12731273    ///
    … …  
    13511351    /// \warning Node and edge deletions and other modifications
    13521352    /// (e.g. changing the end-nodes of edges or contracting nodes)
    13531353    /// cannot be restored. These events invalidate the snapshot.
    1354     /// However the edges and nodes that were added to the graph after
     1354    /// However, the edges and nodes that were added to the graph after
    13551355    /// making the current snapshot can be removed without invalidating it.
    13561356    class Snapshot {
    13571357    protected:

  • lemon/lp_base.h 

    diff --git a/lemon/lp_base.h b/lemon/lp_base.h
    a b  
    146146
    147147    ///Iterator for iterate over the columns of an LP problem
    148148
    149     /// Its usage is quite simple, for example you can count the number
     149    /// Its usage is quite simple, for example, you can count the number
    150150    /// of columns in an LP \c lp:
    151151    ///\code
    152152    /// int count=0;
    … …  
    241241
    242242    ///Iterator for iterate over the rows of an LP problem
    243243
    244     /// Its usage is quite simple, for example you can count the number
     244    /// Its usage is quite simple, for example, you can count the number
    245245    /// of rows in an LP \c lp:
    246246    ///\code
    247247    /// int count=0;

  • lemon/maps.h 

    diff --git a/lemon/maps.h b/lemon/maps.h
    a b  
    230230  ///
    231231  /// This map is essentially a wrapper for \c std::vector. It assigns
    232232  /// values to integer keys from the range <tt>[0..size-1]</tt>.
    233   /// It can be used with some data structures, for example
    234   /// \c UnionFind, \c BinHeap, when the used items are small
     233  /// It can be used together with some data structures, e.g.
     234  /// heap types and \c UnionFind, when the used items are small
    235235  /// integers. This map conforms to the \ref concepts::ReferenceMap
    236   /// "ReferenceMap" concept.
     236  /// "ReferenceMap" concept. 
    237237  ///
    238238  /// The simplest way of using this map is through the rangeMap()
    239239  /// function.
    … …  
    348348  /// keys (i.e. the map is "sparse").
    349349  /// The name of this type also refers to this important usage.
    350350  ///
    351   /// Apart form that this map can be used in many other cases since it
     351  /// Apart form that, this map can be used in many other cases since it
    352352  /// is based on \c std::map, which is a general associative container.
    353   /// However keep in mind that it is usually not as efficient as other
     353  /// However, keep in mind that it is usually not as efficient as other
    354354  /// maps.
    355355  ///
    356356  /// The simplest way of using this map is through the sparseMap()
    … …  
    17851785  ///
    17861786  /// The most important usage of it is storing certain nodes or arcs
    17871787  /// that were marked \c true by an algorithm.
    1788   /// For example it makes easier to store the nodes in the processing
     1788  /// For example, it makes easier to store the nodes in the processing
    17891789  /// order of Dfs algorithm, as the following examples show.
    17901790  /// \code
    17911791  ///   std::vector<Node> v;
    … …  
    18001800  /// for the elements or the iterator should be an inserter iterator.
    18011801  ///
    18021802  /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so
    1803   /// it cannot be used when a readable map is needed, for example as
     1803  /// it cannot be used when a readable map is needed, for example, as
    18041804  /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms.
    18051805  ///
    18061806  /// \relates LoggerBoolMap
    … …  
    19221922  /// items with the same value.
    19231923  /// Otherwise consider to use \c IterableValueMap, which is more
    19241924  /// suitable and more efficient for such cases. It provides iterators
    1925   /// to traverse the items with the same associated value, however
     1925  /// to traverse the items with the same associated value, but
    19261926  /// it does not have \c InverseMap.
    19271927  ///
    19281928  /// This type is not reference map, so it cannot be modified with
    … …  
    34663466  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
    34673467  /// may provide alternative ways to modify the digraph.
    34683468  /// The correct behavior of InDegMap is not guarantied if these additional
    3469   /// features are used. For example the functions
     3469  /// features are used. For example, the functions
    34703470  /// \ref ListDigraph::changeSource() "changeSource()",
    34713471  /// \ref ListDigraph::changeTarget() "changeTarget()" and
    34723472  /// \ref ListDigraph::reverseArc() "reverseArc()"
    … …  
    35963596  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
    35973597  /// may provide alternative ways to modify the digraph.
    35983598  /// The correct behavior of OutDegMap is not guarantied if these additional
    3599   /// features are used. For example the functions
     3599  /// features are used. For example, the functions
    36003600  /// \ref ListDigraph::changeSource() "changeSource()",
    36013601  /// \ref ListDigraph::changeTarget() "changeTarget()" and
    36023602  /// \ref ListDigraph::reverseArc() "reverseArc()"

  • lemon/network_simplex.h 

    diff --git a/lemon/network_simplex.h b/lemon/network_simplex.h
    a b  
    4848  /// In general this class is the fastest implementation available
    4949  /// in LEMON for the minimum cost flow problem.
    5050  /// Moreover it supports both directions of the supply/demand inequality
    51   /// constraints. For more information see \ref SupplyType.
     51  /// constraints. For more information, see \ref SupplyType.
    5252  ///
    5353  /// Most of the parameters of the problem (except for the digraph)
    5454  /// can be given using separate functions, and the algorithm can be
    … …  
    5757  ///
    5858  /// \tparam GR The digraph type the algorithm runs on.
    5959  /// \tparam V The value type used for flow amounts, capacity bounds
    60   /// and supply values in the algorithm. By default it is \c int.
     60  /// and supply values in the algorithm. By default, it is \c int.
    6161  /// \tparam C The value type used for costs and potentials in the
    62   /// algorithm. By default it is the same as \c V.
     62  /// algorithm. By default, it is the same as \c V.
    6363  ///
    6464  /// \warning Both value types must be signed and all input data must
    6565  /// be integer.
    6666  ///
    6767  /// \note %NetworkSimplex provides five different pivot rule
    6868  /// implementations, from which the most efficient one is used
    69   /// by default. For more information see \ref PivotRule.
     69  /// by default. For more information, see \ref PivotRule.
    7070  template <typename GR, typename V = int, typename C = V>
    7171  class NetworkSimplex
    7272  {
    … …  
    122122    /// \ref NetworkSimplex provides five different pivot rule
    123123    /// implementations that significantly affect the running time
    124124    /// of the algorithm.
    125     /// By default \ref BLOCK_SEARCH "Block Search" is used, which
     125    /// By default, \ref BLOCK_SEARCH "Block Search" is used, which
    126126    /// proved to be the most efficient and the most robust on various
    127127    /// test inputs according to our benchmark tests.
    128     /// However another pivot rule can be selected using the \ref run()
     128    /// However, another pivot rule can be selected using the \ref run()
    129129    /// function with the proper parameter.
    130130    enum PivotRule {
    131131
    132       /// The First Eligible pivot rule.
     132      /// The \e First \e Eligible pivot rule.
    133133      /// The next eligible arc is selected in a wraparound fashion
    134134      /// in every iteration.
    135135      FIRST_ELIGIBLE,
    136136
    137       /// The Best Eligible pivot rule.
     137      /// The \e Best \e Eligible pivot rule.
    138138      /// The best eligible arc is selected in every iteration.
    139139      BEST_ELIGIBLE,
    140140
    141       /// The Block Search pivot rule.
     141      /// The \e Block \e Search pivot rule.
    142142      /// A specified number of arcs are examined in every iteration
    143143      /// in a wraparound fashion and the best eligible arc is selected
    144144      /// from this block.
    145145      BLOCK_SEARCH,
    146146
    147       /// The Candidate List pivot rule.
     147      /// The \e Candidate \e List pivot rule.
    148148      /// In a major iteration a candidate list is built from eligible arcs
    149149      /// in a wraparound fashion and in the following minor iterations
    150150      /// the best eligible arc is selected from this list.
    151151      CANDIDATE_LIST,
    152152
    153       /// The Altering Candidate List pivot rule.
     153      /// The \e Altering \e Candidate \e List pivot rule.
    154154      /// It is a modified version of the Candidate List method.
    155155      /// It keeps only the several best eligible arcs from the former
    156156      /// candidate list and extends this list in every iteration.
    … …  
    810810    /// If it is not used before calling \ref run(), the \ref GEQ supply
    811811    /// type will be used.
    812812    ///
    813     /// For more information see \ref SupplyType.
     813    /// For more information, see \ref SupplyType.
    814814    ///
    815815    /// \return <tt>(*this)</tt>
    816816    NetworkSimplex& supplyType(SupplyType supply_type) {
    … …  
    842842    /// that have been given are kept for the next call, unless
    843843    /// \ref reset() is called, thus only the modified parameters
    844844    /// have to be set again. See \ref reset() for examples.
    845     /// However the underlying digraph must not be modified after this
     845    /// However, the underlying digraph must not be modified after this
    846846    /// class have been constructed, since it copies and extends the graph.
    847847    ///
    848848    /// \param pivot_rule The pivot rule that will be used during the
    849     /// algorithm. For more information see \ref PivotRule.
     849    /// algorithm. For more information, see \ref PivotRule.
    850850    ///
    851851    /// \return \c INFEASIBLE if no feasible flow exists,
    852852    /// \n \c OPTIMAL if the problem has optimal solution
    … …  
    871871    /// It is useful for multiple run() calls. If this function is not
    872872    /// used, all the parameters given before are kept for the next
    873873    /// \ref run() call.
    874     /// However the underlying digraph must not be modified after this
     874    /// However, the underlying digraph must not be modified after this
    875875    /// class have been constructed, since it copies and extends the graph.
    876876    ///
    877877    /// For example,

  • lemon/preflow.h 

    diff --git a/lemon/preflow.h b/lemon/preflow.h
    a b  
    264264    /// The Elevator should have standard constructor interface to be
    265265    /// able to automatically created by the algorithm (i.e. the
    266266    /// digraph and the maximum level should be passed to it).
    267     /// However an external elevator object could also be passed to the
     267    /// However, an external elevator object could also be passed to the
    268268    /// algorithm with the \ref elevator(Elevator&) "elevator()" function
    269269    /// before calling \ref run() or \ref init().
    270270    /// \sa SetElevator

  • lemon/time_measure.h 

    diff --git a/lemon/time_measure.h b/lemon/time_measure.h
    a b  
    375375
    376376    ///This function returns the number of stop() exections that is
    377377    ///necessary to really stop the timer.
    378     ///For example the timer
     378    ///For example, the timer
    379379    ///is running if and only if the return value is \c true
    380380    ///(i.e. greater than
    381381    ///zero).

  • lemon/unionfind.h 

    diff --git a/lemon/unionfind.h b/lemon/unionfind.h
    a b  
    4343  /// the find operation uses path compression.
    4444  /// This is a very simple but efficient implementation, providing
    4545  /// only four methods: join (union), find, insert and size.
    46   /// For more features see the \ref UnionFindEnum class.
     46  /// For more features, see the \ref UnionFindEnum class.
    4747  ///
    4848  /// It is primarily used in Kruskal algorithm for finding minimal
    4949  /// cost spanning tree in a graph.