Index: lemon/concept/sym_graph.h
===================================================================
 lemon/concept/sym_graph.h (revision 1526)
+++ lemon/concept/sym_graph.h (revision 1527)
@@ 43,6 +43,6 @@
/// or it can serve as a skeleton of a new symmetric graph structure.
///
 /// Also, you will find here the full documentation of a certain graph
 /// feature, the documentation of a real symmetric graph imlementation
+ /// Also, you will find here the full documentation of graph
+ /// features, the documentation of a real symmetric graph imlementation
/// like @ref SymListGraph or
/// @ref lemon::SymSmartGraph will just refer to this structure.
@@ 55,5 +55,5 @@
///
StaticSymGraph() { }
 ///Copy consructor.
+ // ///Copy consructor.
// ///\todo It is not clear, what we expect from a copy constructor.
@@ 94,5 +94,5 @@
/// Inequality operator
 /// \sa operator==(Node n)
+ /// \sa operator==(Node)
///
bool operator!=(Node) const { return true; }
@@ 142,7 +142,7 @@
/// Sets the iterator to the node of \c g pointed by the trivial
 /// iterator n.
+ /// iterator \c n.
/// This feature necessitates that each time we
 /// iterate the edgeset, the iteration order is the same.
+ /// iterate the nodeset, the iteration order is the same.
NodeIt(const StaticSymGraph& g, const Node& n) { }
/// Next node.
@@ 268,6 +268,6 @@
/// This constructor sets the iterator to first outgoing edge.
 /// This constructor set the iterator to the first outgoing edge of
 /// node
+ /// This constructor sets the iterator to the first outgoing edge of
+ /// the node
///@param n the node
///@param g the graph
@@ 317,6 +317,6 @@
/// This constructor sets the iterator to first incoming edge.
 /// This constructor set the iterator to the first incoming edge of
 /// node
+ /// This constructor sets the iterator to the first incoming edge of
+ /// the node
///@param n the node
///@param g the graph
@@ 362,6 +362,6 @@
/// This constructor sets the iterator to first edge.
 /// This constructor set the iterator to the first edge of
 /// node
+ /// This constructor sets the iterator to the first edge of
+ /// the graph
///@param g the graph
SymEdgeIt(const StaticSymGraph& g) { }
@@ 406,6 +406,6 @@
/// This constructor sets the iterator to first edge.
 /// This constructor set the iterator to the first edge of
 /// node
+ /// This constructor sets the iterator to the first edge of
+ /// the graph
///@param g the graph
EdgeIt(const StaticSymGraph& g) { }
@@ 590,8 +590,8 @@
/// An empty nonstatic graph class.
 /// This class provides everything that \ref StaticGraph
 /// with additional functionality which enables to build a
+ /// This class is an extension of \ref StaticGraph
+ /// with additional functionality that enables one to build a
/// graph from scratch.
 class ExtendableSymGraph : public StaticSymGraph
+ class ExtendableSymGraph : public StaticSymGraph
{
public:
@@ 623,6 +623,6 @@
/// An empty erasable graph class.
 /// This class is an extension of \ref ExtendableGraph. It also makes it
 /// possible to erase edges or nodes.
+ /// This class is an extension of \ref ExtendableGraph. It is also
+ /// possible to erase edges or nodes in this graph.
class ErasableSymGraph : public ExtendableSymGraph
{
Index: lemon/min_cost_flow.h
===================================================================
 lemon/min_cost_flow.h (revision 1435)
+++ lemon/min_cost_flow.h (revision 1527)
@@ 39,14 +39,14 @@
/// The class \ref lemon::MinCostFlow "MinCostFlow" implements an
/// algorithm for finding a flow of value \c k having minimal total
 /// cost from a given source node to a given target node in an
 /// edgeweighted directed graph. To this end, the edgecapacities
 /// and edgeweights have to be nonnegative. The edgecapacities
 /// should be integers, but the edgeweights can be integers, reals
 /// or of other comparable numeric type. This algorithm is intended
 /// to be used only for small values of \c k, since it is only
 /// polynomial in k, not in the length of k (which is log k): in
 /// order to find the minimum cost flow of value \c k it finds the
 /// minimum cost flow of value \c i for every \c i between 0 and \c
 /// k.
+ /// cost from a given source node to a given target node in a
+ /// directed graph with a cost function on the edges. To
+ /// this end, the edgecapacities and edgecosts have to be
+ /// nonnegative. The edgecapacities should be integers, but the
+ /// edgecosts can be integers, reals or of other comparable
+ /// numeric type. This algorithm is intended to be used only for
+ /// small values of \c k, since it is only polynomial in k, not in
+ /// the length of k (which is log k): in order to find the minimum
+ /// cost flow of value \c k it finds the minimum cost flow of value
+ /// \c i for every \c i between 0 and \c k.
///
///\param Graph The directed graph type the algorithm runs on.
@@ 118,5 +118,5 @@
\param _g The directed graph the algorithm runs on.
 \param _length The length (weight or cost) of the edges.
+ \param _length The length (cost) of the edges.
\param _cap The capacity of the edges.
\param _s Source node.
@@ 204,7 +204,7 @@
}
 /// Total weight of the found flow.

 /// This function gives back the total weight of the found flow.
+ /// Total cost of the found flow.
+
+ /// This function gives back the total cost of the found flow.
Length totalLength(){
return total_length;
Index: lemon/suurballe.h
===================================================================
 lemon/suurballe.h (revision 1435)
+++ lemon/suurballe.h (revision 1527)
@@ 40,5 +40,5 @@
/// edgeweighted directed graph having minimal total weight (length).
///
 ///\warning Length values should be nonnegative.
+ ///\warning Length values should be nonnegative!
///
///\param Graph The directed graph type the algorithm runs on.
@@ 122,5 +122,4 @@
paths.clear();
 //total_length=0;
paths.resize(k);
for (int j=0; j
void getPath(Path& p, size_t j){