406-e0cef67fe565.patch on Ticket #406 – Attachment – LEMON

doc/coding_style.dox

# HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1294588274 -3600
# Node ID e0cef67fe565981494527c12172751fcfe6a477a
# Parent  8583fb74238ca99554339ac28adecc285e084aa0
Various doc improvements (#406)

diff --git a/doc/coding_style.dox b/doc/coding_style.dox

-                      a
 \subsection pri-loc-var Private member variables
 Private member variables should start with underscore
+Private member variables should start with underscore.
 \code
 _start_with_underscores
+_start_with_underscore
 \endcode
 \subsection cs-excep Exceptions

doc/groups.dox

diff --git a/doc/groups.dox b/doc/groups.dox

-                      a
  - \ref CycleCanceling Cycle-Canceling algorithms, two of which are
    strongly polynomial \ref klein67primal, \ref goldberg89cyclecanceling.
 In general NetworkSimplex is the most efficient implementation,
 but in special cases other algorithms could be faster.
+In general, \ref NetworkSimplex and \ref CostScaling are the most efficient
+implementations, but the other two algorithms could be faster in special cases.
 For example, if the total supply and/or capacities are rather small,
 CapacityScaling is usually the fastest algorithm (without effective scaling).
+\ref CapacityScaling is usually the fastest algorithm (without effective scaling).
 */
 /**
 …
 - \ref HowardMmc Howard's policy iteration algorithm
   \ref dasdan98minmeancycle.
 In practice, the \ref HowardMmc "Howard" algorithm proved to be by far the
+In practice, the \ref HowardMmc "Howard" algorithm turned out to be by far the
 most efficient one, though the best known theoretical bound on its running
 time is exponential.
 Both \ref KarpMmc "Karp" and \ref HartmannOrlinMmc "Hartmann-Orlin" algorithms
 …
 */
 /**
 @defgroup planar Planarity Embedding and Drawing
+@defgroup planar Planar Embedding and Drawing
 @ingroup algs
 \brief Algorithms for planarity checking, embedding and drawing

lemon/capacity_scaling.h

diff --git a/lemon/capacity_scaling.h b/lemon/capacity_scaling.h

-                      a
   ///
   /// \warning Both number types must be signed and all input data must
   /// be integer.
   /// \warning This algorithm does not support negative costs for such
   /// arcs that have infinite upper bound.
+  /// \warning This algorithm does not support negative costs for
+  /// arcs having infinite upper bound.
 #ifdef DOXYGEN
   template <typename GR, typename V, typename C, typename TR>
 #else
 …
     /// calling \ref run(), the supply of each node will be set to zero.
     ///
     /// Using this function has the same effect as using \ref supplyMap()
     /// with such a map in which \c k is assigned to \c s, \c -k is
+    /// with a map in which \c k is assigned to \c s, \c -k is
     /// assigned to \c t and all other nodes have zero supply value.
     ///
     /// \param s The source node.

lemon/core.h

diff --git a/lemon/core.h b/lemon/core.h

-                      a
+  }
   /// Check whether a graph is undirected.
+  /// \brief Check whether a graph is undirected.
   ///
   /// This function returns \c true if the given graph is undirected.
 #ifdef DOXYGEN

lemon/cost_scaling.h

diff --git a/lemon/cost_scaling.h b/lemon/cost_scaling.h

-                      a
   /// can be viewed as the generalization of the \ref Preflow
   /// "preflow push-relabel" algorithm for the maximum flow problem.
   ///
+  /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
+  /// implementations available in LEMON for this problem.
+  ///
   /// Most of the parameters of the problem (except for the digraph)
   /// can be given using separate functions, and the algorithm can be
   /// executed using the \ref run() function. If some parameters are not
 …
   ///
   /// \warning Both number types must be signed and all input data must
   /// be integer.
   /// \warning This algorithm does not support negative costs for such
   /// arcs that have infinite upper bound.
+  /// \warning This algorithm does not support negative costs for
+  /// arcs having infinite upper bound.
   ///
   /// \note %CostScaling provides three different internal methods,
   /// from which the most efficient one is used by default.
 …
     /// in their base operations, which are used in conjunction with the
     /// relabel operation.
     /// By default, the so called \ref PARTIAL_AUGMENT
     /// "Partial Augment-Relabel" method is used, which proved to be
+    /// "Partial Augment-Relabel" method is used, which turned out to be
     /// the most efficient and the most robust on various test inputs.
     /// However, the other methods can be selected using the \ref run()
     /// function with the proper parameter.
 …
     /// calling \ref run(), the supply of each node will be set to zero.
     ///
     /// Using this function has the same effect as using \ref supplyMap()
     /// with such a map in which \c k is assigned to \c s, \c -k is
+    /// with a map in which \c k is assigned to \c s, \c -k is
     /// assigned to \c t and all other nodes have zero supply value.
     ///
     /// \param s The source node.

lemon/cycle_canceling.h

diff --git a/lemon/cycle_canceling.h b/lemon/cycle_canceling.h

-                      a
   ///
   /// \warning Both number types must be signed and all input data must
   /// be integer.
   /// \warning This algorithm does not support negative costs for such
   /// arcs that have infinite upper bound.
+  /// \warning This algorithm does not support negative costs for
+  /// arcs having infinite upper bound.
   ///
   /// \note For more information about the three available methods,
   /// see \ref Method.
 …
     ///
     /// \ref CycleCanceling provides three different cycle-canceling
     /// methods. By default, \ref CANCEL_AND_TIGHTEN "Cancel and Tighten"
+    /// is used, which proved to be the most efficient and the most robust
+    /// on various test inputs.
+    /// is used, which is by far the most efficient and the most robust.
     /// However, the other methods can be selected using the \ref run()
     /// function with the proper parameter.
     enum Method {
 …
     /// calling \ref run(), the supply of each node will be set to zero.
     ///
     /// Using this function has the same effect as using \ref supplyMap()
     /// with such a map in which \c k is assigned to \c s, \c -k is
+    /// with a map in which \c k is assigned to \c s, \c -k is
     /// assigned to \c t and all other nodes have zero supply value.
     ///
     /// \param s The source node.

lemon/euler.h

diff --git a/lemon/euler.h b/lemon/euler.h

-                      a
   ///Euler tour iterator for digraphs.
   /// \ingroup graph_prop
+  /// \ingroup graph_properties
   ///This iterator provides an Euler tour (Eulerian circuit) of a \e directed
   ///graph (if there exists) and it converts to the \c Arc type of the digraph.
   ///

lemon/network_simplex.h

diff --git a/lemon/network_simplex.h b/lemon/network_simplex.h

-                      a
   /// linear programming simplex method directly for the minimum cost
   /// flow problem.
   ///
   /// In general, %NetworkSimplex is the fastest implementation available
   /// in LEMON for this problem.
   /// Moreover, it supports both directions of the supply/demand inequality
   /// constraints. For more information, see \ref SupplyType.
+  /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
+  /// implementations available in LEMON for this problem.
+  /// Furthermore, this class supports both directions of the supply/demand
+  /// inequality constraints. For more information, see \ref SupplyType.
   ///
   /// Most of the parameters of the problem (except for the digraph)
   /// can be given using separate functions, and the algorithm can be
 …
     /// implementations that significantly affect the running time
     /// of the algorithm.
     /// By default, \ref BLOCK_SEARCH "Block Search" is used, which
     /// proved to be the most efficient and the most robust on various
+    /// turend out to be the most efficient and the most robust on various
     /// test inputs.
     /// However, another pivot rule can be selected using the \ref run()
     /// function with the proper parameter.
 …
     typedef std::vector<Value> ValueVector;
     typedef std::vector<Cost> CostVector;
     typedef std::vector<signed char> CharVector;
     // Note: vector<signed char> is used instead of vector<ArcState> and
+    // Note: vector<signed char> is used instead of vector<ArcState> and
     // vector<ArcDirection> for efficiency reasons
     // State constants for arcs
 …
     /// of the algorithm.
     ///
     /// \return <tt>(*this)</tt>
+    ///
+    /// \sa supplyType()
     template<typename SupplyMap>
     NetworkSimplex& supplyMap(const SupplyMap& map) {
       for (NodeIt n(_graph); n != INVALID; ++n) {
 …
     /// calling \ref run(), the supply of each node will be set to zero.
     ///
     /// Using this function has the same effect as using \ref supplyMap()
     /// with such a map in which \c k is assigned to \c s, \c -k is
+    /// with a map in which \c k is assigned to \c s, \c -k is
     /// assigned to \c t and all other nodes have zero supply value.
     ///
     /// \param s The source node.

Context Navigation

Ticket #406: 406-e0cef67fe565.patch

doc/coding_style.dox

doc/groups.dox

lemon/capacity_scaling.h

lemon/core.h

lemon/cost_scaling.h

lemon/cycle_canceling.h

lemon/euler.h

lemon/network_simplex.h

Download in other formats: