COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changes in / [788:c92296660262:787:c2230649a493] in lemon-1.2


Ignore:
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • doc/min_cost_flow.dox

    r788 r755  
    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)\leq 0\f$;
     81   - \f$\pi(u)<=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$.
    … …  
    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)\geq 0\f$;
     148   - \f$\pi(u)>=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$.

  • lemon/bellman_ford.h

    r788 r781  
    301301    /// \ref named-templ-param "Named parameter" for setting
    302302    /// \c OperationTraits type.
    303     /// For more information, see \ref BellmanFordDefaultOperationTraits.
     303    /// For more information see \ref BellmanFordDefaultOperationTraits.
    304304    template <class T>
    305305    struct SetOperationTraits
    … …  
    719719    ///
    720720    /// The shortest path tree used here is equal to the shortest path
    721     /// tree used in \ref predNode() and \ref predMap().
     721    /// tree used in \ref predNode() and \predMap().
    722722    ///
    723723    /// \pre Either \ref run() or \ref init() must be called before
    … …  
    734734    ///
    735735    /// The shortest path tree used here is equal to the shortest path
    736     /// tree used in \ref predArc() and \ref predMap().
     736    /// tree used in \ref predArc() and \predMap().
    737737    ///
    738738    /// \pre Either \ref run() or \ref init() must be called before

  • lemon/bfs.h

    r788 r787  
    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.
    … …  
    849849    ///The type of the map that indicates which nodes are processed.
    850850    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    851     ///By default, it is a NullMap.
     851    ///By default it is a NullMap.
    852852    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    853853    ///Instantiates a ProcessedMap.

  • lemon/circulation.h

    r786 r715  
    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().

  • lemon/concepts/digraph.h

    r786 r734  
    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
    … …  
    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.
    … …  
    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.
    … …  
    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

  • lemon/concepts/graph.h

    r786 r734  
    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
    … …  
    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
    … …  
    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.
    … …  
    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
    … …  
    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.
    … …  
    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.
    … …  
    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
    … …  
    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

  • lemon/concepts/graph_components.h

    r786 r734  
    1919///\ingroup graph_concepts
    2020///\file
    21 ///\brief The concepts of graph components.
     21///\brief The concept of graph components.
    2222
    2323#ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H

  • lemon/concepts/path.h

    r785 r559  
    1919///\ingroup concept
    2020///\file
    21 ///\brief The concept of paths
     21///\brief Classes for representing paths in digraphs.
    2222///
    2323
    … …  
    3939    /// A skeleton structure for representing directed paths in a
    4040    /// digraph.
    41     /// In a sense, a path can be treated as a list of arcs.
    42     /// LEMON path types just store this list. As a consequence, they cannot
    43     /// enumerate the nodes on the path directly and a zero length path
    44     /// cannot store its source node.
    45     ///
    46     /// The arcs of a path should be stored in the order of their directions,
    47     /// i.e. the target node of each arc should be the same as the source
    48     /// node of the next arc. This consistency could be checked using
    49     /// \ref checkPath().
    50     /// The source and target nodes of a (consistent) path can be obtained
    51     /// using \ref pathSource() and \ref pathTarget().
    52     ///
    53     /// A path can be constructed from another path of any type using the
    54     /// copy constructor or the assignment operator.
    55     ///
    5641    /// \tparam GR The digraph type in which the path is.
     42    ///
     43    /// In a sense, the path can be treated as a list of arcs. The
     44    /// lemon path type stores just this list. As a consequence it
     45    /// cannot enumerate the nodes in the path and the zero length
     46    /// paths cannot store the source.
     47    ///
    5748    template <typename GR>
    5849    class Path {
    … …  
    6960      Path() {}
    7061
    71       /// \brief Template copy constructor
     62      /// \brief Template constructor
    7263      template <typename CPath>
    7364      Path(const CPath& cpath) {}
    7465
    75       /// \brief Template assigment operator
     66      /// \brief Template assigment
    7667      template <typename CPath>
    7768      Path& operator=(const CPath& cpath) {
    … …  
    8071      }
    8172
    82       /// Length of the path, i.e. the number of arcs on the path.
     73      /// Length of the path ie. the number of arcs in the path.
    8374      int length() const { return 0;}
    8475
    … …  
    8980      void clear() {}
    9081
    91       /// \brief LEMON style iterator for enumerating the arcs of a path.
     82      /// \brief LEMON style iterator for path arcs
    9283      ///
    93       /// LEMON style iterator class for enumerating the arcs of a path.
     84      /// This class is used to iterate on the arcs of the paths.
    9485      class ArcIt {
    9586      public:
    … …  
    9889        /// Invalid constructor
    9990        ArcIt(Invalid) {}
    100         /// Sets the iterator to the first arc of the given path
     91        /// Constructor for first arc
    10192        ArcIt(const Path &) {}
    10293
    103         /// Conversion to \c Arc
     94        /// Conversion to Arc
    10495        operator Arc() const { return INVALID; }
    10596
    … …  
    202193    ///
    203194    /// A skeleton structure for path dumpers. The path dumpers are
    204     /// the generalization of the paths, they can enumerate the arcs
    205     /// of the path either in forward or in backward order.
    206     /// These classes are typically not used directly, they are rather
    207     /// used to be assigned to a real path type.
     195    /// the generalization of the paths. The path dumpers can
     196    /// enumerate the arcs of the path wheter in forward or in
     197    /// backward order.  In most time these classes are not used
     198    /// directly rather it used to assign a dumped class to a real
     199    /// path type.
    208200    ///
    209201    /// The main purpose of this concept is that the shortest path
    210     /// algorithms can enumerate the arcs easily in reverse order.
    211     /// In LEMON, such algorithms give back a (reverse) path dumper that
    212     /// can be assigned to a real path. The dumpers can be implemented as
     202    /// algorithms can enumerate easily the arcs in reverse order.
     203    /// If we would like to give back a real path from these
     204    /// algorithms then we should create a temporarly path object. In
     205    /// LEMON such algorithms gives back a path dumper what can
     206    /// assigned to a real path and the dumpers can be implemented as
    213207    /// an adaptor class to the predecessor map.
    214208    ///
    215209    /// \tparam GR The digraph type in which the path is.
     210    ///
     211    /// The paths can be constructed from any path type by a
     212    /// template constructor or a template assignment operator.
    216213    template <typename GR>
    217214    class PathDumper {
    … …  
    223220      typedef typename Digraph::Arc Arc;
    224221
    225       /// Length of the path, i.e. the number of arcs on the path.
     222      /// Length of the path ie. the number of arcs in the path.
    226223      int length() const { return 0;}
    227224
    … …  
    231228      /// \brief Forward or reverse dumping
    232229      ///
    233       /// If this tag is defined to be \c True, then reverse dumping
    234       /// is provided in the path dumper. In this case, \c RevArcIt
    235       /// iterator should be implemented instead of \c ArcIt iterator.
     230      /// If the RevPathTag is defined and true then reverse dumping
     231      /// is provided in the path dumper. In this case instead of the
     232      /// ArcIt the RevArcIt iterator should be implemented in the
     233      /// dumper.
    236234      typedef False RevPathTag;
    237235
    238       /// \brief LEMON style iterator for enumerating the arcs of a path.
     236      /// \brief LEMON style iterator for path arcs
    239237      ///
    240       /// LEMON style iterator class for enumerating the arcs of a path.
     238      /// This class is used to iterate on the arcs of the paths.
    241239      class ArcIt {
    242240      public:
    … …  
    245243        /// Invalid constructor
    246244        ArcIt(Invalid) {}
    247         /// Sets the iterator to the first arc of the given path
     245        /// Constructor for first arc
    248246        ArcIt(const PathDumper&) {}
    249247
    250         /// Conversion to \c Arc
     248        /// Conversion to Arc
    251249        operator Arc() const { return INVALID; }
    252250
    … …  
    263261      };
    264262
    265       /// \brief LEMON style iterator for enumerating the arcs of a path
    266       /// in reverse direction.
     263      /// \brief LEMON style iterator for path arcs
    267264      ///
    268       /// LEMON style iterator class for enumerating the arcs of a path
    269       /// in reverse direction.
     265      /// This class is used to iterate on the arcs of the paths in
     266      /// reverse direction.
    270267      class RevArcIt {
    271268      public:
    … …  
    274271        /// Invalid constructor
    275272        RevArcIt(Invalid) {}
    276         /// Sets the iterator to the last arc of the given path
     273        /// Constructor for first arc
    277274        RevArcIt(const PathDumper &) {}
    278275
    279         /// Conversion to \c Arc
     276        /// Conversion to Arc
    280277        operator Arc() const { return INVALID; }
    281278

  • lemon/counter.h

    r786 r440  
    213213  /// 'Do nothing' version of Counter.
    214214
    215   /// This class can be used in the same way as \ref Counter, but it
     215  /// This class can be used in the same way as \ref Counter however it
    216216  /// does not count at all and does not print report on destruction.
    217217  ///

  • lemon/dfs.h

    r788 r787  
    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.
    … …  
    779779    ///The type of the map that indicates which nodes are processed.
    780780    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    781     ///By default, it is a NullMap.
     781    ///By default it is a NullMap.
    782782    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    783783    ///Instantiates a ProcessedMap.

  • lemon/dijkstra.h

    r788 r787  
    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.
    … …  
    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().
    … …  
    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
    … …  
    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.

  • lemon/gomory_hu.h

    r786 r713  
    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                    ///<
    299300                    CutMap& cutMap
     301                    ///<
    300302                    ) const {
    301303      Node sn = s, tn = t;
    … …  
    393395                   /// \endcode
    394396                   /// does not necessarily give the same set of nodes.
    395                    /// However, it is ensured that
     397                   /// However it is ensured that
    396398                   /// \code
    397399                   /// MinCutNodeIt(gomory, s, t, true);

  • lemon/graph_to_eps.h

    r786 r617  
    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.
    … …  
    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  ///
    … …  
    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
    … …  
    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()"

  • lemon/hypercube_graph.h

    r788 r787  
    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  ///

  • lemon/lgf_reader.h

    r786 r599  
    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
    … …  
    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

  • lemon/list_graph.h

    r788 r787  
    401401    ///
    402402    ///\note \c ArcIt and \c OutArcIt iterators referencing the changed
    403     ///arc remain valid, but \c InArcIt iterators are invalidated.
     403    ///arc remain valid, however \c InArcIt iterators are invalidated.
    404404    ///
    405405    ///\warning This functionality cannot be used together with the Snapshot
    … …  
    413413    ///
    414414    ///\note \c InArcIt iterators referencing the changed arc remain
    415     ///valid, but \c ArcIt and \c OutArcIt iterators are invalidated.
     415    ///valid, however \c ArcIt and \c OutArcIt iterators are invalidated.
    416416    ///
    417417    ///\warning This functionality cannot be used together with the Snapshot
    … …  
    560560    /// reversing, contracting, splitting arcs or nodes) cannot be
    561561    /// restored. These events invalidate the snapshot.
    562     /// However, the arcs and nodes that were added to the digraph after
     562    /// However the arcs and nodes that were added to the digraph after
    563563    /// making the current snapshot can be removed without invalidating it.
    564564    class Snapshot {
    … …  
    12871287    ///
    12881288    ///\note \c EdgeIt iterators referencing the changed edge remain
    1289     ///valid, but \c ArcIt iterators referencing the changed edge and
     1289    ///valid, however \c ArcIt iterators referencing the changed edge and
    12901290    ///all other iterators whose base node is the changed node are also
    12911291    ///invalidated.
    … …  
    13721372    /// (e.g. changing the end-nodes of edges or contracting nodes)
    13731373    /// cannot be restored. These events invalidate the snapshot.
    1374     /// However, the edges and nodes that were added to the graph after
     1374    /// However the edges and nodes that were added to the graph after
    13751375    /// making the current snapshot can be removed without invalidating it.
    13761376    class Snapshot {

  • lemon/lp_base.h

    r786 r746  
    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
    … …  
    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

  • lemon/maps.h

    r786 r726  
    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 together with some data structures, e.g.
    234   /// heap types and \c UnionFind, when the used items are small
     233  /// It can be used with some data structures, for example
     234  /// \c UnionFind, \c BinHeap, 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()
    … …  
    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  ///
    … …  
    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
    … …  
    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  ///
    … …  
    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, but
     1925  /// to traverse the items with the same associated value, however
    19261926  /// it does not have \c InverseMap.
    19271927  ///
    … …  
    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
    … …  
    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

  • lemon/network_simplex.h

    r788 r755  
    5151  /// in LEMON for the minimum cost flow problem.
    5252  /// Moreover it supports both directions of the supply/demand inequality
    53   /// constraints. For more information, see \ref SupplyType.
     53  /// constraints. For more information see \ref SupplyType.
    5454  ///
    5555  /// Most of the parameters of the problem (except for the digraph)
    … …  
    6060  /// \tparam GR The digraph type the algorithm runs on.
    6161  /// \tparam V The value type used for flow amounts, capacity bounds
    62   /// and supply values in the algorithm. By default, it is \c int.
     62  /// and supply values in the algorithm. By default it is \c int.
    6363  /// \tparam C The value type used for costs and potentials in the
    64   /// algorithm. By default, it is the same as \c V.
     64  /// algorithm. By default it is the same as \c V.
    6565  ///
    6666  /// \warning Both value types must be signed and all input data must
    … …  
    6969  /// \note %NetworkSimplex provides five different pivot rule
    7070  /// implementations, from which the most efficient one is used
    71   /// by default. For more information, see \ref PivotRule.
     71  /// by default. For more information see \ref PivotRule.
    7272  template <typename GR, typename V = int, typename C = V>
    7373  class NetworkSimplex
    … …  
    125125    /// implementations that significantly affect the running time
    126126    /// of the algorithm.
    127     /// By default, \ref BLOCK_SEARCH "Block Search" is used, which
     127    /// By default \ref BLOCK_SEARCH "Block Search" is used, which
    128128    /// proved to be the most efficient and the most robust on various
    129129    /// test inputs according to our benchmark tests.
    130     /// However, another pivot rule can be selected using the \ref run()
     130    /// However another pivot rule can be selected using the \ref run()
    131131    /// function with the proper parameter.
    132132    enum PivotRule {
    133133
    134       /// The \e First \e Eligible pivot rule.
     134      /// The First Eligible pivot rule.
    135135      /// The next eligible arc is selected in a wraparound fashion
    136136      /// in every iteration.
    137137      FIRST_ELIGIBLE,
    138138
    139       /// The \e Best \e Eligible pivot rule.
     139      /// The Best Eligible pivot rule.
    140140      /// The best eligible arc is selected in every iteration.
    141141      BEST_ELIGIBLE,
    142142
    143       /// The \e Block \e Search pivot rule.
     143      /// The Block Search pivot rule.
    144144      /// A specified number of arcs are examined in every iteration
    145145      /// in a wraparound fashion and the best eligible arc is selected
    … …  
    147147      BLOCK_SEARCH,
    148148
    149       /// The \e Candidate \e List pivot rule.
     149      /// The Candidate List pivot rule.
    150150      /// In a major iteration a candidate list is built from eligible arcs
    151151      /// in a wraparound fashion and in the following minor iterations
    … …  
    153153      CANDIDATE_LIST,
    154154
    155       /// The \e Altering \e Candidate \e List pivot rule.
     155      /// The Altering Candidate List pivot rule.
    156156      /// It is a modified version of the Candidate List method.
    157157      /// It keeps only the several best eligible arcs from the former
    … …  
    813813    /// type will be used.
    814814    ///
    815     /// For more information, see \ref SupplyType.
     815    /// For more information see \ref SupplyType.
    816816    ///
    817817    /// \return <tt>(*this)</tt>
    … …  
    845845    /// \ref reset() is called, thus only the modified parameters
    846846    /// have to be set again. See \ref reset() for examples.
    847     /// However, the underlying digraph must not be modified after this
     847    /// However the underlying digraph must not be modified after this
    848848    /// class have been constructed, since it copies and extends the graph.
    849849    ///
    850850    /// \param pivot_rule The pivot rule that will be used during the
    851     /// algorithm. For more information, see \ref PivotRule.
     851    /// algorithm. For more information see \ref PivotRule.
    852852    ///
    853853    /// \return \c INFEASIBLE if no feasible flow exists,
    … …  
    874874    /// used, all the parameters given before are kept for the next
    875875    /// \ref run() call.
    876     /// However, the underlying digraph must not be modified after this
     876    /// However the underlying digraph must not be modified after this
    877877    /// class have been constructed, since it copies and extends the graph.
    878878    ///

  • lemon/preflow.h

    r788 r755  
    266266    /// able to automatically created by the algorithm (i.e. the
    267267    /// digraph and the maximum level should be passed to it).
    268     /// However, an external elevator object could also be passed to the
     268    /// However an external elevator object could also be passed to the
    269269    /// algorithm with the \ref elevator(Elevator&) "elevator()" function
    270270    /// before calling \ref run() or \ref init().

  • lemon/time_measure.h

    r786 r584  
    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

  • lemon/unionfind.h

    r786 r559  
    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
Note: See TracChangeset for help on using the changeset viewer.