# HG changeset patch
# User athos
# Date 1120214007 0
# Node ID 7ceab500e1f65070ac72134668124a054a31fa08
# Parent 8c14aa8f27a210ec9f6fe45dac6bae977d778280
Doc review+corrections in my own documentation according to the reviewers comments.
diff -r 8c14aa8f27a2 -r 7ceab500e1f6 doc/graph_io.dox
--- a/doc/graph_io.dox Thu Jun 30 16:13:30 2005 +0000
+++ b/doc/graph_io.dox Fri Jul 01 10:33:27 2005 +0000
@@ -206,12 +206,13 @@
reader.run();
\endcode
-\section types The background of Reading and Writing
-The \c GraphReader should know how to read a Value from the given map.
+\section types Background of Reading and Writing
+To read a map (on the nodes or edges)
+the \c GraphReader should know how to read a Value from the given map.
By the default implementation the input operator reads a value from
the stream and the type of the readed value is the value type of the given map.
When the reader should skip a value in the stream, because you do not
-want to store it in map, the reader skips a character sequence without
+want to store it in a map, the reader skips a character sequence without
whitespace.
If you want to change the functionality of the reader, you can use
@@ -229,7 +230,7 @@
};
\endcode
-By example, the \c "strings" nodemap contains strings and you do not need
+For example, the \c "strings" nodemap contains strings and you do not need
the value of the string just the length. Then you can implement own Reader
struct.
@@ -253,7 +254,7 @@
should provide an inner template class Reader for each type, and an
DefaultReader for skipping a value.
-The specialization of the writing should be very similar to the reading.
+The specialization of writing should be very similar to that of reading.
\author Balazs Dezso
*/
diff -r 8c14aa8f27a2 -r 7ceab500e1f6 lemon/concept/sym_graph.h
--- a/lemon/concept/sym_graph.h Thu Jun 30 16:13:30 2005 +0000
+++ b/lemon/concept/sym_graph.h Fri Jul 01 10:33:27 2005 +0000
@@ -42,8 +42,8 @@
/// It can be used for checking the interface compatibility,
/// 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.
class StaticSymGraph
@@ -54,7 +54,7 @@
/// Default constructor.
///
StaticSymGraph() { }
- ///Copy consructor.
+ // ///Copy consructor.
// ///\todo It is not clear, what we expect from a copy constructor.
// ///E.g. How to assign the nodes/edges to each other? What about maps?
@@ -93,7 +93,7 @@
/// Inequality operator
- /// \sa operator==(Node n)
+ /// \sa operator==(Node)
///
bool operator!=(Node) const { return true; }
@@ -141,9 +141,9 @@
/// Node -> NodeIt conversion.
/// 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 edge-set, the iteration order is the same.
+ /// iterate the node-set, the iteration order is the same.
NodeIt(const StaticSymGraph& g, const Node& n) { }
/// Next node.
@@ -267,8 +267,8 @@
OutEdgeIt(Invalid) { }
/// 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
OutEdgeIt(const StaticSymGraph& g, const Node& n) { }
@@ -316,8 +316,8 @@
InEdgeIt(Invalid) { }
/// 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
InEdgeIt(const StaticSymGraph& g, const Node& n) { }
@@ -361,8 +361,8 @@
SymEdgeIt(Invalid) { }
/// 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) { }
/// Edge -> EdgeIt conversion
@@ -405,8 +405,8 @@
EdgeIt(Invalid) { }
/// 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) { }
/// Edge -> EdgeIt conversion
@@ -589,10 +589,10 @@
/// An empty non-static 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:
/// Default constructor.
@@ -622,8 +622,8 @@
/// 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
{
public:
diff -r 8c14aa8f27a2 -r 7ceab500e1f6 lemon/min_cost_flow.h
--- a/lemon/min_cost_flow.h Thu Jun 30 16:13:30 2005 +0000
+++ b/lemon/min_cost_flow.h Fri Jul 01 10:33:27 2005 +0000
@@ -38,16 +38,16 @@
///
/// 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
- /// edge-weighted directed graph. To this end, the edge-capacities
- /// and edge-weights have to be nonnegative. The edge-capacities
- /// should be integers, but the edge-weights 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 edge-capacities and edge-costs have to be
+ /// nonnegative. The edge-capacities should be integers, but the
+ /// edge-costs 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.
///\param LengthMap The type of the length map.
@@ -117,7 +117,7 @@
/*! \brief The constructor of the class.
\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.
\param _t Target node.
@@ -203,9 +203,9 @@
return i;
}
- /// Total weight of the found flow.
+ /// Total cost of the found flow.
- /// This function gives back the total weight of the found flow.
+ /// This function gives back the total cost of the found flow.
Length totalLength(){
return total_length;
}
diff -r 8c14aa8f27a2 -r 7ceab500e1f6 lemon/suurballe.h
--- a/lemon/suurballe.h Thu Jun 30 16:13:30 2005 +0000
+++ b/lemon/suurballe.h Fri Jul 01 10:33:27 2005 +0000
@@ -39,7 +39,7 @@
/// from a given source node to a given target node in an
/// edge-weighted 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.
///\param LengthMap The type of the length map (values should be nonnegative).
@@ -121,7 +121,6 @@
reversed[e] = min_cost_flow.getFlow()[e];
paths.clear();
- //total_length=0;
paths.resize(k);
for (int j=0; j<i; ++j){
Node n=s;
@@ -135,7 +134,6 @@
}
n = G.target(e);
paths[j].push_back(e);
- //total_length += length[e];
reversed[e] = 1-reversed[e];
}
@@ -166,7 +164,7 @@
///This function checks, whether the given solution is optimal.
///Currently this function only checks optimality,
- ///doesn't bother with feasibility
+ ///doesn't bother with feasibility.
///It is meant for testing purposes.
bool checkComplementarySlackness(){
return min_cost_flow.checkComplementarySlackness();
@@ -175,15 +173,15 @@
///Read the found paths.
///This function gives back the \c j-th path in argument p.
- ///Assumes that \c run() has been run and nothing changed since then.
+ ///Assumes that \c run() has been run and nothing has changed since then.
/// \warning It is assumed that \c p is constructed to
///be a path of graph \c G.
///If \c j is not less than the result of previous \c run,
///then the result here will be an empty path (\c j can be 0 as well).
///
///\param Path The type of the path structure to put the result to (must meet lemon path concept).
- ///\param p The path to put the result to
- ///\param j Which path you want to get from the found paths (in a real application you would get the found paths iteratively)
+ ///\param p The path to put the result to.
+ ///\param j Which path you want to get from the found paths (in a real application you would get the found paths iteratively).
template<typename Path>
void getPath(Path& p, size_t j){