COIN-OR::LEMON - Graph Library

Changeset 1023:e0cef67fe565 in lemon


Ignore:
Timestamp:
01/09/11 16:51:14 (9 years ago)
Author:
Peter Kovacs <kpeter@…>
Branch:
default
Phase:
public
Message:

Various doc improvements (#406)

Files:
8 edited

Legend:

Unmodified
Added
Removed
  • doc/coding_style.dox

    r463 r1023  
    9999\subsection pri-loc-var Private member variables
    100100
    101 Private member variables should start with underscore
     101Private member variables should start with underscore.
    102102
    103103\code
    104 _start_with_underscores
     104_start_with_underscore
    105105\endcode
    106106
  • doc/groups.dox

    r999 r1023  
    407407   strongly polynomial \ref klein67primal, \ref goldberg89cyclecanceling.
    408408
    409 In general NetworkSimplex is the most efficient implementation,
    410 but in special cases other algorithms could be faster.
     409In general, \ref NetworkSimplex and \ref CostScaling are the most efficient
     410implementations, but the other two algorithms could be faster in special cases.
    411411For example, if the total supply and/or capacities are rather small,
    412 CapacityScaling is usually the fastest algorithm (without effective scaling).
     412\ref CapacityScaling is usually the fastest algorithm (without effective scaling).
    413413*/
    414414
     
    472472  \ref dasdan98minmeancycle.
    473473
    474 In practice, the \ref HowardMmc "Howard" algorithm proved to be by far the
     474In practice, the \ref HowardMmc "Howard" algorithm turned out to be by far the
    475475most efficient one, though the best known theoretical bound on its running
    476476time is exponential.
     
    540540
    541541/**
    542 @defgroup planar Planarity Embedding and Drawing
     542@defgroup planar Planar Embedding and Drawing
    543543@ingroup algs
    544544\brief Algorithms for planarity checking, embedding and drawing
  • lemon/capacity_scaling.h

    r956 r1023  
    8989  /// \warning Both number types must be signed and all input data must
    9090  /// be integer.
    91   /// \warning This algorithm does not support negative costs for such
    92   /// arcs that have infinite upper bound.
     91  /// \warning This algorithm does not support negative costs for
     92  /// arcs having infinite upper bound.
    9393#ifdef DOXYGEN
    9494  template <typename GR, typename V, typename C, typename TR>
     
    423423    ///
    424424    /// Using this function has the same effect as using \ref supplyMap()
    425     /// with such a map in which \c k is assigned to \c s, \c -k is
     425    /// with a map in which \c k is assigned to \c s, \c -k is
    426426    /// assigned to \c t and all other nodes have zero supply value.
    427427    ///
  • lemon/core.h

    r988 r1023  
    448448  }
    449449
    450   /// Check whether a graph is undirected.
     450  /// \brief Check whether a graph is undirected.
    451451  ///
    452452  /// This function returns \c true if the given graph is undirected.
  • lemon/cost_scaling.h

    r956 r1023  
    9898  /// "preflow push-relabel" algorithm for the maximum flow problem.
    9999  ///
     100  /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
     101  /// implementations available in LEMON for this problem.
     102  ///
    100103  /// Most of the parameters of the problem (except for the digraph)
    101104  /// can be given using separate functions, and the algorithm can be
     
    116119  /// \warning Both number types must be signed and all input data must
    117120  /// be integer.
    118   /// \warning This algorithm does not support negative costs for such
    119   /// arcs that have infinite upper bound.
     121  /// \warning This algorithm does not support negative costs for
     122  /// arcs having infinite upper bound.
    120123  ///
    121124  /// \note %CostScaling provides three different internal methods,
     
    179182    /// relabel operation.
    180183    /// By default, the so called \ref PARTIAL_AUGMENT
    181     /// "Partial Augment-Relabel" method is used, which proved to be
     184    /// "Partial Augment-Relabel" method is used, which turned out to be
    182185    /// the most efficient and the most robust on various test inputs.
    183186    /// However, the other methods can be selected using the \ref run()
     
    448451    ///
    449452    /// Using this function has the same effect as using \ref supplyMap()
    450     /// with such a map in which \c k is assigned to \c s, \c -k is
     453    /// with a map in which \c k is assigned to \c s, \c -k is
    451454    /// assigned to \c t and all other nodes have zero supply value.
    452455    ///
  • lemon/cycle_canceling.h

    r956 r1023  
    6868  /// \warning Both number types must be signed and all input data must
    6969  /// be integer.
    70   /// \warning This algorithm does not support negative costs for such
    71   /// arcs that have infinite upper bound.
     70  /// \warning This algorithm does not support negative costs for
     71  /// arcs having infinite upper bound.
    7272  ///
    7373  /// \note For more information about the three available methods,
     
    117117    /// \ref CycleCanceling provides three different cycle-canceling
    118118    /// methods. By default, \ref CANCEL_AND_TIGHTEN "Cancel and Tighten"
    119     /// is used, which proved to be the most efficient and the most robust
    120     /// on various test inputs.
     119    /// is used, which is by far the most efficient and the most robust.
    121120    /// However, the other methods can be selected using the \ref run()
    122121    /// function with the proper parameter.
     
    350349    ///
    351350    /// Using this function has the same effect as using \ref supplyMap()
    352     /// with such a map in which \c k is assigned to \c s, \c -k is
     351    /// with a map in which \c k is assigned to \c s, \c -k is
    353352    /// assigned to \c t and all other nodes have zero supply value.
    354353    ///
  • lemon/euler.h

    r956 r1023  
    3737  ///Euler tour iterator for digraphs.
    3838
    39   /// \ingroup graph_prop
     39  /// \ingroup graph_properties
    4040  ///This iterator provides an Euler tour (Eulerian circuit) of a \e directed
    4141  ///graph (if there exists) and it converts to the \c Arc type of the digraph.
  • lemon/network_simplex.h

    r991 r1023  
    4848  /// flow problem.
    4949  ///
    50   /// In general, %NetworkSimplex is the fastest implementation available
    51   /// in LEMON for this problem.
    52   /// Moreover, it supports both directions of the supply/demand inequality
    53   /// constraints. For more information, see \ref SupplyType.
     50  /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
     51  /// implementations available in LEMON for this problem.
     52  /// Furthermore, this class supports both directions of the supply/demand
     53  /// inequality constraints. For more information, see \ref SupplyType.
    5454  ///
    5555  /// Most of the parameters of the problem (except for the digraph)
     
    126126    /// of the algorithm.
    127127    /// By default, \ref BLOCK_SEARCH "Block Search" is used, which
    128     /// proved to be the most efficient and the most robust on various
     128    /// turend out to be the most efficient and the most robust on various
    129129    /// test inputs.
    130130    /// However, another pivot rule can be selected using the \ref run()
     
    168168    typedef std::vector<Cost> CostVector;
    169169    typedef std::vector<signed char> CharVector;
    170     // Note: vector<signed char> is used instead of vector<ArcState> and 
     170    // Note: vector<signed char> is used instead of vector<ArcState> and
    171171    // vector<ArcDirection> for efficiency reasons
    172172
     
    735735    ///
    736736    /// \return <tt>(*this)</tt>
     737    ///
     738    /// \sa supplyType()
    737739    template<typename SupplyMap>
    738740    NetworkSimplex& supplyMap(const SupplyMap& map) {
     
    751753    ///
    752754    /// Using this function has the same effect as using \ref supplyMap()
    753     /// with such a map in which \c k is assigned to \c s, \c -k is
     755    /// with a map in which \c k is assigned to \c s, \c -k is
    754756    /// assigned to \c t and all other nodes have zero supply value.
    755757    ///
Note: See TracChangeset for help on using the changeset viewer.