1.1 --- a/doc/coding_style.dox Sat Jan 08 15:52:07 2011 +0100
1.2 +++ b/doc/coding_style.dox Sun Jan 09 16:51:14 2011 +0100
1.3 @@ -98,10 +98,10 @@
1.4
1.5 \subsection pri-loc-var Private member variables
1.6
1.7 -Private member variables should start with underscore
1.8 +Private member variables should start with underscore.
1.9
1.10 \code
1.11 -_start_with_underscores
1.12 +_start_with_underscore
1.13 \endcode
1.14
1.15 \subsection cs-excep Exceptions
2.1 --- a/doc/groups.dox Sat Jan 08 15:52:07 2011 +0100
2.2 +++ b/doc/groups.dox Sun Jan 09 16:51:14 2011 +0100
2.3 @@ -406,10 +406,10 @@
2.4 - \ref CycleCanceling Cycle-Canceling algorithms, two of which are
2.5 strongly polynomial \ref klein67primal, \ref goldberg89cyclecanceling.
2.6
2.7 -In general NetworkSimplex is the most efficient implementation,
2.8 -but in special cases other algorithms could be faster.
2.9 +In general, \ref NetworkSimplex and \ref CostScaling are the most efficient
2.10 +implementations, but the other two algorithms could be faster in special cases.
2.11 For example, if the total supply and/or capacities are rather small,
2.12 -CapacityScaling is usually the fastest algorithm (without effective scaling).
2.13 +\ref CapacityScaling is usually the fastest algorithm (without effective scaling).
2.14 */
2.15
2.16 /**
2.17 @@ -471,7 +471,7 @@
2.18 - \ref HowardMmc Howard's policy iteration algorithm
2.19 \ref dasdan98minmeancycle.
2.20
2.21 -In practice, the \ref HowardMmc "Howard" algorithm proved to be by far the
2.22 +In practice, the \ref HowardMmc "Howard" algorithm turned out to be by far the
2.23 most efficient one, though the best known theoretical bound on its running
2.24 time is exponential.
2.25 Both \ref KarpMmc "Karp" and \ref HartmannOrlinMmc "Hartmann-Orlin" algorithms
2.26 @@ -539,7 +539,7 @@
2.27 */
2.28
2.29 /**
2.30 -@defgroup planar Planarity Embedding and Drawing
2.31 +@defgroup planar Planar Embedding and Drawing
2.32 @ingroup algs
2.33 \brief Algorithms for planarity checking, embedding and drawing
2.34
3.1 --- a/lemon/capacity_scaling.h Sat Jan 08 15:52:07 2011 +0100
3.2 +++ b/lemon/capacity_scaling.h Sun Jan 09 16:51:14 2011 +0100
3.3 @@ -88,8 +88,8 @@
3.4 ///
3.5 /// \warning Both number types must be signed and all input data must
3.6 /// be integer.
3.7 - /// \warning This algorithm does not support negative costs for such
3.8 - /// arcs that have infinite upper bound.
3.9 + /// \warning This algorithm does not support negative costs for
3.10 + /// arcs having infinite upper bound.
3.11 #ifdef DOXYGEN
3.12 template <typename GR, typename V, typename C, typename TR>
3.13 #else
3.14 @@ -422,7 +422,7 @@
3.15 /// calling \ref run(), the supply of each node will be set to zero.
3.16 ///
3.17 /// Using this function has the same effect as using \ref supplyMap()
3.18 - /// with such a map in which \c k is assigned to \c s, \c -k is
3.19 + /// with a map in which \c k is assigned to \c s, \c -k is
3.20 /// assigned to \c t and all other nodes have zero supply value.
3.21 ///
3.22 /// \param s The source node.
4.1 --- a/lemon/core.h Sat Jan 08 15:52:07 2011 +0100
4.2 +++ b/lemon/core.h Sun Jan 09 16:51:14 2011 +0100
4.3 @@ -447,7 +447,7 @@
4.4
4.5 }
4.6
4.7 - /// Check whether a graph is undirected.
4.8 + /// \brief Check whether a graph is undirected.
4.9 ///
4.10 /// This function returns \c true if the given graph is undirected.
4.11 #ifdef DOXYGEN
5.1 --- a/lemon/cost_scaling.h Sat Jan 08 15:52:07 2011 +0100
5.2 +++ b/lemon/cost_scaling.h Sun Jan 09 16:51:14 2011 +0100
5.3 @@ -97,6 +97,9 @@
5.4 /// can be viewed as the generalization of the \ref Preflow
5.5 /// "preflow push-relabel" algorithm for the maximum flow problem.
5.6 ///
5.7 + /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
5.8 + /// implementations available in LEMON for this problem.
5.9 + ///
5.10 /// Most of the parameters of the problem (except for the digraph)
5.11 /// can be given using separate functions, and the algorithm can be
5.12 /// executed using the \ref run() function. If some parameters are not
5.13 @@ -115,8 +118,8 @@
5.14 ///
5.15 /// \warning Both number types must be signed and all input data must
5.16 /// be integer.
5.17 - /// \warning This algorithm does not support negative costs for such
5.18 - /// arcs that have infinite upper bound.
5.19 + /// \warning This algorithm does not support negative costs for
5.20 + /// arcs having infinite upper bound.
5.21 ///
5.22 /// \note %CostScaling provides three different internal methods,
5.23 /// from which the most efficient one is used by default.
5.24 @@ -178,7 +181,7 @@
5.25 /// in their base operations, which are used in conjunction with the
5.26 /// relabel operation.
5.27 /// By default, the so called \ref PARTIAL_AUGMENT
5.28 - /// "Partial Augment-Relabel" method is used, which proved to be
5.29 + /// "Partial Augment-Relabel" method is used, which turned out to be
5.30 /// the most efficient and the most robust on various test inputs.
5.31 /// However, the other methods can be selected using the \ref run()
5.32 /// function with the proper parameter.
5.33 @@ -447,7 +450,7 @@
5.34 /// calling \ref run(), the supply of each node will be set to zero.
5.35 ///
5.36 /// Using this function has the same effect as using \ref supplyMap()
5.37 - /// with such a map in which \c k is assigned to \c s, \c -k is
5.38 + /// with a map in which \c k is assigned to \c s, \c -k is
5.39 /// assigned to \c t and all other nodes have zero supply value.
5.40 ///
5.41 /// \param s The source node.
6.1 --- a/lemon/cycle_canceling.h Sat Jan 08 15:52:07 2011 +0100
6.2 +++ b/lemon/cycle_canceling.h Sun Jan 09 16:51:14 2011 +0100
6.3 @@ -67,8 +67,8 @@
6.4 ///
6.5 /// \warning Both number types must be signed and all input data must
6.6 /// be integer.
6.7 - /// \warning This algorithm does not support negative costs for such
6.8 - /// arcs that have infinite upper bound.
6.9 + /// \warning This algorithm does not support negative costs for
6.10 + /// arcs having infinite upper bound.
6.11 ///
6.12 /// \note For more information about the three available methods,
6.13 /// see \ref Method.
6.14 @@ -116,8 +116,7 @@
6.15 ///
6.16 /// \ref CycleCanceling provides three different cycle-canceling
6.17 /// methods. By default, \ref CANCEL_AND_TIGHTEN "Cancel and Tighten"
6.18 - /// is used, which proved to be the most efficient and the most robust
6.19 - /// on various test inputs.
6.20 + /// is used, which is by far the most efficient and the most robust.
6.21 /// However, the other methods can be selected using the \ref run()
6.22 /// function with the proper parameter.
6.23 enum Method {
6.24 @@ -349,7 +348,7 @@
6.25 /// calling \ref run(), the supply of each node will be set to zero.
6.26 ///
6.27 /// Using this function has the same effect as using \ref supplyMap()
6.28 - /// with such a map in which \c k is assigned to \c s, \c -k is
6.29 + /// with a map in which \c k is assigned to \c s, \c -k is
6.30 /// assigned to \c t and all other nodes have zero supply value.
6.31 ///
6.32 /// \param s The source node.
7.1 --- a/lemon/euler.h Sat Jan 08 15:52:07 2011 +0100
7.2 +++ b/lemon/euler.h Sun Jan 09 16:51:14 2011 +0100
7.3 @@ -36,7 +36,7 @@
7.4
7.5 ///Euler tour iterator for digraphs.
7.6
7.7 - /// \ingroup graph_prop
7.8 + /// \ingroup graph_properties
7.9 ///This iterator provides an Euler tour (Eulerian circuit) of a \e directed
7.10 ///graph (if there exists) and it converts to the \c Arc type of the digraph.
7.11 ///
8.1 --- a/lemon/network_simplex.h Sat Jan 08 15:52:07 2011 +0100
8.2 +++ b/lemon/network_simplex.h Sun Jan 09 16:51:14 2011 +0100
8.3 @@ -47,10 +47,10 @@
8.4 /// linear programming simplex method directly for the minimum cost
8.5 /// flow problem.
8.6 ///
8.7 - /// In general, %NetworkSimplex is the fastest implementation available
8.8 - /// in LEMON for this problem.
8.9 - /// Moreover, it supports both directions of the supply/demand inequality
8.10 - /// constraints. For more information, see \ref SupplyType.
8.11 + /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
8.12 + /// implementations available in LEMON for this problem.
8.13 + /// Furthermore, this class supports both directions of the supply/demand
8.14 + /// inequality constraints. For more information, see \ref SupplyType.
8.15 ///
8.16 /// Most of the parameters of the problem (except for the digraph)
8.17 /// can be given using separate functions, and the algorithm can be
8.18 @@ -125,7 +125,7 @@
8.19 /// implementations that significantly affect the running time
8.20 /// of the algorithm.
8.21 /// By default, \ref BLOCK_SEARCH "Block Search" is used, which
8.22 - /// proved to be the most efficient and the most robust on various
8.23 + /// turend out to be the most efficient and the most robust on various
8.24 /// test inputs.
8.25 /// However, another pivot rule can be selected using the \ref run()
8.26 /// function with the proper parameter.
8.27 @@ -167,7 +167,7 @@
8.28 typedef std::vector<Value> ValueVector;
8.29 typedef std::vector<Cost> CostVector;
8.30 typedef std::vector<signed char> CharVector;
8.31 - // Note: vector<signed char> is used instead of vector<ArcState> and
8.32 + // Note: vector<signed char> is used instead of vector<ArcState> and
8.33 // vector<ArcDirection> for efficiency reasons
8.34
8.35 // State constants for arcs
8.36 @@ -734,6 +734,8 @@
8.37 /// of the algorithm.
8.38 ///
8.39 /// \return <tt>(*this)</tt>
8.40 + ///
8.41 + /// \sa supplyType()
8.42 template<typename SupplyMap>
8.43 NetworkSimplex& supplyMap(const SupplyMap& map) {
8.44 for (NodeIt n(_graph); n != INVALID; ++n) {
8.45 @@ -750,7 +752,7 @@
8.46 /// calling \ref run(), the supply of each node will be set to zero.
8.47 ///
8.48 /// Using this function has the same effect as using \ref supplyMap()
8.49 - /// with such a map in which \c k is assigned to \c s, \c -k is
8.50 + /// with a map in which \c k is assigned to \c s, \c -k is
8.51 /// assigned to \c t and all other nodes have zero supply value.
8.52 ///
8.53 /// \param s The source node.