Diff [4e3484a2e90c0d1d1250ba4f3face5afc4ec3b58:a2d5fd4c309a4c4431d3c2377cff197ebe0bf476] for / – LEMON

doc/min_cost_flow.dox

-                      r802
+                      r835
    - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.
  - For all \f$u\in V\f$ nodes:
    - \f$\pi(u)<=0\f$;
+   - \f$\pi(u)\leq 0\f$;
    - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
      then \f$\pi(u)=0\f$.
 …
    - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.
  - For all \f$u\in V\f$ nodes:
    - \f$\pi(u)>=0\f$;
+   - \f$\pi(u)\geq 0\f$;
    - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
      then \f$\pi(u)=0\f$.

lemon/adaptors.h

-                      r703
+                      r834
   /// parameter is set to be \c const.
   ///
+  /// This class provides item counting in the same time as the adapted
+  /// digraph structure.
+  ///
   /// \tparam DGR The type of the adapted digraph.
   /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 …
   /// by adding or removing nodes or arcs, unless the \c GR template
   /// parameter is set to be \c const.
+  ///
+  /// This class provides only linear time counting for nodes and arcs.
   ///
   /// \tparam DGR The type of the adapted digraph.
 …
   /// parameter is set to be \c const.
   ///
+  /// This class provides only linear time counting for nodes, edges and arcs.
+  ///
   /// \tparam GR The type of the adapted graph.
   /// It must conform to the \ref concepts::Graph "Graph" concept.
 …
   /// by adding or removing nodes or arcs/edges, unless the \c GR template
   /// parameter is set to be \c const.
+  ///
+  /// This class provides only linear time item counting.
   ///
   /// \tparam GR The type of the adapted digraph or graph.
 …
   /// parameter is set to be \c const.
   ///
+  /// This class provides only linear time counting for nodes and arcs.
+  ///
   /// \tparam DGR The type of the adapted digraph.
   /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 …
   /// by adding or removing nodes or edges, unless the \c GR template
   /// parameter is set to be \c const.
+  ///
+  /// This class provides only linear time counting for nodes, edges and arcs.
   ///
   /// \tparam GR The type of the adapted graph.
 …
   /// parameter is set to be \c const.
   ///
+  /// This class provides item counting in the same time as the adapted
+  /// digraph structure.
+  ///
   /// \tparam DGR The type of the adapted digraph.
   /// It must conform to the \ref concepts::Digraph "Digraph" concept.
 …
   /// by adding or removing nodes or arcs, unless the \c GR template
   /// parameter is set to be \c const.
+  ///
+  /// This class provides item counting in the same time as the adapted
+  /// graph structure.
   ///
   /// \tparam GR The type of the adapted graph.
 …
   /// arcs).
   /// This class conforms to the \ref concepts::Digraph "Digraph" concept.
+  ///
+  /// This class provides only linear time counting for nodes and arcs.
   ///
   /// \tparam DGR The type of the adapted digraph.
 …
   /// in the adaptor.
   ///
+  /// This class provides item counting in the same time as the adapted
+  /// digraph structure.
+  ///
   /// \tparam DGR The type of the adapted digraph.
   /// It must conform to the \ref concepts::Digraph "Digraph" concept.

lemon/bellman_ford.h

-                      r828
+                      r835
     /// \ref named-templ-param "Named parameter" for setting
     /// \c OperationTraits type.
     /// For more information see \ref BellmanFordDefaultOperationTraits.
+    /// For more information, see \ref BellmanFordDefaultOperationTraits.
     template <class T>
     struct SetOperationTraits
 …
     ///
     /// The shortest path tree used here is equal to the shortest path
     /// tree used in \ref predNode() and \predMap().
+    /// tree used in \ref predNode() and \ref predMap().
     ///
     /// \pre Either \ref run() or \ref init() must be called before
 …
     ///
     /// The shortest path tree used here is equal to the shortest path
     /// tree used in \ref predArc() and \predMap().
+    /// tree used in \ref predArc() and \ref predMap().
     ///
     /// \pre Either \ref run() or \ref init() must be called before

lemon/bfs.h

-                      r764
+                      r835
     ///The type of the map that indicates which nodes are processed.
     ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
 …
     ///Runs the algorithm to visit all nodes in the digraph.
+    ///This method runs the %BFS algorithm in order to
+    ///compute the shortest path to each node.
+    ///
+    ///The algorithm computes
+    ///- the shortest path tree (forest),
+    ///- the distance of each node from the root(s).
+    ///This method runs the %BFS algorithm in order to visit all nodes
+    ///in the digraph.
     ///
     ///\note <tt>b.run(s)</tt> is just a shortcut of the following code.
 …
     ///The type of the map that indicates which nodes are processed.
     ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a ProcessedMap.
 …
     ///Runs BFS algorithm to visit all nodes in the digraph.
     ///This method runs BFS algorithm in order to compute
     ///the shortest path to each node.
+    ///This method runs BFS algorithm in order to visit all nodes
+    ///in the digraph.
     void run()
+    {
 …
     /// \brief Runs the algorithm to visit all nodes in the digraph.
     ///
+    /// This method runs the %BFS algorithm in order to
+    /// compute the shortest path to each node.
+    ///
+    /// The algorithm computes
+    /// - the shortest path tree (forest),
+    /// - the distance of each node from the root(s).
+    /// This method runs the %BFS algorithm in order to visit all nodes
+    /// in the digraph.
     ///
     /// \note <tt>b.run(s)</tt> is just a shortcut of the following code.

lemon/circulation.h

r762	r833
307	307	/// able to automatically created by the algorithm (i.e. the
308	308	/// 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
310	310	/// algorithm with the \ref elevator(Elevator&) "elevator()" function
311	311	/// before calling \ref run() or \ref init().

lemon/concepts/digraph.h

-                      r781
+                      r833
       /// This iterator goes through each node of the digraph.
       /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of nodes in a digraph \c g of type \c %Digraph like this:
       ///\code
 …
       /// This iterator goes trough the \e outgoing arcs of a certain node
       /// of a digraph.
       /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of outgoing arcs of a node \c n
       /// in a digraph \c g of type \c %Digraph as follows.
 …
       /// This iterator goes trough the \e incoming arcs of a certain node
       /// of a digraph.
       /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of incoming arcs of a node \c n
       /// in a digraph \c g of type \c %Digraph as follows.
 …
       /// This iterator goes through each arc of the digraph.
       /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of arcs in a digraph \c g of type \c %Digraph as follows:
       ///\code

lemon/concepts/graph.h

-                      r781
+                      r833
       /// This iterator goes through each node of the graph.
       /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of nodes in a graph \c g of type \c %Graph like this:
       ///\code
 …
       /// This iterator goes through each edge of the graph.
       /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of edges in a graph \c g of type \c %Graph as follows:
       ///\code
 …
       /// This iterator goes trough the incident undirected edges
       /// of a certain node of a graph.
       /// Its usage is quite simple, for example you can compute the
+      /// Its usage is quite simple, for example, you can compute the
       /// degree (i.e. the number of incident edges) of a node \c n
       /// in a graph \c g of type \c %Graph as follows.
 …
       /// This iterator goes through each directed arc of the graph.
       /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of arcs in a graph \c g of type \c %Graph as follows:
       ///\code
 …
       /// This iterator goes trough the \e outgoing directed arcs of a
       /// certain node of a graph.
       /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of outgoing arcs of a node \c n
       /// in a graph \c g of type \c %Graph as follows.
 …
       /// This iterator goes trough the \e incoming directed arcs of a
       /// certain node of a graph.
       /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of incoming arcs of a node \c n
       /// in a graph \c g of type \c %Graph as follows.
 …
       /// Returns the first node of the given edge.
       ///
       /// Edges don't have source and target nodes, however methods
+      /// Edges don't have source and target nodes, however, methods
       /// u() and v() are used to query the two end-nodes of an edge.
       /// The orientation of an edge that arises this way is called
 …
       /// Returns the second node of the given edge.
       ///
       /// Edges don't have source and target nodes, however methods
+      /// Edges don't have source and target nodes, however, methods
       /// u() and v() are used to query the two end-nodes of an edge.
       /// The orientation of an edge that arises this way is called

lemon/concepts/graph_components.h

r781	r833
19	19	///\ingroup graph_concepts
20	20	///\file
21		///\brief The concept of graph components.
	21	///\brief The concepts of graph components.
22	22
23	23	#ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H

lemon/concepts/path.h

-                      r606
+                      r832
 ///\ingroup concept
 ///\file
 ///\brief Classes for representing paths in digraphs.
+///\brief The concept of paths
 ///
 …
     /// A skeleton structure for representing directed paths in a
     /// digraph.
+    /// In a sense, a path can be treated as a list of arcs.
+    /// LEMON path types just store this list. As a consequence, they cannot
+    /// enumerate the nodes on the path directly and a zero length path
+    /// cannot store its source node.
+    ///
+    /// The arcs of a path should be stored in the order of their directions,
+    /// i.e. the target node of each arc should be the same as the source
+    /// node of the next arc. This consistency could be checked using
+    /// \ref checkPath().
+    /// The source and target nodes of a (consistent) path can be obtained
+    /// using \ref pathSource() and \ref pathTarget().
+    ///
+    /// A path can be constructed from another path of any type using the
+    /// copy constructor or the assignment operator.
+    ///
     /// \tparam GR The digraph type in which the path is.
-    ///
-    /// In a sense, the path can be treated as a list of arcs. The
-    /// lemon path type stores just this list. As a consequence it
-    /// cannot enumerate the nodes in the path and the zero length
-    /// paths cannot store the source.
-    ///
     template <typename GR>
     class Path {
 …
       Path() {}
       /// \brief Template constructor
+      /// \brief Template copy constructor
       template <typename CPath>
       Path(const CPath& cpath) {}
       /// \brief Template assigment
+      /// \brief Template assigment operator
       template <typename CPath>
       Path& operator=(const CPath& cpath) {
 …
+      }
       /// Length of the path ie. the number of arcs in the path.
+      /// Length of the path, i.e. the number of arcs on the path.
       int length() const { return 0;}
 …
       void clear() {}
       /// \brief LEMON style iterator for path arcs
+      /// \brief LEMON style iterator for enumerating the arcs of a path.
       ///
       /// This class is used to iterate on the arcs of the paths.
+      /// LEMON style iterator class for enumerating the arcs of a path.
       class ArcIt {
       public:
 …
         /// Invalid constructor
         ArcIt(Invalid) {}
         /// Constructor for first arc
+        /// Sets the iterator to the first arc of the given path
         ArcIt(const Path &) {}
         /// Conversion to Arc
+        /// Conversion to \c Arc
         operator Arc() const { return INVALID; }
 …
     ///
     /// A skeleton structure for path dumpers. The path dumpers are
+    /// the generalization of the paths. The path dumpers can
+    /// enumerate the arcs of the path wheter in forward or in
+    /// backward order.  In most time these classes are not used
+    /// directly rather it used to assign a dumped class to a real
+    /// path type.
+    /// the generalization of the paths, they can enumerate the arcs
+    /// of the path either in forward or in backward order.
+    /// These classes are typically not used directly, they are rather
+    /// used to be assigned to a real path type.
     ///
     /// The main purpose of this concept is that the shortest path
+    /// algorithms can enumerate easily the arcs in reverse order.
+    /// If we would like to give back a real path from these
+    /// algorithms then we should create a temporarly path object. In
+    /// LEMON such algorithms gives back a path dumper what can
+    /// assigned to a real path and the dumpers can be implemented as
+    /// algorithms can enumerate the arcs easily in reverse order.
+    /// In LEMON, such algorithms give back a (reverse) path dumper that
+    /// can be assigned to a real path. The dumpers can be implemented as
     /// an adaptor class to the predecessor map.
     ///
     /// \tparam GR The digraph type in which the path is.
-    ///
-    /// The paths can be constructed from any path type by a
-    /// template constructor or a template assignment operator.
     template <typename GR>
     class PathDumper {
 …
       typedef typename Digraph::Arc Arc;
       /// Length of the path ie. the number of arcs in the path.
+      /// Length of the path, i.e. the number of arcs on the path.
       int length() const { return 0;}
 …
       /// \brief Forward or reverse dumping
       ///
+      /// If the RevPathTag is defined and true then reverse dumping
+      /// is provided in the path dumper. In this case instead of the
+      /// ArcIt the RevArcIt iterator should be implemented in the
+      /// dumper.
+      /// If this tag is defined to be \c True, then reverse dumping
+      /// is provided in the path dumper. In this case, \c RevArcIt
+      /// iterator should be implemented instead of \c ArcIt iterator.
       typedef False RevPathTag;
       /// \brief LEMON style iterator for path arcs
+      /// \brief LEMON style iterator for enumerating the arcs of a path.
       ///
       /// This class is used to iterate on the arcs of the paths.
+      /// LEMON style iterator class for enumerating the arcs of a path.
       class ArcIt {
       public:
 …
         /// Invalid constructor
         ArcIt(Invalid) {}
         /// Constructor for first arc
+        /// Sets the iterator to the first arc of the given path
         ArcIt(const PathDumper&) {}
         /// Conversion to Arc
+        /// Conversion to \c Arc
         operator Arc() const { return INVALID; }
 …
       };
+      /// \brief LEMON style iterator for path arcs
+      /// \brief LEMON style iterator for enumerating the arcs of a path
+      /// in reverse direction.
       ///
       /// This class is used to iterate on the arcs of the paths in
       /// reverse direction.
+      /// LEMON style iterator class for enumerating the arcs of a path
+      /// in reverse direction.
       class RevArcIt {
       public:
 …
         /// Invalid constructor
         RevArcIt(Invalid) {}
         /// Constructor for first arc
+        /// Sets the iterator to the last arc of the given path
         RevArcIt(const PathDumper &) {}
         /// Conversion to Arc
+        /// Conversion to \c Arc
         operator Arc() const { return INVALID; }

lemon/counter.h

r463	r833
213	213	/// 'Do nothing' version of Counter.
214	214
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
216	216	/// does not count at all and does not print report on destruction.
217	217	///

lemon/dfs.h

-                      r764
+                      r835
     ///The type of the map that indicates which nodes are processed.
     ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
 …
     ///Runs the algorithm to visit all nodes in the digraph.
+    ///This method runs the %DFS algorithm in order to compute the
+    ///%DFS path to each node.
+    ///
+    ///The algorithm computes
+    ///- the %DFS tree (forest),
+    ///- the distance of each node from the root(s) in the %DFS tree.
+    ///This method runs the %DFS algorithm in order to visit all nodes
+    ///in the digraph.
     ///
     ///\note <tt>d.run()</tt> is just a shortcut of the following code.
 …
     ///The type of the map that indicates which nodes are processed.
     ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a ProcessedMap.
 …
     ///Runs DFS algorithm to visit all nodes in the digraph.
     ///This method runs DFS algorithm in order to compute
     ///the DFS path to each node.
+    ///This method runs DFS algorithm in order to visit all nodes
+    ///in the digraph.
     void run()
+    {
 …
     /// \brief Runs the algorithm to visit all nodes in the digraph.
+    /// This method runs the %DFS algorithm in order to
+    /// compute the %DFS path to each node.
+    ///
+    /// The algorithm computes
+    /// - the %DFS tree (forest),
+    /// - the distance of each node from the root(s) in the %DFS tree.
+    /// This method runs the %DFS algorithm in order to visit all nodes
+    /// in the digraph.
     ///
     /// \note <tt>d.run()</tt> is just a shortcut of the following code.

lemon/dijkstra.h

-                      r764
+                      r835
     ///The type of the map that indicates which nodes are processed.
     ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
 …
     ///The type of the arc lengths.
     typedef typename TR::LengthMap::Value Value;
+    typedef typename TR::Value Value;
     ///The type of the map that stores the arc lengths.
     typedef typename TR::LengthMap LengthMap;
 …
     ///passed to the constructor of the cross reference and the cross
     ///reference should be passed to the constructor of the heap).
     ///However external heap and cross reference objects could also be
+    ///However, external heap and cross reference objects could also be
     ///passed to the algorithm using the \ref heap() function before
     ///calling \ref run(Node) "run()" or \ref init().
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c OperationTraits type.
     /// For more information see \ref DijkstraDefaultOperationTraits.
+    /// For more information, see \ref DijkstraDefaultOperationTraits.
     template <class T>
     struct SetOperationTraits
 …
     ///The type of the map that indicates which nodes are processed.
     ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     ///By default it is a NullMap.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a ProcessedMap.

lemon/edge_set.h

-                      r825
+                      r834
   /// all arcs incident to the given node is erased from the arc set.
   ///
+  /// This class fully conforms to the \ref concepts::Digraph
+  /// "Digraph" concept.
+  /// It provides only linear time counting for nodes and arcs.
+  ///
   /// \param GR The type of the graph which shares its node set with
   /// this class. Its interface must conform to the
   /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
   /// concept.
-  ///
-  /// This class fully conforms to the \ref concepts::Digraph
-  /// "Digraph" concept.
   template <typename GR>
   class ListArcSet : public ArcSetExtender<ListArcSetBase<GR> > {
 …
   /// incident to the given node is erased from the arc set.
   ///
+  /// This class fully conforms to the \ref concepts::Graph "Graph"
+  /// concept.
+  /// It provides only linear time counting for nodes, edges and arcs.
+  ///
   /// \param GR The type of the graph which shares its node set
   /// with this class. Its interface must conform to the
   /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
-  /// concept.
-  ///
-  /// This class fully conforms to the \ref concepts::Graph "Graph"
   /// concept.
   template <typename GR>
 …
   /// arcs. Therefore the arcs cannot be erased from the arc sets.
   ///
+  /// This class fully conforms to the \ref concepts::Digraph "Digraph"
+  /// concept.
+  /// It provides only linear time counting for nodes and arcs.
+  ///
   /// \warning If a node is erased from the underlying graph and this
   /// node is the source or target of one arc in the arc set, then
   /// the arc set is invalidated, and it cannot be used anymore. The
   /// validity can be checked with the \c valid() member function.
-  ///
-  /// This class fully conforms to the \ref concepts::Digraph
-  /// "Digraph" concept.
   template <typename GR>
   class SmartArcSet : public ArcSetExtender<SmartArcSetBase<GR> > {
 …
   /// edges cannot be erased from the edge sets.
   ///
+  /// This class fully conforms to the \ref concepts::Graph "Graph"
+  /// concept.
+  /// It provides only linear time counting for nodes, edges and arcs.
+  ///
   /// \warning If a node is erased from the underlying graph and this
   /// node is incident to one edge in the edge set, then the edge set
   /// is invalidated, and it cannot be used anymore. The validity can
   /// be checked with the \c valid() member function.
-  ///
-  /// This class fully conforms to the \ref concepts::Graph
-  /// "Graph" concept.
   template <typename GR>
   class SmartEdgeSet : public EdgeSetExtender<SmartEdgeSetBase<GR> > {

lemon/full_graph.h

-                      r827
+                      r834
   /// only in the concept class.
   ///
+  /// This class provides constant time counting for nodes and arcs.
+  ///
   /// \note FullDigraph and FullGraph classes are very similar,
   /// but there are two differences. While this class conforms only
 …
     /// completely static, the nodes can be indexed with integers from
     /// the range <tt>[0..nodeNum()-1]</tt>.
+    /// The index of a node is the same as its ID.
     /// \sa index()
     Node operator()(int ix) const { return Parent::operator()(ix); }
 …
     /// completely static, the nodes can be indexed with integers from
     /// the range <tt>[0..nodeNum()-1]</tt>.
+    /// The index of a node is the same as its ID.
     /// \sa operator()()
     static int index(const Node& node) { return Parent::index(node); }
 …
   /// only in the concept class.
   ///
+  /// This class provides constant time counting for nodes, edges and arcs.
+  ///
   /// \note FullDigraph and FullGraph classes are very similar,
   /// but there are two differences. While FullDigraph
 …
     /// completely static, the nodes can be indexed with integers from
     /// the range <tt>[0..nodeNum()-1]</tt>.
+    /// The index of a node is the same as its ID.
     /// \sa index()
     Node operator()(int ix) const { return Parent::operator()(ix); }
 …
     /// completely static, the nodes can be indexed with integers from
     /// the range <tt>[0..nodeNum()-1]</tt>.
+    /// The index of a node is the same as its ID.
     /// \sa operator()()
     static int index(const Node& node) { return Parent::index(node); }

lemon/gomory_hu.h

-                      r760
+                      r833
     /// \pre \ref run() must be called before using this function.
     template <typename CutMap>
     Value minCutMap(const Node& s, ///<
+    Value minCutMap(const Node& s,
                     const Node& t,
-                    ///<
                     CutMap& cutMap
-                    ///<
                     ) const {
       Node sn = s, tn = t;
 …
                    /// \endcode
                    /// does not necessarily give the same set of nodes.
                    /// However it is ensured that
+                   /// However, it is ensured that
                    /// \code
                    /// MinCutNodeIt(gomory, s, t, true);

lemon/graph_to_eps.h

-                      r664
+                      r833
   ///\param gr  Reference to the graph to be printed.
   ///\param ost Reference to the output stream.
   ///By default it is <tt>std::cout</tt>.
+  ///By default, it is <tt>std::cout</tt>.
   ///\param pros If it is \c true, then the \c ostream referenced by \c os
   ///will be explicitly deallocated by the destructor.
 …
   ///Turn on/off pre-scaling
   ///By default graphToEps() rescales the whole image in order to avoid
+  ///By default, graphToEps() rescales the whole image in order to avoid
   ///very big or very small bounding boxes.
   ///
 …
 ///\param g Reference to the graph to be printed.
 ///\param os Reference to the output stream.
 ///By default it is <tt>std::cout</tt>.
+///By default, it is <tt>std::cout</tt>.
 ///
 ///This function also has a lot of
 …
 ///\endcode
 ///
 ///For more detailed examples see the \ref graph_to_eps_demo.cc demo file.
+///For more detailed examples, see the \ref graph_to_eps_demo.cc demo file.
 ///
 ///\warning Don't forget to put the \ref GraphToEps::run() "run()"

lemon/grid_graph.h

r782	r834
504	504	/// Most of its member functions and nested classes are documented
505	505	/// only in the concept class.
	506	///
	507	/// This class provides constant time counting for nodes, edges and arcs.
506	508	class GridGraph : public ExtendedGridGraphBase {
507	509	typedef ExtendedGridGraphBase Parent;

lemon/hypercube_graph.h

-                      r827
+                      r835
   /// differ only on one position in the binary form.
   /// This class is completely static and it needs constant memory space.
   /// Thus you can neither add nor delete nodes or edges, however
+  /// Thus you can neither add nor delete nodes or edges, however,
   /// the structure can be resized using resize().
   ///
 …
   /// Most of its member functions and nested classes are documented
   /// only in the concept class.
+  ///
+  /// This class provides constant time counting for nodes, edges and arcs.
   ///
   /// \note The type of the indices is chosen to \c int for efficiency

lemon/lgf_reader.h

-                      r646
+                      r833
   ///\endcode
   ///
   /// By default the reader uses the first section in the file of the
+  /// By default, the reader uses the first section in the file of the
   /// proper type. If a section has an optional name, then it can be
   /// selected for reading by giving an optional name parameter to the
 …
     /// whitespaces are trimmed from each processed string.
     ///
     /// For example let's see a section, which contain several
+    /// For example, let's see a section, which contain several
     /// integers, which should be inserted into a vector.
     ///\code

lemon/list_graph.h

-                      r788
+                      r835
   ///only in the concept class.
   ///
+  ///This class provides only linear time counting for nodes and arcs.
+  ///
   ///\sa concepts::Digraph
   ///\sa ListGraph
 …
     ///\brief Erase a node from the digraph.
     ///
+    ///This function erases the given node from the digraph.
+    ///This function erases the given node along with its outgoing and
+    ///incoming arcs from the digraph.
+    ///
+    ///\note All iterators referencing the removed node or the connected
+    ///arcs are invalidated, of course.
     void erase(Node n) { Parent::erase(n); }
 …
     ///
     ///This function erases the given arc from the digraph.
+    ///
+    ///\note All iterators referencing the removed arc are invalidated,
+    ///of course.
     void erase(Arc a) { Parent::erase(a); }
 …
     ///
     ///\note \c ArcIt and \c OutArcIt iterators referencing the changed
     ///arc remain valid, however \c InArcIt iterators are invalidated.
+    ///arc remain valid, but \c InArcIt iterators are invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
 …
     ///
     ///\note \c InArcIt iterators referencing the changed arc remain
     ///valid, however \c ArcIt and \c OutArcIt iterators are invalidated.
+    ///valid, but \c ArcIt and \c OutArcIt iterators are invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
 …
     ///This function erases all nodes and arcs from the digraph.
     ///
+    ///\note All iterators of the digraph are invalidated, of course.
     void clear() {
       Parent::clear();
 …
     /// reversing, contracting, splitting arcs or nodes) cannot be
     /// restored. These events invalidate the snapshot.
     /// However the arcs and nodes that were added to the digraph after
+    /// However, the arcs and nodes that were added to the digraph after
     /// making the current snapshot can be removed without invalidating it.
     class Snapshot {
 …
   ///only in the concept class.
   ///
+  ///This class provides only linear time counting for nodes, edges and arcs.
+  ///
   ///\sa concepts::Graph
   ///\sa ListDigraph
 …
     ///\brief Erase a node from the graph.
     ///
+    /// This function erases the given node from the graph.
+    /// This function erases the given node along with its incident arcs
+    /// from the graph.
+    ///
+    /// \note All iterators referencing the removed node or the incident
+    /// edges are invalidated, of course.
     void erase(Node n) { Parent::erase(n); }
 …
     ///
     /// This function erases the given edge from the graph.
+    ///
+    /// \note All iterators referencing the removed edge are invalidated,
+    /// of course.
     void erase(Edge e) { Parent::erase(e); }
     /// Node validity check
 …
     ///
     ///\note \c EdgeIt iterators referencing the changed edge remain
     ///valid, however \c ArcIt iterators referencing the changed edge and
+    ///valid, but \c ArcIt iterators referencing the changed edge and
     ///all other iterators whose base node is the changed node are also
     ///invalidated.
 …
     ///This function erases all nodes and arcs from the graph.
     ///
+    ///\note All iterators of the graph are invalidated, of course.
     void clear() {
       Parent::clear();
 …
     /// (e.g. changing the end-nodes of edges or contracting nodes)
     /// cannot be restored. These events invalidate the snapshot.
     /// However the edges and nodes that were added to the graph after
+    /// However, the edges and nodes that were added to the graph after
     /// making the current snapshot can be removed without invalidating it.
     class Snapshot {

lemon/lp_base.h

-                      r793
+                      r833
     ///Iterator for iterate over the columns of an LP problem
     /// Its usage is quite simple, for example you can count the number
+    /// Its usage is quite simple, for example, you can count the number
     /// of columns in an LP \c lp:
     ///\code
 …
     ///Iterator for iterate over the rows of an LP problem
     /// Its usage is quite simple, for example you can count the number
+    /// Its usage is quite simple, for example, you can count the number
     /// of rows in an LP \c lp:
     ///\code

lemon/maps.h

-                      r836
+                      r839
   /// This map is essentially a wrapper for \c std::vector. It assigns
   /// values to integer keys from the range <tt>[0..size-1]</tt>.
   /// It can be used with some data structures, for example
   /// \c UnionFind, \c BinHeap, when the used items are small
+  /// It can be used together with some data structures, e.g.
+  /// heap types and \c UnionFind, when the used items are small
   /// integers. This map conforms to the \ref concepts::ReferenceMap
   /// "ReferenceMap" concept.
+  /// "ReferenceMap" concept.
   ///
   /// The simplest way of using this map is through the rangeMap()
 …
   /// The name of this type also refers to this important usage.
   ///
   /// Apart form that this map can be used in many other cases since it
+  /// Apart form that, this map can be used in many other cases since it
   /// is based on \c std::map, which is a general associative container.
   /// However keep in mind that it is usually not as efficient as other
+  /// However, keep in mind that it is usually not as efficient as other
   /// maps.
   ///
 …
   /// The most important usage of it is storing certain nodes or arcs
   /// that were marked \c true by an algorithm.
   /// For example it makes easier to store the nodes in the processing
+  /// For example, it makes easier to store the nodes in the processing
   /// order of Dfs algorithm, as the following examples show.
   /// \code
 …
   ///
   /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so
   /// it cannot be used when a readable map is needed, for example as
+  /// it cannot be used when a readable map is needed, for example, as
   /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms.
   ///
 …
   /// Otherwise consider to use \c IterableValueMap, which is more
   /// suitable and more efficient for such cases. It provides iterators
   /// to traverse the items with the same associated value, however
+  /// to traverse the items with the same associated value, but
   /// it does not have \c InverseMap.
   ///
 …
   /// may provide alternative ways to modify the digraph.
   /// The correct behavior of InDegMap is not guarantied if these additional
   /// features are used. For example the functions
+  /// features are used. For example, the functions
   /// \ref ListDigraph::changeSource() "changeSource()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and
 …
   /// may provide alternative ways to modify the digraph.
   /// The correct behavior of OutDegMap is not guarantied if these additional
   /// features are used. For example the functions
+  /// features are used. For example, the functions
   /// \ref ListDigraph::changeSource() "changeSource()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and

lemon/network_simplex.h

-                      r802
+                      r835
   /// in LEMON for the minimum cost flow problem.
   /// Moreover it supports both directions of the supply/demand inequality
   /// constraints. For more information see \ref SupplyType.
+  /// constraints. For more information, see \ref SupplyType.
   ///
   /// Most of the parameters of the problem (except for the digraph)
 …
   /// \tparam GR The digraph type the algorithm runs on.
   /// \tparam V The value type used for flow amounts, capacity bounds
   /// and supply values in the algorithm. By default it is \c int.
+  /// and supply values in the algorithm. By default, it is \c int.
   /// \tparam C The value type used for costs and potentials in the
   /// algorithm. By default it is the same as \c V.
+  /// algorithm. By default, it is the same as \c V.
   ///
   /// \warning Both value types must be signed and all input data must
 …
   /// \note %NetworkSimplex provides five different pivot rule
   /// implementations, from which the most efficient one is used
   /// by default. For more information see \ref PivotRule.
+  /// by default. For more information, see \ref PivotRule.
   template <typename GR, typename V = int, typename C = V>
   class NetworkSimplex
 …
     /// implementations that significantly affect the running time
     /// of the algorithm.
     /// By default \ref BLOCK_SEARCH "Block Search" is used, which
+    /// By default, \ref BLOCK_SEARCH "Block Search" is used, which
     /// proved to be the most efficient and the most robust on various
     /// test inputs according to our benchmark tests.
     /// However another pivot rule can be selected using the \ref run()
+    /// However, another pivot rule can be selected using the \ref run()
     /// function with the proper parameter.
     enum PivotRule {
       /// The First Eligible pivot rule.
+      /// The \e First \e Eligible pivot rule.
       /// The next eligible arc is selected in a wraparound fashion
       /// in every iteration.
       FIRST_ELIGIBLE,
       /// The Best Eligible pivot rule.
+      /// The \e Best \e Eligible pivot rule.
       /// The best eligible arc is selected in every iteration.
       BEST_ELIGIBLE,
       /// The Block Search pivot rule.
+      /// The \e Block \e Search pivot rule.
       /// A specified number of arcs are examined in every iteration
       /// in a wraparound fashion and the best eligible arc is selected
 …
       BLOCK_SEARCH,
       /// The Candidate List pivot rule.
+      /// The \e Candidate \e List pivot rule.
       /// In a major iteration a candidate list is built from eligible arcs
       /// in a wraparound fashion and in the following minor iterations
 …
       CANDIDATE_LIST,
       /// The Altering Candidate List pivot rule.
+      /// The \e Altering \e Candidate \e List pivot rule.
       /// It is a modified version of the Candidate List method.
       /// It keeps only the several best eligible arcs from the former
 …
     /// type will be used.
     ///
     /// For more information see \ref SupplyType.
+    /// For more information, see \ref SupplyType.
     ///
     /// \return <tt>(*this)</tt>
 …
     /// \ref reset() is called, thus only the modified parameters
     /// have to be set again. See \ref reset() for examples.
     /// However the underlying digraph must not be modified after this
+    /// However, the underlying digraph must not be modified after this
     /// class have been constructed, since it copies and extends the graph.
     ///
     /// \param pivot_rule The pivot rule that will be used during the
     /// algorithm. For more information see \ref PivotRule.
+    /// algorithm. For more information, see \ref PivotRule.
     ///
     /// \return \c INFEASIBLE if no feasible flow exists,
 …
     /// used, all the parameters given before are kept for the next
     /// \ref run() call.
     /// However the underlying digraph must not be modified after this
+    /// However, the underlying digraph must not be modified after this
     /// class have been constructed, since it copies and extends the graph.
     ///

lemon/preflow.h

r802	r835
266	266	/// able to automatically created by the algorithm (i.e. the
267	267	/// 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
269	269	/// algorithm with the \ref elevator(Elevator&) "elevator()" function
270	270	/// before calling \ref run() or \ref init().

lemon/smart_graph.h

-                      r827
+                      r834
   ///only in the concept class.
   ///
+  ///This class provides constant time counting for nodes and arcs.
+  ///
   ///\sa concepts::Digraph
   ///\sa SmartGraph
 …
   /// only in the concept class.
   ///
+  /// This class provides constant time counting for nodes, edges and arcs.
+  ///
   /// \sa concepts::Graph
   /// \sa SmartDigraph

lemon/static_graph.h

r826	r834
293	293	/// only in the concept class.
294	294	///
	295	/// This class provides constant time counting for nodes and arcs.
	296	///
295	297	/// \sa concepts::Digraph
296	298	class StaticDigraph : public ExtendedStaticDigraphBase {

lemon/time_measure.h

r631	r833
376	376	///This function returns the number of stop() exections that is
377	377	///necessary to really stop the timer.
378		///For example the timer
	378	///For example, the timer
379	379	///is running if and only if the return value is \c true
380	380	///(i.e. greater than

lemon/unionfind.h

r606	r833
44	44	/// This is a very simple but efficient implementation, providing
45	45	/// 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.
47	47	///
48	48	/// It is primarily used in Kruskal algorithm for finding minimal

Context Navigation

Changes in / [838:4e3484a2e90c:839:a2d5fd4c309a] in lemon

Legend:

doc/min_cost_flow.dox

lemon/adaptors.h

lemon/bellman_ford.h

lemon/bfs.h

lemon/circulation.h

lemon/concepts/digraph.h

lemon/concepts/graph.h

lemon/concepts/graph_components.h

lemon/concepts/path.h

lemon/counter.h

lemon/dfs.h

lemon/dijkstra.h

lemon/edge_set.h

lemon/full_graph.h

lemon/gomory_hu.h

lemon/graph_to_eps.h

lemon/grid_graph.h

lemon/hypercube_graph.h

lemon/lgf_reader.h

lemon/list_graph.h

lemon/lp_base.h

lemon/maps.h

lemon/network_simplex.h

lemon/preflow.h

lemon/smart_graph.h

lemon/static_graph.h

lemon/time_measure.h

lemon/unionfind.h

Download in other formats: