# HG changeset patch
# User Alpar Juttner <alpar@cs.elte.hu>
# Date 1376040580 -7200
# Node ID fb1c7da561ceb5fff691bba109ad95b079780845
# Parent  dceba191c00dbe9bb4867fab619aac7a9c232ae9
Remove long lines (from all but one file)

diff -r dceba191c00d -r fb1c7da561ce doc/groups.dox
--- a/doc/groups.dox	Fri Aug 09 11:28:17 2013 +0200
+++ b/doc/groups.dox	Fri Aug 09 11:29:40 2013 +0200
@@ -422,7 +422,8 @@
 nodes or above), especially if they are sparse.
 However, other algorithms could be faster in special cases.
 For example, if the total supply and/or capacities are rather small,
-\ref CapacityScaling is usually the fastest algorithm (without effective scaling).
+\ref CapacityScaling is usually the fastest algorithm
+(without effective scaling).
 
 These classes are intended to be used with integer-valued input data
 (capacities, supply values, and costs), except for \ref CapacityScaling,
diff -r dceba191c00d -r fb1c7da561ce lemon/concepts/digraph.h
--- a/lemon/concepts/digraph.h	Fri Aug 09 11:28:17 2013 +0200
+++ b/lemon/concepts/digraph.h	Fri Aug 09 11:29:40 2013 +0200
@@ -312,7 +312,9 @@
 
         /// Sets the iterator to the first arc of the given digraph.
         ///
-        explicit ArcIt(const Digraph& g) { ::lemon::ignore_unused_variable_warning(g); }
+        explicit ArcIt(const Digraph& g) {
+          ::lemon::ignore_unused_variable_warning(g);
+        }
         /// Sets the iterator to the given arc.
 
         /// Sets the iterator to the given arc of the given digraph.
diff -r dceba191c00d -r fb1c7da561ce lemon/concepts/graph.h
--- a/lemon/concepts/graph.h	Fri Aug 09 11:28:17 2013 +0200
+++ b/lemon/concepts/graph.h	Fri Aug 09 11:29:40 2013 +0200
@@ -396,7 +396,9 @@
 
         /// Sets the iterator to the first arc of the given graph.
         ///
-        explicit ArcIt(const Graph &g) { ::lemon::ignore_unused_variable_warning(g); }
+        explicit ArcIt(const Graph &g) {
+          ::lemon::ignore_unused_variable_warning(g);
+        }
         /// Sets the iterator to the given arc.
 
         /// Sets the iterator to the given arc of the given graph.
diff -r dceba191c00d -r fb1c7da561ce lemon/cost_scaling.h
--- a/lemon/cost_scaling.h	Fri Aug 09 11:28:17 2013 +0200
+++ b/lemon/cost_scaling.h	Fri Aug 09 11:29:40 2013 +0200
@@ -91,7 +91,8 @@
   ///
   /// \ref CostScaling implements a cost scaling algorithm that performs
   /// push/augment and relabel operations for finding a \ref min_cost_flow
-  /// "minimum cost flow" \cite amo93networkflows, \cite goldberg90approximation,
+  /// "minimum cost flow" \cite amo93networkflows,
+  /// \cite goldberg90approximation,
   /// \cite goldberg97efficient, \cite bunnagel98efficient.
   /// It is a highly efficient primal-dual solution method, which
   /// can be viewed as the generalization of the \ref Preflow
@@ -213,7 +214,8 @@
     typedef std::vector<Cost> CostVector;
     typedef std::vector<LargeCost> LargeCostVector;
     typedef std::vector<char> BoolVector;
-    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
+    // Note: vector<char> is used instead of vector<bool>
+    // for efficiency reasons
 
   private:
 
diff -r dceba191c00d -r fb1c7da561ce lemon/howard_mmc.h
--- a/lemon/howard_mmc.h	Fri Aug 09 11:28:17 2013 +0200
+++ b/lemon/howard_mmc.h	Fri Aug 09 11:29:40 2013 +0200
@@ -361,7 +361,8 @@
     ///
     /// \return The termination cause of the search process.
     /// For more information, see \ref TerminationCause.
