Changeset 1093:fb1c7da561ce in lemon-main

Timestamp:

08/09/13 11:29:40 (11 years ago)

Author:

Alpar Juttner <alpar@…>

Branch:

default

Children:

1094:c08d0f04c117, 1170:ad22262328b3

Phase:

public

Message:

Remove long lines (from all but one file)

Files:

• doc/groups.dox (modified) (1 diff)
• lemon/concepts/digraph.h (modified) (1 diff)
• lemon/concepts/graph.h (modified) (1 diff)
• lemon/cost_scaling.h (modified) (2 diffs)
• lemon/howard_mmc.h (modified) (1 diff)
• lemon/max_cardinality_search.h (modified) (2 diffs)
• test/tsp_test.cc (modified) (2 diffs)
• tools/dimacs-solver.cc (modified) (1 diff)

doc/groups.dox

@@ -423 +423 @@
 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

lemon/concepts/digraph.h

@@ -313 +313 @@
         /// 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.
 

lemon/concepts/graph.h

@@ -397 +397 @@
         /// 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.
 

lemon/cost_scaling.h

@@ -92 +92 @@
   /// \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
@@ -214 +215 @@
     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:

lemon/howard_mmc.h

@@ -362 +362 @@
     /// \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();

lemon/max_cardinality_search.h

@@ -165 +165 @@
     ///
     /// 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);
@@ -181 +181 @@
   /// 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

test/tsp_test.cc

@@ -67 +67 @@
 
   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());
@@ -265 +266 @@
   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");

tools/dimacs-solver.cc

@@ -128 +128 @@
   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';