COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Ticket #459: 459-1-7bf489cf624e.patch

File 459-1-7bf489cf624e.patch, 10.5 KB (added by Peter Kovacs, 12 years ago)

  • doc/groups.dox 

    # HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1363436075 -3600
# Node ID 7bf489cf624efd8023bb1a9ba91302a12415fea0
# Parent  dbaf21739390aee540985c2ce919f3025bff545e
Minor fixes and improvements in the doc (#459)

diff --git a/doc/groups.dox b/doc/groups.dox
    a b  
    392392
    393393This group contains the algorithms for finding minimum cost flows and
    394394circulations \ref amo93networkflows. For more information about this
    395 problem and its dual solution, see \ref min_cost_flow
     395problem and its dual solution, see: \ref min_cost_flow
    396396"Minimum Cost Flow Problem".
    397397
    398398LEMON contains several algorithms for this problem.
    … …  
    484484most efficient one, though the best known theoretical bound on its running
    485485time is exponential.
    486486Both \ref KarpMmc "Karp" and \ref HartmannOrlinMmc "Hartmann-Orlin" algorithms
    487 run in time O(ne) and use space O(n<sup>2</sup>+e), but the latter one is
    488 typically faster due to the applied early termination scheme.
     487run in time O(ne) and use space O(n<sup>2</sup>+e).
    489488*/
    490489
    491490/**

  • lemon/capacity_scaling.h 

    diff --git a/lemon/capacity_scaling.h b/lemon/capacity_scaling.h
    a b  
    6868  /// of the successive shortest path algorithm for finding a
    6969  /// \ref min_cost_flow "minimum cost flow" \ref amo93networkflows,
    7070  /// \ref edmondskarp72theoretical. It is an efficient dual
    71   /// solution method.
     71  /// solution method, which runs in polynomial time
     72  /// \f$O(e\log U (n+e)\log n)\f$, where <i>U</i> denotes the maximum
     73  /// of node supply and arc capacity values.
    7274  ///
    7375  /// This algorithm is typically slower than \ref CostScaling and
    7476  /// \ref NetworkSimplex, but in special cases, it can be more

  • lemon/concepts/bpgraph.h 

    diff --git a/lemon/concepts/bpgraph.h b/lemon/concepts/bpgraph.h
    a b  
    997997
    998998      /// \brief The base node of the iterator.
    999999      ///
    1000       /// Returns the base node of the given incomming arc iterator
     1000      /// Returns the base node of the given incoming arc iterator
    10011001      /// (i.e. the target node of the corresponding arc).
    10021002      Node baseNode(InArcIt) const { return INVALID; }
    10031003
    10041004      /// \brief The running node of the iterator.
    10051005      ///
    1006       /// Returns the running node of the given incomming arc iterator
     1006      /// Returns the running node of the given incoming arc iterator
    10071007      /// (i.e. the source node of the corresponding arc).
    10081008      Node runningNode(InArcIt) const { return INVALID; }
    10091009

  • lemon/concepts/digraph.h 

    diff --git a/lemon/concepts/digraph.h b/lemon/concepts/digraph.h
    a b  
    409409
    410410      /// \brief The base node of the iterator.
    411411      ///
    412       /// Returns the base node of the given incomming arc iterator
     412      /// Returns the base node of the given incoming arc iterator
    413413      /// (i.e. the target node of the corresponding arc).
    414414      Node baseNode(InArcIt) const { return INVALID; }
    415415
    416416      /// \brief The running node of the iterator.
    417417      ///
    418       /// Returns the running node of the given incomming arc iterator
     418      /// Returns the running node of the given incoming arc iterator
    419419      /// (i.e. the source node of the corresponding arc).
    420420      Node runningNode(InArcIt) const { return INVALID; }
    421421

  • lemon/concepts/graph.h 

    diff --git a/lemon/concepts/graph.h b/lemon/concepts/graph.h
    a b  
    757757
    758758      /// \brief The base node of the iterator.
    759759      ///
    760       /// Returns the base node of the given incomming arc iterator
     760      /// Returns the base node of the given incoming arc iterator
    761761      /// (i.e. the target node of the corresponding arc).
    762762      Node baseNode(InArcIt) const { return INVALID; }
    763763
    764764      /// \brief The running node of the iterator.
    765765      ///
    766       /// Returns the running node of the given incomming arc iterator
     766      /// Returns the running node of the given incoming arc iterator
    767767      /// (i.e. the source node of the corresponding arc).
    768768      Node runningNode(InArcIt) const { return INVALID; }
    769769

  • lemon/concepts/graph_components.h 

    diff --git a/lemon/concepts/graph_components.h b/lemon/concepts/graph_components.h
    a b  
    875875      /// This function gives back the next arc in the iteration order.
    876876      void next(Arc&) const {}
    877877
    878       /// \brief Return the first arc incomming to the given node.
     878      /// \brief Return the first arc incoming to the given node.
    879879      ///
    880       /// This function gives back the first arc incomming to the
     880      /// This function gives back the first arc incoming to the
    881881      /// given node.
    882882      void firstIn(Arc&, const Node&) const {}
    883883
    884       /// \brief Return the next arc incomming to the given node.
     884      /// \brief Return the next arc incoming to the given node.
    885885      ///
    886       /// This function gives back the next arc incomming to the
     886      /// This function gives back the next arc incoming to the
    887887      /// given node.
    888888      void nextIn(Arc&) const {}
    889889

  • lemon/cost_scaling.h 

    diff --git a/lemon/cost_scaling.h b/lemon/cost_scaling.h
    a b  
    9696  /// It is a highly efficient primal-dual solution method, which
    9797  /// can be viewed as the generalization of the \ref Preflow
    9898  /// "preflow push-relabel" algorithm for the maximum flow problem.
     99  /// It is a polynomial algorithm, its running time complexity is
     100  /// \f$O(n^2e\log(nK))\f$, where <i>K</i> denotes the maximum arc cost.
    99101  ///
    100102  /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
    101103  /// implementations available in LEMON for solving this problem.
    … …  
    12691271          int u = _buckets[r];
    12701272          _buckets[r] = _bucket_next[u];
    12711273
    1272           // Search the incomming arcs of u
     1274          // Search the incoming arcs of u
    12731275          LargeCost pi_u = _pi[u];
    12741276          int last_out = _first_out[u+1];
    12751277          for (int a = _first_out[u]; a != last_out; ++a) {

  • lemon/cycle_canceling.h 

    diff --git a/lemon/cycle_canceling.h b/lemon/cycle_canceling.h
    a b  
    5151  /// \ref goldberg89cyclecanceling.
    5252  /// The most efficent one is the \ref CANCEL_AND_TIGHTEN
    5353  /// "Cancel-and-Tighten" algorithm, thus it is the default method.
    54   /// It runs in strongly polynomial time, but in practice, it is typically
    55   /// orders of magnitude slower than the scaling algorithms and
    56   /// \ref NetworkSimplex.
     54  /// It runs in strongly polynomial time O(n<sup>2</sup>e<sup>2</sup>log(n)),
     55  /// but in practice, it is typically orders of magnitude slower than
     56  /// the scaling algorithms and \ref NetworkSimplex.
    5757  /// (For more information, see \ref min_cost_flow_algs "the module page".)
    5858  ///
    5959  /// Most of the parameters of the problem (except for the digraph)

  • lemon/hartmann_orlin_mmc.h 

    diff --git a/lemon/hartmann_orlin_mmc.h b/lemon/hartmann_orlin_mmc.h
    a b  
    9999  /// This class implements the Hartmann-Orlin algorithm for finding
    100100  /// a directed cycle of minimum mean cost in a digraph
    101101  /// \ref hartmann93finding, \ref dasdan98minmeancycle.
    102   /// It is an improved version of \ref KarpMmc "Karp"'s original algorithm,
    103   /// it applies an efficient early termination scheme.
    104   /// It runs in time O(ne) and uses space O(n<sup>2</sup>+e).
     102  /// This method is based on \ref KarpMmc "Karp"'s original algorithm, but
     103  /// applies an early termination scheme. It makes the algorithm
     104  /// significantly faster for some problem instances, but slower for others.
     105  /// The algorithm runs in time O(ne) and uses space O(n<sup>2</sup>+e).
    105106  ///
    106107  /// \tparam GR The type of the digraph the algorithm runs on.
    107108  /// \tparam CM The type of the cost map. The default
    … …  
    274275    /// found cycle.
    275276    ///
    276277    /// If you don't call this function before calling \ref run() or
    277     /// \ref findCycleMean(), it will allocate a local \ref Path "path"
    278     /// structure. The destuctor deallocates this automatically
     278    /// \ref findCycleMean(), a local \ref Path "path" structure
     279    /// will be allocated. The destuctor deallocates this automatically
    279280    /// allocated object, of course.
    280281    ///
    281282    /// \note The algorithm calls only the \ref lemon::Path::addFront()

  • lemon/howard_mmc.h 

    diff --git a/lemon/howard_mmc.h b/lemon/howard_mmc.h
    a b  
    282282    /// found cycle.
    283283    ///
    284284    /// If you don't call this function before calling \ref run() or
    285     /// \ref findCycleMean(), it will allocate a local \ref Path "path"
    286     /// structure. The destuctor deallocates this automatically
     285    /// \ref findCycleMean(), a local \ref Path "path" structure
     286    /// will be allocated. The destuctor deallocates this automatically
    287287    /// allocated object, of course.
    288288    ///
    289289    /// \note The algorithm calls only the \ref lemon::Path::addBack()

  • lemon/karp_mmc.h 

    diff --git a/lemon/karp_mmc.h b/lemon/karp_mmc.h
    a b  
    270270    /// found cycle.
    271271    ///
    272272    /// If you don't call this function before calling \ref run() or
    273     /// \ref findCycleMean(), it will allocate a local \ref Path "path"
    274     /// structure. The destuctor deallocates this automatically
     273    /// \ref findCycleMean(), a local \ref Path "path" structure
     274    /// will be allocated. The destuctor deallocates this automatically
    275275    /// allocated object, of course.
    276276    ///
    277277    /// \note The algorithm calls only the \ref lemon::Path::addFront()

  • lemon/list_graph.h 

    diff --git a/lemon/list_graph.h b/lemon/list_graph.h
    a b  
    445445    ///\note The moved arcs are joined to node \c u using changeSource()
    446446    ///or changeTarget(), thus \c ArcIt and \c OutArcIt iterators are
    447447    ///invalidated for the outgoing arcs of node \c v and \c InArcIt
    448     ///iterators are invalidated for the incomming arcs of \c v.
     448    ///iterators are invalidated for the incoming arcs of \c v.
    449449    ///Moreover all iterators referencing node \c v or the removed
    450450    ///loops are also invalidated. Other iterators remain valid.
    451451    ///

  • lemon/network_simplex.h 

    diff --git a/lemon/network_simplex.h b/lemon/network_simplex.h
    a b  
    15031503            }
    15041504          }
    15051505        } else {
    1506           // Find the min. cost incomming arc for each demand node
     1506          // Find the min. cost incoming arc for each demand node
    15071507          for (int i = 0; i != int(demand_nodes.size()); ++i) {
    15081508            Node v = demand_nodes[i];
    15091509            Cost c, min_cost = std::numeric_limits<Cost>::max();