-    TerminationCause findCycleMean(int limit = std::numeric_limits<int>::max()) {
+    TerminationCause findCycleMean(int limit =
+                                   std::numeric_limits<int>::max()) {
       // Initialize and find strongly connected components
       init();
       findComponents();
diff -r dceba191c00d -r fb1c7da561ce lemon/max_cardinality_search.h
--- a/lemon/max_cardinality_search.h	Fri Aug 09 11:28:17 2013 +0200
+++ b/lemon/max_cardinality_search.h	Fri Aug 09 11:29:40 2013 +0200
@@ -164,8 +164,8 @@
     /// \brief Instantiates a CardinalityMap.
     ///
     /// This function instantiates a \ref CardinalityMap.
-    /// \param digraph is the digraph, to which we would like to define the \ref
-    /// CardinalityMap
+    /// \param digraph is the digraph, to which we would like to
+    /// define the \ref CardinalityMap
     static CardinalityMap *createCardinalityMap(const Digraph &digraph) {
       return new CardinalityMap(digraph);
     }
@@ -180,7 +180,8 @@
   /// This class provides an efficient implementation of Maximum Cardinality
   /// Search algorithm. The maximum cardinality search first chooses any
   /// node of the digraph. Then every time it chooses one unprocessed node
-  /// with maximum cardinality, i.e the sum of capacities on out arcs to the nodes
+  /// with maximum cardinality, i.e the sum of capacities on out arcs
+  /// to the nodes
   /// which were previusly processed.
   /// If there is a cut in the digraph the algorithm should choose
   /// again any unprocessed node of the digraph.
diff -r dceba191c00d -r fb1c7da561ce test/tsp_test.cc
--- a/test/tsp_test.cc	Fri Aug 09 11:28:17 2013 +0200
+++ b/test/tsp_test.cc	Fri Aug 09 11:29:40 2013 +0200
@@ -66,12 +66,13 @@
   FullGraph::NodeMap<bool> used(gr, false);
 
   int node_cnt = 0;
-  for (typename Container::const_iterator it = p.begin(); it != p.end(); ++it) {
-    FullGraph::Node node = *it;
-    if (used[node]) return false;
-    used[node] = true;
-    ++node_cnt;
-  }
+  for (typename Container::const_iterator it = p.begin(); it != p.end(); ++it)
+    {
+      FullGraph::Node node = *it;
+      if (used[node]) return false;
+      used[node] = true;
+      ++node_cnt;
+    }
 
   return (node_cnt == gr.nodeNum());
 }
@@ -264,8 +265,10 @@
   tspTestSmall<NearestNeighborTsp<ConstMap<Edge, int> > >("Nearest Neighbor");
   tspTestSmall<GreedyTsp<ConstMap<Edge, int> > >("Greedy");
   tspTestSmall<NearestInsertionTsp<ConstMap<Edge, int> > >("Nearest Insertion");
-  tspTestSmall<FarthestInsertionTsp<ConstMap<Edge, int> > >("Farthest Insertion");
-  tspTestSmall<CheapestInsertionTsp<ConstMap<Edge, int> > >("Cheapest Insertion");
+  tspTestSmall<FarthestInsertionTsp<ConstMap<Edge, int> > >
+    ("Farthest Insertion");
+  tspTestSmall<CheapestInsertionTsp<ConstMap<Edge, int> > >
+    ("Cheapest Insertion");
   tspTestSmall<RandomInsertionTsp<ConstMap<Edge, int> > >("Random Insertion");
   tspTestSmall<ChristofidesTsp<ConstMap<Edge, int> > >("Christofides");
   tspTestSmall<Opt2Tsp<ConstMap<Edge, int> > >("2-opt");
diff -r dceba191c00d -r fb1c7da561ce tools/dimacs-solver.cc
--- a/tools/dimacs-solver.cc	Fri Aug 09 11:28:17 2013 +0200
+++ b/tools/dimacs-solver.cc	Fri Aug 09 11:29:40 2013 +0200
@@ -127,7 +127,8 @@
   typename MCF::ProblemType res = ns.run();
   if (report) {
     std::cerr << "Run NetworkSimplex: " << ti << "\n\n";
-    std::cerr << "Feasible flow: " << (res == MCF::OPTIMAL ? "found" : "not found") << '\n';
+    std::cerr << "Feasible flow: " << (res == MCF::OPTIMAL ? "found" :
+                                       "not found") << '\n';
     if (res) std::cerr << "Min flow cost: "
                        << ns.template totalCost<LargeValue>() << '\n';
   }