1.1 --- a/doc/graph_io.dox	Thu Jun 30 16:13:30 2005 +0000
     1.2 +++ b/doc/graph_io.dox	Fri Jul 01 10:33:27 2005 +0000
     1.3 @@ -206,12 +206,13 @@
     1.4  reader.run();
     1.5  \endcode
     1.6  
     1.7 -\section types The background of Reading and Writing
     1.8 -The \c GraphReader should know how to read a Value from the given map.
     1.9 +\section types Background of Reading and Writing
    1.10 +To read a map (on the nodes or edges)
    1.11 +the \c GraphReader should know how to read a Value from the given map.
    1.12  By the default implementation the input operator reads a value from
    1.13  the stream and the type of the readed value is the value type of the given map.
    1.14  When the reader should skip a value in the stream, because you do not
    1.15 -want to store it in map, the reader skips a character sequence without 
    1.16 +want to store it in a map, the reader skips a character sequence without 
    1.17  whitespace. 
    1.18  
    1.19  If you want to change the functionality of the reader, you can use
    1.20 @@ -229,7 +230,7 @@
    1.21  };
    1.22  \endcode
    1.23  
    1.24 -By example, the \c "strings" nodemap contains strings and you do not need
    1.25 +For example, the \c "strings" nodemap contains strings and you do not need
    1.26  the value of the string just the length. Then you can implement own Reader
    1.27  struct.
    1.28  
    1.29 @@ -253,7 +254,7 @@
    1.30  should provide an inner template class Reader for each type, and an 
    1.31  DefaultReader for skipping a value.
    1.32  
    1.33 -The specialization of the writing should be very similar to the reading.
    1.34 +The specialization of  writing should be very similar to that of reading.
    1.35  
    1.36  \author Balazs Dezso
    1.37  */

     2.1 --- a/lemon/concept/sym_graph.h	Thu Jun 30 16:13:30 2005 +0000
     2.2 +++ b/lemon/concept/sym_graph.h	Fri Jul 01 10:33:27 2005 +0000
     2.3 @@ -42,8 +42,8 @@
     2.4      /// It can be used for checking the interface compatibility,
     2.5      /// or it can serve as a skeleton of a new symmetric graph structure.
     2.6      /// 
     2.7 -    /// Also, you will find here the full documentation of a certain graph
     2.8 -    /// feature, the documentation of a real symmetric graph imlementation
     2.9 +    /// Also, you will find here the full documentation of graph
    2.10 +    /// features, the documentation of a real symmetric graph imlementation
    2.11      /// like @ref SymListGraph or
    2.12      /// @ref lemon::SymSmartGraph will just refer to this structure.
    2.13      class StaticSymGraph
    2.14 @@ -54,7 +54,7 @@
    2.15        /// Default constructor.
    2.16        ///
    2.17        StaticSymGraph() { }
    2.18 -      ///Copy consructor.
    2.19 +      //      ///Copy consructor.
    2.20  
    2.21  //       ///\todo It is not clear, what we expect from a copy constructor.
    2.22  //       ///E.g. How to assign the nodes/edges to each other? What about maps?
    2.23 @@ -93,7 +93,7 @@
    2.24  
    2.25  	/// Inequality operator
    2.26  	
    2.27 -	/// \sa operator==(Node n)
    2.28 +	/// \sa operator==(Node)
    2.29  	///
    2.30  	bool operator!=(Node) const { return true; }
    2.31  
    2.32 @@ -141,9 +141,9 @@
    2.33  	/// Node -> NodeIt conversion.
    2.34  
    2.35  	/// Sets the iterator to the node of \c g pointed by the trivial 
    2.36 -	/// iterator n.
    2.37 +	/// iterator \c n.
    2.38  	/// This feature necessitates that each time we 
    2.39 -	/// iterate the edge-set, the iteration order is the same.
    2.40 +	/// iterate the node-set, the iteration order is the same.
    2.41  	NodeIt(const StaticSymGraph& g, const Node& n) { }
    2.42  	/// Next node.
    2.43  
    2.44 @@ -267,8 +267,8 @@
    2.45  	OutEdgeIt(Invalid) { }
    2.46  	/// This constructor sets the iterator to first outgoing edge.
    2.47      
    2.48 -	/// This constructor set the iterator to the first outgoing edge of
    2.49 -	/// node
    2.50 +	/// This constructor sets the iterator to the first outgoing edge of
    2.51 +	/// the node
    2.52  	///@param n the node
    2.53  	///@param g the graph
    2.54  	OutEdgeIt(const StaticSymGraph& g, const Node& n) { }
    2.55 @@ -316,8 +316,8 @@
    2.56  	InEdgeIt(Invalid) { }
    2.57  	/// This constructor sets the iterator to first incoming edge.
    2.58      
    2.59 -	/// This constructor set the iterator to the first incoming edge of
    2.60 -	/// node
    2.61 +	/// This constructor sets the iterator to the first incoming edge of
    2.62 +	/// the node
    2.63  	///@param n the node
    2.64  	///@param g the graph
    2.65  	InEdgeIt(const StaticSymGraph& g, const Node& n) { }
    2.66 @@ -361,8 +361,8 @@
    2.67  	SymEdgeIt(Invalid) { }
    2.68  	/// This constructor sets the iterator to first edge.
    2.69      
    2.70 -	/// This constructor set the iterator to the first edge of
    2.71 -	/// node
    2.72 +	/// This constructor sets the iterator to the first edge of
    2.73 +	/// the graph
    2.74  	///@param g the graph
    2.75  	SymEdgeIt(const StaticSymGraph& g) { }
    2.76  	/// Edge -> EdgeIt conversion
    2.77 @@ -405,8 +405,8 @@
    2.78  	EdgeIt(Invalid) { }
    2.79  	/// This constructor sets the iterator to first edge.
    2.80      
    2.81 -	/// This constructor set the iterator to the first edge of
    2.82 -	/// node
    2.83 +	/// This constructor sets the iterator to the first edge of
    2.84 +	/// the graph
    2.85  	///@param g the graph
    2.86  	EdgeIt(const StaticSymGraph& g) { }
    2.87  	/// Edge -> EdgeIt conversion
    2.88 @@ -589,10 +589,10 @@
    2.89    
    2.90      /// An empty non-static graph class.
    2.91  
    2.92 -    /// This class provides everything that \ref StaticGraph
    2.93 -    /// with additional functionality which enables to build a
    2.94 +    /// This class is an extension of \ref StaticGraph
    2.95 +    /// with additional functionality that enables one to build a
    2.96      /// graph from scratch.
    2.97 -    class ExtendableSymGraph : public StaticSymGraph
    2.98 +     class ExtendableSymGraph : public StaticSymGraph
    2.99      {
   2.100      public:
   2.101        /// Default constructor.
   2.102 @@ -622,8 +622,8 @@
   2.103  
   2.104      /// An empty erasable graph class.
   2.105    
   2.106 -    /// This class is an extension of \ref ExtendableGraph. It also makes it
   2.107 -    /// possible to erase edges or nodes.
   2.108 +    /// This class is an extension of \ref ExtendableGraph. It is also
   2.109 +    /// possible to erase edges or nodes in this graph.
   2.110      class ErasableSymGraph : public ExtendableSymGraph
   2.111      {
   2.112      public:

     3.1 --- a/lemon/min_cost_flow.h	Thu Jun 30 16:13:30 2005 +0000
     3.2 +++ b/lemon/min_cost_flow.h	Fri Jul 01 10:33:27 2005 +0000
     3.3 @@ -38,16 +38,16 @@
     3.4    ///
     3.5    /// The class \ref lemon::MinCostFlow "MinCostFlow" implements an
     3.6    /// algorithm for finding a flow of value \c k having minimal total
     3.7 -  /// cost from a given source node to a given target node in an
     3.8 -  /// edge-weighted directed graph. To this end, the edge-capacities
     3.9 -  /// and edge-weights have to be nonnegative.  The edge-capacities
    3.10 -  /// should be integers, but the edge-weights can be integers, reals
    3.11 -  /// or of other comparable numeric type.  This algorithm is intended
    3.12 -  /// to be used only for small values of \c k, since it is only
    3.13 -  /// polynomial in k, not in the length of k (which is log k):  in
    3.14 -  /// order to find the minimum cost flow of value \c k it finds the
    3.15 -  /// minimum cost flow of value \c i for every \c i between 0 and \c
    3.16 -  /// k.
    3.17 +  /// cost from a given source node to a given target node in a
    3.18 +  /// directed graph with a cost function on the edges. To
    3.19 +  /// this end, the edge-capacities and edge-costs have to be
    3.20 +  /// nonnegative.  The edge-capacities should be integers, but the
    3.21 +  /// edge-costs can be integers, reals or of other comparable
    3.22 +  /// numeric type.  This algorithm is intended to be used only for
    3.23 +  /// small values of \c k, since it is only polynomial in k, not in
    3.24 +  /// the length of k (which is log k): in order to find the minimum
    3.25 +  /// cost flow of value \c k it finds the minimum cost flow of value
    3.26 +  /// \c i for every \c i between 0 and \c k.
    3.27    ///
    3.28    ///\param Graph The directed graph type the algorithm runs on.
    3.29    ///\param LengthMap The type of the length map.
    3.30 @@ -117,7 +117,7 @@
    3.31      /*! \brief The constructor of the class.
    3.32      
    3.33      \param _g The directed graph the algorithm runs on. 
    3.34 -    \param _length The length (weight or cost) of the edges. 
    3.35 +    \param _length The length (cost) of the edges. 
    3.36      \param _cap The capacity of the edges. 
    3.37      \param _s Source node.
    3.38      \param _t Target node.
    3.39 @@ -203,9 +203,9 @@
    3.40        return i;
    3.41      }
    3.42  
    3.43 -    /// Total weight of the found flow.
    3.44 +    /// Total cost of the found flow.
    3.45  
    3.46 -    /// This function gives back the total weight of the found flow.
    3.47 +    /// This function gives back the total cost of the found flow.
    3.48      Length totalLength(){
    3.49        return total_length;
    3.50      }

     4.1 --- a/lemon/suurballe.h	Thu Jun 30 16:13:30 2005 +0000
     4.2 +++ b/lemon/suurballe.h	Fri Jul 01 10:33:27 2005 +0000
     4.3 @@ -39,7 +39,7 @@
     4.4    /// from a given source node to a given target node in an
     4.5    /// edge-weighted directed graph having minimal total weight (length).
     4.6    ///
     4.7 -  ///\warning Length values should be nonnegative.
     4.8 +  ///\warning Length values should be nonnegative!
     4.9    /// 
    4.10    ///\param Graph The directed graph type the algorithm runs on.
    4.11    ///\param LengthMap The type of the length map (values should be nonnegative).
    4.12 @@ -121,7 +121,6 @@
    4.13  	reversed[e] = min_cost_flow.getFlow()[e];
    4.14        
    4.15        paths.clear();
    4.16 -      //total_length=0;
    4.17        paths.resize(k);
    4.18        for (int j=0; j<i; ++j){
    4.19  	Node n=s;
    4.20 @@ -135,7 +134,6 @@
    4.21  	  }
    4.22  	  n = G.target(e);
    4.23  	  paths[j].push_back(e);
    4.24 -	  //total_length += length[e];
    4.25  	  reversed[e] = 1-reversed[e];
    4.26  	}
    4.27  	
    4.28 @@ -166,7 +164,7 @@
    4.29  
    4.30      ///This function checks, whether the given solution is optimal.
    4.31      ///Currently this function only checks optimality,
    4.32 -    ///doesn't bother with feasibility
    4.33 +    ///doesn't bother with feasibility.
    4.34      ///It is meant for testing purposes.
    4.35      bool checkComplementarySlackness(){
    4.36        return min_cost_flow.checkComplementarySlackness();
    4.37 @@ -175,15 +173,15 @@
    4.38      ///Read the found paths.
    4.39      
    4.40      ///This function gives back the \c j-th path in argument p.
    4.41 -    ///Assumes that \c run() has been run and nothing changed since then.
    4.42 +    ///Assumes that \c run() has been run and nothing has changed since then.
    4.43      /// \warning It is assumed that \c p is constructed to
    4.44      ///be a path of graph \c G.
    4.45      ///If \c j is not less than the result of previous \c run,
    4.46      ///then the result here will be an empty path (\c j can be 0 as well).
    4.47      ///
    4.48      ///\param Path The type of the path structure to put the result to (must meet lemon path concept).
    4.49 -    ///\param p The path to put the result to 
    4.50 -    ///\param j Which path you want to get from the found paths (in a real application you would get the found paths iteratively)
    4.51 +    ///\param p The path to put the result to.
    4.52 +    ///\param j Which path you want to get from the found paths (in a real application you would get the found paths iteratively).
    4.53      template<typename Path>
    4.54      void getPath(Path& p, size_t j){
    4.55