COIN-OR::LEMON - Graph Library

Changeset 1527:7ceab500e1f6 in lemon-0.x for lemon


Ignore:
Timestamp:
07/01/05 12:33:27 (17 years ago)
Author:
athos
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2014
Message:

Doc review+corrections in my own documentation according to the reviewers comments.

Location:
lemon
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • lemon/concept/sym_graph.h

    r1526 r1527  
    4343    /// or it can serve as a skeleton of a new symmetric graph structure.
    4444    ///
    45     /// Also, you will find here the full documentation of a certain graph
    46     /// feature, the documentation of a real symmetric graph imlementation
     45    /// Also, you will find here the full documentation of graph
     46    /// features, the documentation of a real symmetric graph imlementation
    4747    /// like @ref SymListGraph or
    4848    /// @ref lemon::SymSmartGraph will just refer to this structure.
     
    5555      ///
    5656      StaticSymGraph() { }
    57       ///Copy consructor.
     57      //      ///Copy consructor.
    5858
    5959//       ///\todo It is not clear, what we expect from a copy constructor.
     
    9494        /// Inequality operator
    9595       
    96         /// \sa operator==(Node n)
     96        /// \sa operator==(Node)
    9797        ///
    9898        bool operator!=(Node) const { return true; }
     
    142142
    143143        /// Sets the iterator to the node of \c g pointed by the trivial
    144         /// iterator n.
     144        /// iterator \c n.
    145145        /// This feature necessitates that each time we
    146         /// iterate the edge-set, the iteration order is the same.
     146        /// iterate the node-set, the iteration order is the same.
    147147        NodeIt(const StaticSymGraph& g, const Node& n) { }
    148148        /// Next node.
     
    268268        /// This constructor sets the iterator to first outgoing edge.
    269269   
    270         /// This constructor set the iterator to the first outgoing edge of
    271         /// node
     270        /// This constructor sets the iterator to the first outgoing edge of
     271        /// the node
    272272        ///@param n the node
    273273        ///@param g the graph
     
    317317        /// This constructor sets the iterator to first incoming edge.
    318318   
    319         /// This constructor set the iterator to the first incoming edge of
    320         /// node
     319        /// This constructor sets the iterator to the first incoming edge of
     320        /// the node
    321321        ///@param n the node
    322322        ///@param g the graph
     
    362362        /// This constructor sets the iterator to first edge.
    363363   
    364         /// This constructor set the iterator to the first edge of
    365         /// node
     364        /// This constructor sets the iterator to the first edge of
     365        /// the graph
    366366        ///@param g the graph
    367367        SymEdgeIt(const StaticSymGraph& g) { }
     
    406406        /// This constructor sets the iterator to first edge.
    407407   
    408         /// This constructor set the iterator to the first edge of
    409         /// node
     408        /// This constructor sets the iterator to the first edge of
     409        /// the graph
    410410        ///@param g the graph
    411411        EdgeIt(const StaticSymGraph& g) { }
     
    590590    /// An empty non-static graph class.
    591591
    592     /// This class provides everything that \ref StaticGraph
    593     /// with additional functionality which enables to build a
     592    /// This class is an extension of \ref StaticGraph
     593    /// with additional functionality that enables one to build a
    594594    /// graph from scratch.
    595     class ExtendableSymGraph : public StaticSymGraph
     595     class ExtendableSymGraph : public StaticSymGraph
    596596    {
    597597    public:
     
    623623    /// An empty erasable graph class.
    624624 
    625     /// This class is an extension of \ref ExtendableGraph. It also makes it
    626     /// possible to erase edges or nodes.
     625    /// This class is an extension of \ref ExtendableGraph. It is also
     626    /// possible to erase edges or nodes in this graph.
    627627    class ErasableSymGraph : public ExtendableSymGraph
    628628    {
  • lemon/min_cost_flow.h

    r1435 r1527  
    3939  /// The class \ref lemon::MinCostFlow "MinCostFlow" implements an
    4040  /// algorithm for finding a flow of value \c k having minimal total
    41   /// cost from a given source node to a given target node in an
    42   /// edge-weighted directed graph. To this end, the edge-capacities
    43   /// and edge-weights have to be nonnegative.  The edge-capacities
    44   /// should be integers, but the edge-weights can be integers, reals
    45   /// or of other comparable numeric type.  This algorithm is intended
    46   /// to be used only for small values of \c k, since it is only
    47   /// polynomial in k, not in the length of k (which is log k): in
    48   /// order to find the minimum cost flow of value \c k it finds the
    49   /// minimum cost flow of value \c i for every \c i between 0 and \c
    50   /// k.
     41  /// cost from a given source node to a given target node in a
     42  /// directed graph with a cost function on the edges. To
     43  /// this end, the edge-capacities and edge-costs have to be
     44  /// nonnegative.  The edge-capacities should be integers, but the
     45  /// edge-costs can be integers, reals or of other comparable
     46  /// numeric type.  This algorithm is intended to be used only for
     47  /// small values of \c k, since it is only polynomial in k, not in
     48  /// the length of k (which is log k): in order to find the minimum
     49  /// cost flow of value \c k it finds the minimum cost flow of value
     50  /// \c i for every \c i between 0 and \c k.
    5151  ///
    5252  ///\param Graph The directed graph type the algorithm runs on.
     
    118118   
    119119    \param _g The directed graph the algorithm runs on.
    120     \param _length The length (weight or cost) of the edges.
     120    \param _length The length (cost) of the edges.
    121121    \param _cap The capacity of the edges.
    122122    \param _s Source node.
     
    204204    }
    205205
    206     /// Total weight of the found flow.
    207 
    208     /// This function gives back the total weight of the found flow.
     206    /// Total cost of the found flow.
     207
     208    /// This function gives back the total cost of the found flow.
    209209    Length totalLength(){
    210210      return total_length;
  • lemon/suurballe.h

    r1435 r1527  
    4040  /// edge-weighted directed graph having minimal total weight (length).
    4141  ///
    42   ///\warning Length values should be nonnegative.
     42  ///\warning Length values should be nonnegative!
    4343  ///
    4444  ///\param Graph The directed graph type the algorithm runs on.
     
    122122     
    123123      paths.clear();
    124       //total_length=0;
    125124      paths.resize(k);
    126125      for (int j=0; j<i; ++j){
     
    136135          n = G.target(e);
    137136          paths[j].push_back(e);
    138           //total_length += length[e];
    139137          reversed[e] = 1-reversed[e];
    140138        }
     
    167165    ///This function checks, whether the given solution is optimal.
    168166    ///Currently this function only checks optimality,
    169     ///doesn't bother with feasibility
     167    ///doesn't bother with feasibility.
    170168    ///It is meant for testing purposes.
    171169    bool checkComplementarySlackness(){
     
    176174   
    177175    ///This function gives back the \c j-th path in argument p.
    178     ///Assumes that \c run() has been run and nothing changed since then.
     176    ///Assumes that \c run() has been run and nothing has changed since then.
    179177    /// \warning It is assumed that \c p is constructed to
    180178    ///be a path of graph \c G.
     
    183181    ///
    184182    ///\param Path The type of the path structure to put the result to (must meet lemon path concept).
    185     ///\param p The path to put the result to 
    186     ///\param j Which path you want to get from the found paths (in a real application you would get the found paths iteratively)
     183    ///\param p The path to put the result to.
     184    ///\param j Which path you want to get from the found paths (in a real application you would get the found paths iteratively).
    187185    template<typename Path>
    188186    void getPath(Path& p, size_t j){
Note: See TracChangeset for help on using the changeset viewer.