# HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1258066145 -3600
# Node ID 4b1b378823dc0f3c08c7be050d66dee89d73d5fa
# Parent  fe80a8145653d19e2039c8894311d0f9bd9e704a
Small doc improvements + unifications in MCF classes (#180)

diff -r fe80a8145653 -r 4b1b378823dc lemon/capacity_scaling.h
--- a/lemon/capacity_scaling.h	Thu Nov 12 23:45:15 2009 +0100
+++ b/lemon/capacity_scaling.h	Thu Nov 12 23:49:05 2009 +0100
@@ -35,9 +35,9 @@
   ///
   /// Default traits class of CapacityScaling algorithm.
   /// \tparam GR Digraph type.
-  /// \tparam V The value type used for flow amounts, capacity bounds
+  /// \tparam V The number type used for flow amounts, capacity bounds
   /// and supply values. By default it is \c int.
-  /// \tparam C The value type used for costs and potentials.
+  /// \tparam C The number type used for costs and potentials.
   /// By default it is the same as \c V.
   template <typename GR, typename V = int, typename C = V>
   struct CapacityScalingDefaultTraits
@@ -75,12 +75,12 @@
   /// specified, then default values will be used.
   ///
   /// \tparam GR The digraph type the algorithm runs on.
-  /// \tparam V The value type used for flow amounts, capacity bounds
+  /// \tparam V The number type used for flow amounts, capacity bounds
   /// and supply values in the algorithm. By default it is \c int.
-  /// \tparam C The value type used for costs and potentials in the
+  /// \tparam C The number type used for costs and potentials in the
   /// algorithm. By default it is the same as \c V.
   ///
-  /// \warning Both value types must be signed and all input data must
+  /// \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.
@@ -122,7 +122,7 @@
       OPTIMAL,
       /// The digraph contains an arc of negative cost and infinite
       /// upper bound. It means that the objective function is unbounded
-      /// on that arc, however note that it could actually be bounded
+      /// on that arc, however, note that it could actually be bounded
       /// over the feasible flows, but this algroithm cannot handle
       /// these cases.
       UNBOUNDED
@@ -307,7 +307,7 @@
           std::numeric_limits<Value>::infinity() :
           std::numeric_limits<Value>::max())
     {
-      // Check the value types
+      // Check the number types
       LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
         "The flow type of CapacityScaling must be signed");
       LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
@@ -411,7 +411,7 @@
     /// This function sets the upper bounds (capacities) on the arcs.
     /// If it is not used before calling \ref run(), the upper bounds
     /// will be set to \ref INF on all arcs (i.e. the flow value will be
-    /// unbounded from above on each arc).
+    /// unbounded from above).
     ///
     /// \param map An arc map storing the upper bounds.
     /// Its \c Value type must be convertible to the \c Value type
@@ -514,7 +514,7 @@
     /// that have been given are kept for the next call, unless
     /// \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 factor The capacity scaling factor. It must be larger than
@@ -527,7 +527,7 @@
     /// optimal flow and node potentials (primal and dual solutions),
     /// \n \c UNBOUNDED if the digraph contains an arc of negative cost
     /// and infinite upper bound. It means that the objective function
-    /// is unbounded on that arc, however note that it could actually be
+    /// is unbounded on that arc, however, note that it could actually be
     /// bounded over the feasible flows, but this algroithm cannot handle
     /// these cases.
     ///
diff -r fe80a8145653 -r 4b1b378823dc lemon/cost_scaling.h
--- a/lemon/cost_scaling.h	Thu Nov 12 23:45:15 2009 +0100
+++ b/lemon/cost_scaling.h	Thu Nov 12 23:49:05 2009 +0100
@@ -40,9 +40,9 @@
   ///
   /// Default traits class of CostScaling algorithm.
   /// \tparam GR Digraph type.
-  /// \tparam V The value type used for flow amounts, capacity bounds
+  /// \tparam V The number type used for flow amounts, capacity bounds
   /// and supply values. By default it is \c int.
-  /// \tparam C The value type used for costs and potentials.
+  /// \tparam C The number type used for costs and potentials.
   /// By default it is the same as \c V.
 #ifdef DOXYGEN
   template <typename GR, typename V = int, typename C = V>
@@ -101,12 +101,12 @@
   /// specified, then default values will be used.
   ///
   /// \tparam GR The digraph type the algorithm runs on.
-  /// \tparam V The value type used for flow amounts, capacity bounds
+  /// \tparam V The number type used for flow amounts, capacity bounds
   /// and supply values in the algorithm. By default it is \c int.
