COIN-OR::LEMON - Graph Library

Changeset 1527:7ceab500e1f6 in lemon-0.x


Ignore:
Timestamp:
07/01/05 12:33:27 (14 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.

Files:
4 edited

Legend:

Unmodified
Added
Removed
  • doc/graph_io.dox

    r1526 r1527  
    207207\endcode
    208208
    209 \section types The background of Reading and Writing
    210 The \c GraphReader should know how to read a Value from the given map.
     209\section types Background of Reading and Writing
     210To read a map (on the nodes or edges)
     211the \c GraphReader should know how to read a Value from the given map.
    211212By the default implementation the input operator reads a value from
    212213the stream and the type of the readed value is the value type of the given map.
    213214When the reader should skip a value in the stream, because you do not
    214 want to store it in map, the reader skips a character sequence without
     215want to store it in a map, the reader skips a character sequence without
    215216whitespace.
    216217
     
    230231\endcode
    231232
    232 By example, the \c "strings" nodemap contains strings and you do not need
     233For example, the \c "strings" nodemap contains strings and you do not need
    233234the value of the string just the length. Then you can implement own Reader
    234235struct.
     
    254255DefaultReader for skipping a value.
    255256
    256 The specialization of the writing should be very similar to the reading.
     257The specialization of  writing should be very similar to that of reading.
    257258
    258259\author Balazs Dezso
  • 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.