1.1 --- a/doc/groups.dox	Fri Aug 09 11:28:17 2013 +0200
     1.2 +++ b/doc/groups.dox	Fri Aug 09 11:29:40 2013 +0200
     1.3 @@ -422,7 +422,8 @@
     1.4  nodes or above), especially if they are sparse.
     1.5  However, other algorithms could be faster in special cases.
     1.6  For example, if the total supply and/or capacities are rather small,
     1.7 -\ref CapacityScaling is usually the fastest algorithm (without effective scaling).
     1.8 +\ref CapacityScaling is usually the fastest algorithm
     1.9 +(without effective scaling).
    1.10  
    1.11  These classes are intended to be used with integer-valued input data
    1.12  (capacities, supply values, and costs), except for \ref CapacityScaling,

     2.1 --- a/lemon/concepts/digraph.h	Fri Aug 09 11:28:17 2013 +0200
     2.2 +++ b/lemon/concepts/digraph.h	Fri Aug 09 11:29:40 2013 +0200
     2.3 @@ -312,7 +312,9 @@
     2.4  
     2.5          /// Sets the iterator to the first arc of the given digraph.
     2.6          ///
     2.7 -        explicit ArcIt(const Digraph& g) { ::lemon::ignore_unused_variable_warning(g); }
     2.8 +        explicit ArcIt(const Digraph& g) {
     2.9 +          ::lemon::ignore_unused_variable_warning(g);
    2.10 +        }
    2.11          /// Sets the iterator to the given arc.
    2.12  
    2.13          /// Sets the iterator to the given arc of the given digraph.

     3.1 --- a/lemon/concepts/graph.h	Fri Aug 09 11:28:17 2013 +0200
     3.2 +++ b/lemon/concepts/graph.h	Fri Aug 09 11:29:40 2013 +0200
     3.3 @@ -396,7 +396,9 @@
     3.4  
     3.5          /// Sets the iterator to the first arc of the given graph.
     3.6          ///
     3.7 -        explicit ArcIt(const Graph &g) { ::lemon::ignore_unused_variable_warning(g); }
     3.8 +        explicit ArcIt(const Graph &g) {
     3.9 +          ::lemon::ignore_unused_variable_warning(g);
    3.10 +        }
    3.11          /// Sets the iterator to the given arc.
    3.12  
    3.13          /// Sets the iterator to the given arc of the given graph.

     4.1 --- a/lemon/cost_scaling.h	Fri Aug 09 11:28:17 2013 +0200
     4.2 +++ b/lemon/cost_scaling.h	Fri Aug 09 11:29:40 2013 +0200
     4.3 @@ -91,7 +91,8 @@
     4.4    ///
     4.5    /// \ref CostScaling implements a cost scaling algorithm that performs
     4.6    /// push/augment and relabel operations for finding a \ref min_cost_flow
     4.7 -  /// "minimum cost flow" \cite amo93networkflows, \cite goldberg90approximation,
     4.8 +  /// "minimum cost flow" \cite amo93networkflows,
     4.9 +  /// \cite goldberg90approximation,
    4.10    /// \cite goldberg97efficient, \cite bunnagel98efficient.
    4.11    /// It is a highly efficient primal-dual solution method, which
    4.12    /// can be viewed as the generalization of the \ref Preflow
    4.13 @@ -213,7 +214,8 @@
    4.14      typedef std::vector<Cost> CostVector;
    4.15      typedef std::vector<LargeCost> LargeCostVector;
    4.16      typedef std::vector<char> BoolVector;
    4.17 -    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
    4.18 +    // Note: vector<char> is used instead of vector<bool>
    4.19 +    // for efficiency reasons
    4.20  
    4.21    private:
    4.22  

     5.1 --- a/lemon/howard_mmc.h	Fri Aug 09 11:28:17 2013 +0200
     5.2 +++ b/lemon/howard_mmc.h	Fri Aug 09 11:29:40 2013 +0200
     5.3 @@ -361,7 +361,8 @@
     5.4      ///
     5.5      /// \return The termination cause of the search process.
     5.6      /// For more information, see \ref TerminationCause.
     5.7 -    TerminationCause findCycleMean(int limit = std::numeric_limits<int>::max()) {
     5.8 +    TerminationCause findCycleMean(int limit =
     5.9 +                                   std::numeric_limits<int>::max()) {
    5.10        // Initialize and find strongly connected components
    5.11        init();
    5.12        findComponents();

     6.1 --- a/lemon/max_cardinality_search.h	Fri Aug 09 11:28:17 2013 +0200
     6.2 +++ b/lemon/max_cardinality_search.h	Fri Aug 09 11:29:40 2013 +0200
     6.3 @@ -164,8 +164,8 @@
     6.4      /// \brief Instantiates a CardinalityMap.
     6.5      ///
     6.6      /// This function instantiates a \ref CardinalityMap.
     6.7 -    /// \param digraph is the digraph, to which we would like to define the \ref
     6.8 -    /// CardinalityMap
     6.9 +    /// \param digraph is the digraph, to which we would like to
    6.10 +    /// define the \ref CardinalityMap
    6.11      static CardinalityMap *createCardinalityMap(const Digraph &digraph) {
    6.12        return new CardinalityMap(digraph);
    6.13      }
    6.14 @@ -180,7 +180,8 @@
    6.15    /// This class provides an efficient implementation of Maximum Cardinality
    6.16    /// Search algorithm. The maximum cardinality search first chooses any
    6.17    /// node of the digraph. Then every time it chooses one unprocessed node
    6.18 -  /// with maximum cardinality, i.e the sum of capacities on out arcs to the nodes
    6.19 +  /// with maximum cardinality, i.e the sum of capacities on out arcs
    6.20 +  /// to the nodes
    6.21    /// which were previusly processed.
    6.22    /// If there is a cut in the digraph the algorithm should choose
    6.23    /// again any unprocessed node of the digraph.

     7.1 --- a/test/tsp_test.cc	Fri Aug 09 11:28:17 2013 +0200
     7.2 +++ b/test/tsp_test.cc	Fri Aug 09 11:29:40 2013 +0200
     7.3 @@ -66,12 +66,13 @@
     7.4    FullGraph::NodeMap<bool> used(gr, false);
     7.5  
     7.6    int node_cnt = 0;
     7.7 -  for (typename Container::const_iterator it = p.begin(); it != p.end(); ++it) {
     7.8 -    FullGraph::Node node = *it;
     7.9 -    if (used[node]) return false;
    7.10 -    used[node] = true;
    7.11 -    ++node_cnt;
    7.12 -  }
    7.13 +  for (typename Container::const_iterator it = p.begin(); it != p.end(); ++it)
    7.14 +    {
    7.15 +      FullGraph::Node node = *it;
    7.16 +      if (used[node]) return false;
    7.17 +      used[node] = true;
    7.18 +      ++node_cnt;
    7.19 +    }
    7.20  
    7.21    return (node_cnt == gr.nodeNum());
    7.22  }
    7.23 @@ -264,8 +265,10 @@
    7.24    tspTestSmall<NearestNeighborTsp<ConstMap<Edge, int> > >("Nearest Neighbor");
    7.25    tspTestSmall<GreedyTsp<ConstMap<Edge, int> > >("Greedy");
    7.26    tspTestSmall<NearestInsertionTsp<ConstMap<Edge, int> > >("Nearest Insertion");
    7.27 -  tspTestSmall<FarthestInsertionTsp<ConstMap<Edge, int> > >("Farthest Insertion");
    7.28 -  tspTestSmall<CheapestInsertionTsp<ConstMap<Edge, int> > >("Cheapest Insertion");
    7.29 +  tspTestSmall<FarthestInsertionTsp<ConstMap<Edge, int> > >
    7.30 +    ("Farthest Insertion");
    7.31 +  tspTestSmall<CheapestInsertionTsp<ConstMap<Edge, int> > >
    7.32 +    ("Cheapest Insertion");
    7.33    tspTestSmall<RandomInsertionTsp<ConstMap<Edge, int> > >("Random Insertion");
    7.34    tspTestSmall<ChristofidesTsp<ConstMap<Edge, int> > >("Christofides");
    7.35    tspTestSmall<Opt2Tsp<ConstMap<Edge, int> > >("2-opt");

     8.1 --- a/tools/dimacs-solver.cc	Fri Aug 09 11:28:17 2013 +0200
     8.2 +++ b/tools/dimacs-solver.cc	Fri Aug 09 11:29:40 2013 +0200
     8.3 @@ -127,7 +127,8 @@
     8.4    typename MCF::ProblemType res = ns.run();
     8.5    if (report) {
     8.6      std::cerr << "Run NetworkSimplex: " << ti << "\n\n";
     8.7 -    std::cerr << "Feasible flow: " << (res == MCF::OPTIMAL ? "found" : "not found") << '\n';
     8.8 +    std::cerr << "Feasible flow: " << (res == MCF::OPTIMAL ? "found" :
     8.9 +                                       "not found") << '\n';
    8.10      if (res) std::cerr << "Min flow cost: "
    8.11                         << ns.template totalCost<LargeValue>() << '\n';
    8.12    }