COIN-OR::LEMON - Graph Library

Changeset 1271:fb1c7da561ce in lemon


Ignore:
Timestamp:
08/09/13 11:29:40 (6 years ago)
Author:
Alpar Juttner <alpar@…>
Branch:
default
Children:
1279:00f6088403c0, 1281:c08d0f04c117, 1386:ad22262328b3
Phase:
public
Message:

Remove long lines (from all but one file)

Files:
8 edited

Legend:

Unmodified
Added
Removed
  • doc/groups.dox

    r1270 r1271  
    423423However, other algorithms could be faster in special cases.
    424424For example, if the total supply and/or capacities are rather small,
    425 \ref CapacityScaling is usually the fastest algorithm (without effective scaling).
     425\ref CapacityScaling is usually the fastest algorithm
     426(without effective scaling).
    426427
    427428These classes are intended to be used with integer-valued input data
  • lemon/concepts/digraph.h

    r1270 r1271  
    313313        /// Sets the iterator to the first arc of the given digraph.
    314314        ///
    315         explicit ArcIt(const Digraph& g) { ::lemon::ignore_unused_variable_warning(g); }
     315        explicit ArcIt(const Digraph& g) {
     316          ::lemon::ignore_unused_variable_warning(g);
     317        }
    316318        /// Sets the iterator to the given arc.
    317319
  • lemon/concepts/graph.h

    r1270 r1271  
    397397        /// Sets the iterator to the first arc of the given graph.
    398398        ///
    399         explicit ArcIt(const Graph &g) { ::lemon::ignore_unused_variable_warning(g); }
     399        explicit ArcIt(const Graph &g) {
     400          ::lemon::ignore_unused_variable_warning(g);
     401        }
    400402        /// Sets the iterator to the given arc.
    401403
  • lemon/cost_scaling.h

    r1270 r1271  
    9292  /// \ref CostScaling implements a cost scaling algorithm that performs
    9393  /// push/augment and relabel operations for finding a \ref min_cost_flow
    94   /// "minimum cost flow" \cite amo93networkflows, \cite goldberg90approximation,
     94  /// "minimum cost flow" \cite amo93networkflows,
     95  /// \cite goldberg90approximation,
    9596  /// \cite goldberg97efficient, \cite bunnagel98efficient.
    9697  /// It is a highly efficient primal-dual solution method, which
     
    214215    typedef std::vector<LargeCost> LargeCostVector;
    215216    typedef std::vector<char> BoolVector;
    216     // Note: vector<char> is used instead of vector<bool> for efficiency reasons
     217    // Note: vector<char> is used instead of vector<bool>
     218    // for efficiency reasons
    217219
    218220  private:
  • lemon/howard_mmc.h

    r1270 r1271  
    362362    /// \return The termination cause of the search process.
    363363    /// For more information, see \ref TerminationCause.
    364     TerminationCause findCycleMean(int limit = std::numeric_limits<int>::max()) {
     364    TerminationCause findCycleMean(int limit =
     365                                   std::numeric_limits<int>::max()) {
    365366      // Initialize and find strongly connected components
    366367      init();
  • lemon/max_cardinality_search.h

    r1270 r1271  
    165165    ///
    166166    /// This function instantiates a \ref CardinalityMap.
    167     /// \param digraph is the digraph, to which we would like to define the \ref
    168     /// CardinalityMap
     167    /// \param digraph is the digraph, to which we would like to
     168    /// define the \ref CardinalityMap
    169169    static CardinalityMap *createCardinalityMap(const Digraph &digraph) {
    170170      return new CardinalityMap(digraph);
     
    181181  /// Search algorithm. The maximum cardinality search first chooses any
    182182  /// node of the digraph. Then every time it chooses one unprocessed node
    183   /// with maximum cardinality, i.e the sum of capacities on out arcs to the nodes
     183  /// with maximum cardinality, i.e the sum of capacities on out arcs
     184  /// to the nodes
    184185  /// which were previusly processed.
    185186  /// If there is a cut in the digraph the algorithm should choose
  • test/tsp_test.cc

    r1270 r1271  
    6767
    6868  int node_cnt = 0;
    69   for (typename Container::const_iterator it = p.begin(); it != p.end(); ++it) {
    70     FullGraph::Node node = *it;
    71     if (used[node]) return false;
    72     used[node] = true;
    73     ++node_cnt;
    74   }
     69  for (typename Container::const_iterator it = p.begin(); it != p.end(); ++it)
     70    {
     71      FullGraph::Node node = *it;
     72      if (used[node]) return false;
     73      used[node] = true;
     74      ++node_cnt;
     75    }
    7576
    7677  return (node_cnt == gr.nodeNum());
     
    265266  tspTestSmall<GreedyTsp<ConstMap<Edge, int> > >("Greedy");
    266267  tspTestSmall<NearestInsertionTsp<ConstMap<Edge, int> > >("Nearest Insertion");
    267   tspTestSmall<FarthestInsertionTsp<ConstMap<Edge, int> > >("Farthest Insertion");
    268   tspTestSmall<CheapestInsertionTsp<ConstMap<Edge, int> > >("Cheapest Insertion");
     268  tspTestSmall<FarthestInsertionTsp<ConstMap<Edge, int> > >
     269    ("Farthest Insertion");
     270  tspTestSmall<CheapestInsertionTsp<ConstMap<Edge, int> > >
     271    ("Cheapest Insertion");
    269272  tspTestSmall<RandomInsertionTsp<ConstMap<Edge, int> > >("Random Insertion");
    270273  tspTestSmall<ChristofidesTsp<ConstMap<Edge, int> > >("Christofides");
  • tools/dimacs-solver.cc

    r1270 r1271  
    128128  if (report) {
    129129    std::cerr << "Run NetworkSimplex: " << ti << "\n\n";
    130     std::cerr << "Feasible flow: " << (res == MCF::OPTIMAL ? "found" : "not found") << '\n';
     130    std::cerr << "Feasible flow: " << (res == MCF::OPTIMAL ? "found" :
     131                                       "not found") << '\n';
    131132    if (res) std::cerr << "Min flow cost: "
    132133                       << ns.template totalCost<LargeValue>() << '\n';
Note: See TracChangeset for help on using the changeset viewer.