lemon: comparison lemon/path.h

equal deleted inserted replaced

-:446a1231e699
+:8f064d933553
 /// \brief A structure for representing directed paths in a digraph.
 ///
 /// A structure for representing directed path in a digraph.
 /// \tparam GR The digraph type in which the path is.
 ///
-/// In a sense, the path can be treated as a list of arcs. The
+/// In a sense, a path can be treated as a list of arcs. The
-/// LEMON path type stores just this list. As a consequence, it
+/// LEMON path type simply stores this list. As a consequence, it
-/// cannot enumerate the nodes of the path and the source node of
+/// cannot enumerate the nodes in the path, and the source node of
-/// a zero length path is undefined.
+/// a zero-length path is undefined.
 ///
 /// This implementation is a back and front insertable and erasable
 /// path type. It can be indexed in O(1) time. The front and back
 /// insertion and erase is done in O(1) (amortized) time. The
 /// implementation uses two vectors for storing the front and back
 /// \brief Reset the path to an empty one.
 void clear() { head.clear(); tail.clear(); }
 /// \brief The n-th arc.
 ///
-/// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
+/// Gives back the n-th arc. This function runs in O(1) time.
+/// \pre \c n is in the range <tt>[0..length() - 1]</tt>.
 const Arc& nth(int n) const {
 return n < int(head.size()) ? *(head.rbegin() + n) :
 *(tail.begin() + (n - head.size()));
 }
 /// \brief A structure for representing directed paths in a digraph.
 ///
 /// A structure for representing directed path in a digraph.
 /// \tparam GR The digraph type in which the path is.
 ///
-/// In a sense, the path can be treated as a list of arcs. The
+/// In a sense, a path can be treated as a list of arcs. The
-/// LEMON path type stores just this list. As a consequence it
+/// LEMON path type simply stores this list. As a consequence, it
-/// cannot enumerate the nodes in the path and the zero length paths
+/// cannot enumerate the nodes in the path, and the source node of
-/// cannot store the source.
+/// a zero-length path is undefined.
 ///
 /// This implementation is a just back insertable and erasable path
 /// type. It can be indexed in O(1) time. The back insertion and
 /// erasure is amortized O(1) time. This implementation is faster
-/// then the \c Path type because it use just one vector for the
+/// than the \c Path type because it use just one vector for the
 /// arcs.
 template <typename GR>
 class SimplePath {
 public:
 /// \brief Reset the path to an empty one.
 void clear() { data.clear(); }
 /// \brief The n-th arc.
 ///
-/// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
+/// Gives back the n-th arc. This function runs in O(1) time.
+/// \pre \c n is in the range <tt>[0..length() - 1]</tt>.
 const Arc& nth(int n) const {
 return data[n];
 }
 /// \brief  Initializes arc iterator to point to the n-th arc.
 /// \brief A structure for representing directed paths in a digraph.
 ///
 /// A structure for representing directed path in a digraph.
 /// \tparam GR The digraph type in which the path is.
 ///
-/// In a sense, the path can be treated as a list of arcs. The
+/// In a sense, a path can be treated as a list of arcs. The
-/// LEMON path type stores just this list. As a consequence it
+/// LEMON path type simply stores this list. As a consequence, it
-/// cannot enumerate the nodes in the path and the zero length paths
+/// cannot enumerate the nodes in the path, and the source node of
-/// cannot store the source.
+/// a zero-length path is undefined.
 ///
 /// This implementation is a back and front insertable and erasable
 /// path type. It can be indexed in O(k) time, where k is the rank
 /// of the arc in the path. The length can be computed in O(n)
 /// time. The front and back insertion and erasure is O(1) time
 /// \brief The n-th arc.
 ///
 /// This function looks for the n-th arc in O(n) time.
-/// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
+/// \pre \c n is in the range <tt>[0..length() - 1]</tt>.
 const Arc& nth(int n) const {
 Node *node = first;
 for (int i = 0; i < n; ++i) {
 node = node->next;
 }
 /// It splits the current path into two parts. The part before
 /// the iterator \c it will remain in the current path and the part
 /// starting with
 /// \c it will put into \c tpath. If \c tpath have arcs
 /// before the operation they are removed first.  The time
-/// complexity of this function is O(1) plus the the time of emtying
+/// complexity of this function is O(1) plus the time of emtying
 /// \c tpath. If \c it is \c INVALID then it just clears \c tpath
 void split(ArcIt it, ListPath& tpath) {
 tpath.clear();
 if (it.node) {
 tpath.first = it.node;
 /// \brief A structure for representing directed paths in a digraph.
 ///
 /// A structure for representing directed path in a digraph.
 /// \tparam GR The digraph type in which the path is.
 ///
-/// In a sense, the path can be treated as a list of arcs. The
+/// In a sense, a path can be treated as a list of arcs. The
-/// LEMON path type stores just this list. As a consequence it
+/// LEMON path type simply stores this list. As a consequence, it
-/// cannot enumerate the nodes in the path and the source node of
+/// cannot enumerate the nodes in the path, and the source node of
-/// a zero length path is undefined.
+/// a zero-length path is undefined.
 ///
 /// This implementation is completly static, i.e. it can be copy constucted
 /// or copy assigned from another path, but otherwise it cannot be
 /// modified.
 ///
-/// Being the the most memory efficient path type in LEMON,
+/// Being the most memory-efficient path type in LEMON, it is
-/// it is intented to be
+/// intented to be used when you want to store a large number of paths.
-/// used when you want to store a large number of paths.
 template <typename GR>
 class StaticPath {
 public:
 typedef GR Digraph;
 }
 /// \brief The n-th arc.
 ///
-/// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
+/// Gives back the n-th arc. This function runs in O(1) time.
+/// \pre \c n is in the range <tt>[0..length() - 1]</tt>.
 const Arc& nth(int n) const {
 return _arcs[n];
 }
 /// \brief The arc iterator pointing to the n-th arc.
 int length() const { return len; }
 /// \brief Return true when the path is empty.
 int empty() const { return len == 0; }
-/// \brief Erase all arcs in the digraph.
+/// \brief Reset the path to an empty one.
 void clear() {
 len = 0;
 if (_arcs) delete[] _arcs;
 _arcs = 0;
 }
 template <typename Digraph, typename Path>
 typename Digraph::Node pathTarget(const Digraph& digraph, const Path& path) {
 return path.empty() ? INVALID : digraph.target(path.back());
 }
-/// \brief Class which helps to iterate through the nodes of a path
+/// \brief Class for iterating through the nodes of a path
 ///
-/// In a sense, the path can be treated as a list of arcs. The
+/// Class for iterating through the nodes of a path.
-/// LEMON path type stores only this list. As a consequence, it
+///
-/// cannot enumerate the nodes in the path and the zero length paths
+/// In a sense, a path can be treated as a list of arcs. The
-/// cannot have a source node.
+/// LEMON path type simply stores this list. As a consequence, it
-///
+/// cannot enumerate the nodes in the path, and the source node of
-/// This class implements the node iterator of a path structure. To
+/// a zero-length path is undefined.
-/// provide this feature, the underlying digraph should be passed to
+///
+/// However, this class implements a node iterator for path structures.
+/// To provide this feature, the underlying digraph should be passed to
 /// the constructor of the iterator.
 template <typename Path>
 class PathNodeIt {
 private:
 const typename Path::Digraph *_digraph;

changeset 1420	1f4f01870c1e
parent 1336	0759d974de81
child 1421	4fd76139b69e