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 / [792:a2d5fd4c309a:791:4e3484a2e90c] in lemon-main


Ignore:
Files:
28 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/adaptors.h

    r787 r656  
    361361  /// parameter is set to be \c const.
    362362  ///
    363   /// This class provides item counting in the same time as the adapted
    364   /// digraph structure.
    365   ///
    366363  /// \tparam DGR The type of the adapted digraph.
    367364  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
    … …  
    722719  /// by adding or removing nodes or arcs, unless the \c GR template
    723720  /// parameter is set to be \c const.
    724   ///
    725   /// This class provides only linear time counting for nodes and arcs.
    726721  ///
    727722  /// \tparam DGR The type of the adapted digraph.
    … …  
    13201315  /// parameter is set to be \c const.
    13211316  ///
    1322   /// This class provides only linear time counting for nodes, edges and arcs.
    1323   ///
    13241317  /// \tparam GR The type of the adapted graph.
    13251318  /// It must conform to the \ref concepts::Graph "Graph" concept.
    … …  
    14781471  /// by adding or removing nodes or arcs/edges, unless the \c GR template
    14791472  /// parameter is set to be \c const.
    1480   ///
    1481   /// This class provides only linear time item counting.
    14821473  ///
    14831474  /// \tparam GR The type of the adapted digraph or graph.
    … …  
    16291620  /// parameter is set to be \c const.
    16301621  ///
    1631   /// This class provides only linear time counting for nodes and arcs.
    1632   ///
    16331622  /// \tparam DGR The type of the adapted digraph.
    16341623  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
    … …  
    17401729  /// by adding or removing nodes or edges, unless the \c GR template
    17411730  /// parameter is set to be \c const.
    1742   ///
    1743   /// This class provides only linear time counting for nodes, edges and arcs.
    17441731  ///
    17451732  /// \tparam GR The type of the adapted graph.
    … …  
    22462233  /// parameter is set to be \c const.
    22472234  ///
    2248   /// This class provides item counting in the same time as the adapted
    2249   /// digraph structure.
    2250   ///
    22512235  /// \tparam DGR The type of the adapted digraph.
    22522236  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
    … …  
    25512535  /// by adding or removing nodes or arcs, unless the \c GR template
    25522536  /// parameter is set to be \c const.
    2553   ///
    2554   /// This class provides item counting in the same time as the adapted
    2555   /// graph structure.
    25562537  ///
    25572538  /// \tparam GR The type of the adapted graph.
    … …  
    26972678  /// arcs).
    26982679  /// This class conforms to the \ref concepts::Digraph "Digraph" concept.
    2699   ///
    2700   /// This class provides only linear time counting for nodes and arcs.
    27012680  ///
    27022681  /// \tparam DGR The type of the adapted digraph.
    … …  
    33473326  /// in the adaptor.
    33483327  ///
    3349   /// This class provides item counting in the same time as the adapted
    3350   /// digraph structure.
    3351   ///
    33523328  /// \tparam DGR The type of the adapted digraph.
    33533329  /// It must conform to the \ref concepts::Digraph "Digraph" concept.

  • 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 r717  
    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.
    … …  
    702702    ///Runs the algorithm to visit all nodes in the digraph.
    703703
    704     ///This method runs the %BFS algorithm in order to visit all nodes
    705     ///in the digraph.
     704    ///This method runs the %BFS algorithm in order to
     705    ///compute the shortest path to each node.
     706    ///
     707    ///The algorithm computes
     708    ///- the shortest path tree (forest),
     709    ///- the distance of each node from the root(s).
    706710    ///
    707711    ///\note <tt>b.run(s)</tt> is just a shortcut of the following code.
    … …  
    849853    ///The type of the map that indicates which nodes are processed.
    850854    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    851     ///By default, it is a NullMap.
     855    ///By default it is a NullMap.
    852856    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    853857    ///Instantiates a ProcessedMap.
    … …  
    10431047    ///Runs BFS algorithm to visit all nodes in the digraph.
    10441048
    1045     ///This method runs BFS algorithm in order to visit all nodes
    1046     ///in the digraph.
     1049    ///This method runs BFS algorithm in order to compute
     1050    ///the shortest path to each node.
    10471051    void run()
    10481052    {
    … …  
    16921696    /// \brief Runs the algorithm to visit all nodes in the digraph.
    16931697    ///
    1694     /// This method runs the %BFS algorithm in order to visit all nodes
    1695     /// in the digraph.
     1698    /// This method runs the %BFS algorithm in order to
     1699    /// compute the shortest path to each node.
     1700    ///
     1701    /// The algorithm computes
     1702    /// - the shortest path tree (forest),
     1703    /// - the distance of each node from the root(s).
    16961704    ///
    16971705    /// \note <tt>b.run(s)</tt> is just a shortcut of the following code.

  • 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 r717  
    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.
    … …  
    634634    ///Runs the algorithm to visit all nodes in the digraph.
    635635
    636     ///This method runs the %DFS algorithm in order to visit all nodes
    637     ///in the digraph.
     636    ///This method runs the %DFS algorithm in order to compute the
     637    ///%DFS path to each node.
     638    ///
     639    ///The algorithm computes
     640    ///- the %DFS tree (forest),
     641    ///- the distance of each node from the root(s) in the %DFS tree.
    638642    ///
    639643    ///\note <tt>d.run()</tt> is just a shortcut of the following code.
    … …  
    779783    ///The type of the map that indicates which nodes are processed.
    780784    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    781     ///By default, it is a NullMap.
     785    ///By default it is a NullMap.
    782786    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    783787    ///Instantiates a ProcessedMap.
    … …  
    973977    ///Runs DFS algorithm to visit all nodes in the digraph.
    974978
    975     ///This method runs DFS algorithm in order to visit all nodes
    976     ///in the digraph.
     979    ///This method runs DFS algorithm in order to compute
     980    ///the DFS path to each node.
    977981    void run()
    978982    {
    … …  
    15751579    /// \brief Runs the algorithm to visit all nodes in the digraph.
    15761580
    1577     /// This method runs the %DFS algorithm in order to visit all nodes
    1578     /// in the digraph.
     1581    /// This method runs the %DFS algorithm in order to
     1582    /// compute the %DFS path to each node.
     1583    ///
     1584    /// The algorithm computes
     1585    /// - the %DFS tree (forest),
     1586    /// - the distance of each node from the root(s) in the %DFS tree.
    15791587    ///
    15801588    /// \note <tt>d.run()</tt> is just a shortcut of the following code.

  • lemon/dijkstra.h

    r788 r717  
    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.
    … …  
    207207
    208208    ///The type of the arc lengths.
    209     typedef typename TR::Value Value;
     209    typedef typename TR::LengthMap::Value Value;
    210210    ///The type of the map that stores the arc lengths.
    211211    typedef typename TR::LengthMap LengthMap;
    … …  
    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/edge_set.h

    r787 r778  
    256256  /// all arcs incident to the given node is erased from the arc set.
    257257  ///
    258   /// This class fully conforms to the \ref concepts::Digraph
    259   /// "Digraph" concept.
    260   /// It provides only linear time counting for nodes and arcs.
    261   ///
    262258  /// \param GR The type of the graph which shares its node set with
    263259  /// this class. Its interface must conform to the
    264260  /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
    265261  /// concept.
     262  ///
     263  /// This class fully conforms to the \ref concepts::Digraph
     264  /// "Digraph" concept.
    266265  template <typename GR>
    267266  class ListArcSet : public ArcSetExtender<ListArcSetBase<GR> > {
    … …  
    687686  /// incident to the given node is erased from the arc set.
    688687  ///
    689   /// This class fully conforms to the \ref concepts::Graph "Graph"
    690   /// concept.
    691   /// It provides only linear time counting for nodes, edges and arcs.
    692   ///
    693688  /// \param GR The type of the graph which shares its node set
    694689  /// with this class. Its interface must conform to the
    695690  /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
     691  /// concept.
     692  ///
     693  /// This class fully conforms to the \ref concepts::Graph "Graph"
    696694  /// concept.
    697695  template <typename GR>
    … …  
    957955  /// arcs. Therefore the arcs cannot be erased from the arc sets.
    958956  ///
    959   /// This class fully conforms to the \ref concepts::Digraph "Digraph"
    960   /// concept.
    961   /// It provides only linear time counting for nodes and arcs.
    962   ///
    963957  /// \warning If a node is erased from the underlying graph and this
    964958  /// node is the source or target of one arc in the arc set, then
    965959  /// the arc set is invalidated, and it cannot be used anymore. The
    966960  /// validity can be checked with the \c valid() member function.
     961  ///
     962  /// This class fully conforms to the \ref concepts::Digraph
     963  /// "Digraph" concept.
    967964  template <typename GR>
    968965  class SmartArcSet : public ArcSetExtender<SmartArcSetBase<GR> > {
    … …  
    13081305  /// edges cannot be erased from the edge sets.
    13091306  ///
    1310   /// This class fully conforms to the \ref concepts::Graph "Graph"
    1311   /// concept.
    1312   /// It provides only linear time counting for nodes, edges and arcs.
    1313   ///
    13141307  /// \warning If a node is erased from the underlying graph and this
    13151308  /// node is incident to one edge in the edge set, then the edge set
    13161309  /// is invalidated, and it cannot be used anymore. The validity can
    13171310  /// be checked with the \c valid() member function.
     1311  ///
     1312  /// This class fully conforms to the \ref concepts::Graph
     1313  /// "Graph" concept.
    13181314  template <typename GR>
    13191315  class SmartEdgeSet : public EdgeSetExtender<SmartEdgeSetBase<GR> > {

  • lemon/full_graph.h

    r787 r780  
    163163  /// only in the concept class.
    164164  ///
    165   /// This class provides constant time counting for nodes and arcs.
    166   ///
    167165  /// \note FullDigraph and FullGraph classes are very similar,
    168166  /// but there are two differences. While this class conforms only
    … …  
    207205    /// completely static, the nodes can be indexed with integers from
    208206    /// the range <tt>[0..nodeNum()-1]</tt>.
    209     /// The index of a node is the same as its ID.
    210207    /// \sa index()
    211208    Node operator()(int ix) const { return Parent::operator()(ix); }
    … …  
    216213    /// completely static, the nodes can be indexed with integers from
    217214    /// the range <tt>[0..nodeNum()-1]</tt>.
    218     /// The index of a node is the same as its ID.
    219215    /// \sa operator()()
    220216    static int index(const Node& node) { return Parent::index(node); }
    … …  
    540536  /// only in the concept class.
    541537  ///
    542   /// This class provides constant time counting for nodes, edges and arcs.
    543   ///
    544538  /// \note FullDigraph and FullGraph classes are very similar,
    545539  /// but there are two differences. While FullDigraph
    … …  
    586580    /// completely static, the nodes can be indexed with integers from
    587581    /// the range <tt>[0..nodeNum()-1]</tt>.
    588     /// The index of a node is the same as its ID.
    589582    /// \sa index()
    590583    Node operator()(int ix) const { return Parent::operator()(ix); }
    … …  
    595588    /// completely static, the nodes can be indexed with integers from
    596589    /// the range <tt>[0..nodeNum()-1]</tt>.
    597     /// The index of a node is the same as its ID.
    598590    /// \sa operator()()
    599591    static int index(const Node& node) { return Parent::index(node); }

  • 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/grid_graph.h

    r787 r735  
    504504  /// Most of its member functions and nested classes are documented
    505505  /// only in the concept class.
    506   ///
    507   /// This class provides constant time counting for nodes, edges and arcs.
    508506  class GridGraph : public ExtendedGridGraphBase {
    509507    typedef ExtendedGridGraphBase Parent;

  • lemon/hypercube_graph.h

    r788 r780  
    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  ///
    … …  
    294294  /// Most of its member functions and nested classes are documented
    295295  /// only in the concept class.
    296   ///
    297   /// This class provides constant time counting for nodes, edges and arcs.
    298296  ///
    299297  /// \note The type of the indices is chosen to \c int for efficiency

  • 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 r741  
    325325  ///only in the concept class.
    326326  ///
    327   ///This class provides only linear time counting for nodes and arcs.
    328   ///
    329327  ///\sa concepts::Digraph
    330328  ///\sa ListGraph
    … …  
    363361    ///\brief Erase a node from the digraph.
    364362    ///
    365     ///This function erases the given node along with its outgoing and
    366     ///incoming arcs from the digraph.
    367     ///
    368     ///\note All iterators referencing the removed node or the connected
    369     ///arcs are invalidated, of course.
     363    ///This function erases the given node from the digraph.
    370364    void erase(Node n) { Parent::erase(n); }
    371365
    … …  
    373367    ///
    374368    ///This function erases the given arc from the digraph.
    375     ///
    376     ///\note All iterators referencing the removed arc are invalidated,
    377     ///of course.
    378369    void erase(Arc a) { Parent::erase(a); }
    379370
    … …  
    401392    ///
    402393    ///\note \c ArcIt and \c OutArcIt iterators referencing the changed
    403     ///arc remain valid, but \c InArcIt iterators are invalidated.
     394    ///arc remain valid, however \c InArcIt iterators are invalidated.
    404395    ///
    405396    ///\warning This functionality cannot be used together with the Snapshot
    … …  
    413404    ///
    414405    ///\note \c InArcIt iterators referencing the changed arc remain
    415     ///valid, but \c ArcIt and \c OutArcIt iterators are invalidated.
     406    ///valid, however \c ArcIt and \c OutArcIt iterators are invalidated.
    416407    ///
    417408    ///\warning This functionality cannot be used together with the Snapshot
    … …  
    520511    ///This function erases all nodes and arcs from the digraph.
    521512    ///
    522     ///\note All iterators of the digraph are invalidated, of course.
    523513    void clear() {
    524514      Parent::clear();
    … …  
    560550    /// reversing, contracting, splitting arcs or nodes) cannot be
    561551    /// restored. These events invalidate the snapshot.
    562     /// 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
    563553    /// making the current snapshot can be removed without invalidating it.
    564554    class Snapshot {
    … …  
    11901180  ///only in the concept class.
    11911181  ///
    1192   ///This class provides only linear time counting for nodes, edges and arcs.
    1193   ///
    11941182  ///\sa concepts::Graph
    11951183  ///\sa ListDigraph
    … …  
    12301218    ///\brief Erase a node from the graph.
    12311219    ///
    1232     /// This function erases the given node along with its incident arcs
    1233     /// from the graph.
    1234     ///
    1235     /// \note All iterators referencing the removed node or the incident
    1236     /// edges are invalidated, of course.
     1220    /// This function erases the given node from the graph.
    12371221    void erase(Node n) { Parent::erase(n); }
    12381222
    … …  
    12401224    ///
    12411225    /// This function erases the given edge from the graph.
    1242     ///
    1243     /// \note All iterators referencing the removed edge are invalidated,
    1244     /// of course.
    12451226    void erase(Edge e) { Parent::erase(e); }
    12461227    /// Node validity check
    … …  
    12871268    ///
    12881269    ///\note \c EdgeIt iterators referencing the changed edge remain
    1289     ///valid, but \c ArcIt iterators referencing the changed edge and
     1270    ///valid, however \c ArcIt iterators referencing the changed edge and
    12901271    ///all other iterators whose base node is the changed node are also
    12911272    ///invalidated.
    … …  
    13321313    ///This function erases all nodes and arcs from the graph.
    13331314    ///
    1334     ///\note All iterators of the graph are invalidated, of course.
    13351315    void clear() {
    13361316      Parent::clear();
    … …  
    13721352    /// (e.g. changing the end-nodes of edges or contracting nodes)
    13731353    /// cannot be restored. These events invalidate the snapshot.
    1374     /// 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
    13751355    /// making the current snapshot can be removed without invalidating it.
    13761356    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

    r792 r789  
    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/smart_graph.h

    r787 r780  
    195195  ///only in the concept class.
    196196  ///
    197   ///This class provides constant time counting for nodes and arcs.
    198   ///
    199197  ///\sa concepts::Digraph
    200198  ///\sa SmartGraph
    … …  
    623621  /// only in the concept class.
    624622  ///
    625   /// This class provides constant time counting for nodes, edges and arcs.
    626   ///
    627623  /// \sa concepts::Graph
    628624  /// \sa SmartDigraph

  • lemon/static_graph.h

    r787 r779  
    293293  /// only in the concept class.
    294294  ///
    295   /// This class provides constant time counting for nodes and arcs.
    296   ///
    297295  /// \sa concepts::Digraph
    298296  class StaticDigraph : public ExtendedStaticDigraphBase {

  • 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.