lemon: comparison lemon/full

equal deleted inserted replaced

-:f9e479c25565
+:a4df2492fdb5
 */
 #ifndef LEMON_FULL_GRAPH_H
 #define LEMON_FULL_GRAPH_H
-#include <lemon/math.h>
 #include <lemon/core.h>
 #include <lemon/bits/graph_extender.h>
 ///\ingroup graphs
 ///\file
-///\brief FullDigraph and FullGraph classes.
+///\brief FullGraph and FullDigraph classes.
 namespace lemon {
 class FullDigraphBase {
 public:
 int maxArcId() const { return _arc_num - 1; }
 Node source(Arc arc) const { return arc._id / _node_num; }
 Node target(Arc arc) const { return arc._id % _node_num; }
 static int id(Node node) { return node._id; }
 static int id(Arc arc) { return arc._id; }
 static Node nodeFromId(int id) { return Node(id);}
 static Arc arcFromId(int id) { return Arc(id);}
 typedef True FindArcTag;
 Arc findArc(Node s, Node t, Arc prev = INVALID) const {
 return prev != INVALID ? arc(s, t) : INVALID;
 }
 class Node {
 friend class FullDigraphBase;
 protected:
 /// \brief A full digraph class.
 ///
 /// This is a simple and fast directed full graph implementation.
 /// From each node go arcs to each node (including the source node),
 /// therefore the number of the arcs in the digraph is the square of
-/// the node number. The digraph is completely static, so you can
+/// the node number. This digraph type is completely static, so you
-/// neither add nor delete either arcs or nodes, and it needs just
+/// can neither add nor delete either arcs or nodes, and it needs
 /// constant space in memory.
 ///
-/// Thus it conforms to the \ref concepts::Digraph "Digraph" concept
+/// This class conforms to the \ref concepts::Digraph "Digraph" concept
 /// and it also has an important extra feature that its maps are
 /// real \ref concepts::ReferenceMap "reference map"s.
-/// \sa concepts::Digraph.
+///
+/// The \c FullDigraph and \c FullGraph classes are very similar,
+/// but there are two differences. While this class conforms only
+/// to the \ref concepts::Digraph "Digraph" concept, the \c FullGraph
+/// class conforms to the \ref concepts::Graph "Graph" concept,
+/// moreover \c FullGraph does not contain a loop arc for each
+/// node as \c FullDigraph does.
 ///
 /// \sa FullGraph
 class FullDigraph : public ExtendedFullDigraphBase {
 public:
 /// \brief Constructor
 FullDigraph() { construct(0); }
 /// \brief Constructor
 ///
+/// Constructor.
 /// \param n The number of the nodes.
 FullDigraph(int n) { construct(n); }
-/// \brief Resize the digraph
+/// \brief Resizes the digraph
 ///
-/// Resize the digraph. The function will fully destroy and
+/// Resizes the digraph. The function will fully destroy and
-/// rebuild the digraph.  This cause that the maps of the digraph
+/// rebuild the digraph. This cause that the maps of the digraph will
-/// will reallocated automatically and the previous values will be
+/// reallocated automatically and the previous values will be lost.
-/// lost.
 void resize(int n) {
 Parent::notifier(Arc()).clear();
 Parent::notifier(Node()).clear();
 construct(n);
 Parent::notifier(Node()).build();
 Parent::notifier(Arc()).build();
 }
 /// \brief Returns the node with the given index.
 ///
-/// Returns the node with the given index. Because it is a
+/// Returns the node with the given index. Since it is a static
-/// static size digraph the node's of the digraph can be indexed
+/// digraph its nodes can be indexed with integers from the range
-/// in the range <tt>[0..nodeNum()-1]</tt> and the index of
+/// <tt>[0..nodeNum()-1]</tt>.
-/// the node can accessed by the \e index() member.
+/// \sa index()
 Node operator()(int ix) const { return Parent::operator()(ix); }
-/// \brief Returns the index of the node.
+/// \brief Returns the index of the given node.
 ///
-/// Returns the index of the node. Because it is a
+/// Returns the index of the given node. Since it is a static
-/// static size digraph the node's of the digraph can be indexed
+/// digraph its nodes can be indexed with integers from the range
-/// in the range <tt>[0..nodeNum()-1]</tt> and the index of
+/// <tt>[0..nodeNum()-1]</tt>.
-/// the node can accessed by the \e index() member.
+/// \sa operator()
 int index(const Node& node) const { return Parent::index(node); }
-/// \brief Returns the arc connects the given nodes.
+/// \brief Returns the arc connecting the given nodes.
 ///
-/// Returns the arc connects the given nodes.
+/// Returns the arc connecting the given nodes.
 Arc arc(const Node& u, const Node& v) const {
 return Parent::arc(u, v);
 }
 /// \brief Number of nodes.
 return (_node_num - 1 - u) * _node_num - v - 1;
 }
 }
 public:
 Node operator()(int ix) const { return Node(ix); }
 int index(const Node& node) const { return node._id; }
 Edge edge(const Node& u, const Node& v) const {
 bool operator<(const Node node) const {return _id < node._id;}
 };
 class Edge {
 friend class FullGraphBase;
+friend class Arc;
 protected:
 int _id;
 Edge(int id) : _id(id) {}
 ///
 /// \brief An undirected full graph class.
 ///
 /// This is a simple and fast undirected full graph
 /// implementation. From each node go edge to each other node,
-/// therefore the number of edges in the graph is
+/// therefore the number of edges in the graph is \f$n(n-1)/2\f$.
-/// <tt>n(n-1)/2</tt>. It is completely static, so you can neither
+/// This graph type is completely static, so you can neither
-/// add nor delete either edges or nodes, and it needs just constant
+/// add nor delete either edges or nodes, and it needs constant
 /// space in memory.
 ///
-/// The \e FullDigraph and \e FullGraph classes are very similar,
+/// This class conforms to the \ref concepts::Graph "Graph" concept
-/// but there are two differences. While the \e FullDigraph class is
+/// and it also has an important extra feature that its maps are
-/// conform just to the \ref concepts::Digraph "Digraph" concept,
+/// real \ref concepts::ReferenceMap "reference map"s.
-/// this class is conform to the \ref concepts::Graph "Graph"
+///
-/// concept. In addition, the \e FullGraph class does not contain a
+/// The \c FullGraph and \c FullDigraph classes are very similar,
-/// loop arc from each node as the \e FullDigraph does.
+/// but there are two differences. While the \c FullDigraph class
-///
+/// conforms only to the \ref concepts::Digraph "Digraph" concept,
-/// It also has an important extra feature that its maps are real
+/// this class conforms to the \ref concepts::Graph "Graph" concept,
-/// \ref concepts::ReferenceMap "reference map"s.
+/// moreover \c FullGraph does not contain a loop arc for each
+/// node as \c FullDigraph does.
 ///
 /// \sa FullDigraph
 class FullGraph : public ExtendedFullGraphBase {
 public:
 /// \brief Constructor
 FullGraph() { construct(0); }
 /// \brief Constructor
 ///
+/// Constructor.
 /// \param n The number of the nodes.
 FullGraph(int n) { construct(n); }
-/// \brief Resize the graph
+/// \brief Resizes the graph
 ///
-/// Resize the graph. The function will fully destroy and rebuild
+/// Resizes the graph. The function will fully destroy and
-/// the graph.  This cause that the maps of the graph will
+/// rebuild the graph. This cause that the maps of the graph will
-/// reallocated automatically and the previous values will be
+/// reallocated automatically and the previous values will be lost.
-/// lost.
 void resize(int n) {
 Parent::notifier(Arc()).clear();
 Parent::notifier(Edge()).clear();
 Parent::notifier(Node()).clear();
 construct(n);
 Parent::notifier(Arc()).build();
 }
 /// \brief Returns the node with the given index.
 ///
-/// Returns the node with the given index. Because it is a static
+/// Returns the node with the given index. Since it is a static
-/// size graph the node's of the graph can be indexed in the range
+/// graph its nodes can be indexed with integers from the range
-/// <tt>[0..nodeNum()-1]</tt> and the index of the node can
+/// <tt>[0..nodeNum()-1]</tt>.
-/// accessed by the \e index() member.
+/// \sa index()
 Node operator()(int ix) const { return Parent::operator()(ix); }
-/// \brief Returns the index of the node.
+/// \brief Returns the index of the given node.
 ///
-/// Returns the index of the node. Because it is a static size
+/// Returns the index of the given node. Since it is a static
-/// graph the node's of the graph can be indexed in the range
+/// graph its nodes can be indexed with integers from the range
-/// <tt>[0..nodeNum()-1]</tt> and the index of the node can
+/// <tt>[0..nodeNum()-1]</tt>.
-/// accessed by the \e index() member.
+/// \sa operator()
 int index(const Node& node) const { return Parent::index(node); }
+/// \brief Returns the arc connecting the given nodes.
+///
+/// Returns the arc connecting the given nodes.
+Arc arc(const Node& s, const Node& t) const {
+return Parent::arc(s, t);
+}
+/// \brief Returns the edge connects the given nodes.
+///
+/// Returns the edge connects the given nodes.
+Edge edge(const Node& u, const Node& v) const {
+return Parent::edge(u, v);
+}
 /// \brief Number of nodes.
 int nodeNum() const { return Parent::nodeNum(); }
 /// \brief Number of arcs.
 int arcNum() const { return Parent::arcNum(); }
 /// \brief Number of edges.
 int edgeNum() const { return Parent::edgeNum(); }
-/// \brief Returns the arc connects the given nodes.
-///
-/// Returns the arc connects the given nodes.
-Arc arc(const Node& s, const Node& t) const {
-return Parent::arc(s, t);
-}
-/// \brief Returns the edge connects the given nodes.
-///
-/// Returns the edge connects the given nodes.
-Edge edge(const Node& u, const Node& v) const {
-return Parent::edge(u, v);
-}
 };
 } //namespace lemon

changeset 366	80a4d0742e98
parent 365	37557a46e298
child 367	aa75d24ba7d0