-  /// \tparam C The value type used for costs and potentials in the
+  /// \tparam C The number type used for costs and potentials in the
   /// algorithm. By default it is the same as \c V.
   ///
-  /// \warning Both value types must be signed and all input data must
+  /// \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.
@@ -157,7 +157,7 @@
       OPTIMAL,
       /// The digraph contains an arc of negative cost and infinite
       /// upper bound. It means that the objective function is unbounded
-      /// on that arc, however note that it could actually be bounded
+      /// on that arc, however, note that it could actually be bounded
       /// over the feasible flows, but this algroithm cannot handle
       /// these cases.
       UNBOUNDED
@@ -325,7 +325,7 @@
           std::numeric_limits<Value>::infinity() :
           std::numeric_limits<Value>::max())
     {
-      // Check the value types
+      // Check the number types
       LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
         "The flow type of CostScaling must be signed");
       LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
@@ -433,7 +433,7 @@
     /// This function sets the upper bounds (capacities) on the arcs.
     /// If it is not used before calling \ref run(), the upper bounds
     /// will be set to \ref INF on all arcs (i.e. the flow value will be
-    /// unbounded from above on each arc).
+    /// unbounded from above).
     ///
     /// \param map An arc map storing the upper bounds.
     /// Its \c Value type must be convertible to the \c Value type
@@ -549,7 +549,7 @@
     /// optimal flow and node potentials (primal and dual solutions),
     /// \n \c UNBOUNDED if the digraph contains an arc of negative cost
     /// and infinite upper bound. It means that the objective function
-    /// is unbounded on that arc, however note that it could actually be
+    /// is unbounded on that arc, however, note that it could actually be
     /// bounded over the feasible flows, but this algroithm cannot handle
     /// these cases.
     ///
@@ -571,7 +571,7 @@
     /// It is useful for multiple run() calls. If this function is not
     /// 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.
     ///
     /// For example,
diff -r fe80a8145653 -r 4b1b378823dc lemon/network_simplex.h
--- a/lemon/network_simplex.h	Thu Nov 12 23:45:15 2009 +0100
+++ b/lemon/network_simplex.h	Thu Nov 12 23:49:05 2009 +0100
@@ -43,13 +43,13 @@
   /// for finding a \ref min_cost_flow "minimum cost flow"
   /// \ref amo93networkflows, \ref dantzig63linearprog,
   /// \ref kellyoneill91netsimplex.
-  /// This algorithm is a specialized version of the linear programming
-  /// simplex method directly for the minimum cost flow problem.
-  /// It is one of the most efficient solution methods.
+  /// This algorithm is a highly efficient specialized version of the
+  /// linear programming simplex method directly for the minimum cost
+  /// flow problem.
   ///
-  /// In general this class is the fastest implementation available
-  /// in LEMON for the minimum cost flow problem.
-  /// Moreover it supports both directions of the supply/demand inequality
+  /// 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.
   ///
   /// Most of the parameters of the problem (except for the digraph)
@@ -58,12 +58,12 @@
   /// specified, then default values will be used.
   ///
   /// \tparam GR The digraph type the algorithm runs on.
-  /// \tparam V The value type used for flow amounts, capacity bounds
+  /// \tparam V The number type used for flow amounts, capacity bounds
   /// and supply values in the algorithm. By default, it is \c int.
-  /// \tparam C The value type used for costs and potentials in the
+  /// \tparam C The number type used for costs and potentials in the
   /// algorithm. By default, it is the same as \c V.
   ///
-  /// \warning Both value types must be signed and all input data must
+  /// \warning Both number types must be signed and all input data must
   /// be integer.
   ///
   /// \note %NetworkSimplex provides five different pivot rule
@@ -126,7 +126,7 @@
     /// 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
-    /// test inputs according to our benchmark tests.
+    /// test inputs.
     /// However, another pivot rule can be selected using the \ref run()
     /// function with the proper parameter.
     enum PivotRule {
@@ -637,7 +637,7 @@
       INF(std::numeric_limits<Value>::has_infinity ?
           std::numeric_limits<Value>::infinity() : MAX)
     {
-      // Check the value types
+      // Check the number types
       LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
         "The flow type of NetworkSimplex must be signed");
       LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
@@ -729,7 +729,7 @@
     /// This function sets the upper bounds (capacities) on the arcs.
     /// If it is not used before calling \ref run(), the upper bounds
     /// will be set to \ref INF on all arcs (i.e. the flow value will be
-    /// unbounded from above on each arc).
+    /// unbounded from above).
     ///
     /// \param map An arc map storing the upper bounds.
     /// Its \c Value type must be convertible to the \c Value type