Context Navigation

Back to Ticket #57

Ticket #57: full_a598f74ea87e.patch

File full_a598f74ea87e.patch, 9.5 KB (added by Peter Kovacs, 16 years ago)
Small improvements for full graphs

lemon/full_graph.h

# HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1225561910 -3600
# Node ID a598f74ea87ec18aec51a5352114625a961bcaa7
# Parent  37557a46e29874bd50b7c0e54c5595dc6bde36a2
Improvements related to full graphs (#57)

diff --git a/lemon/full_graph.h b/lemon/full_graph.h

-                      a
 #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 {
 …
     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;
 …
   /// 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
   /// neither add nor delete either arcs or nodes, and it needs just
+  /// the node number. This digraph type is completely static, so you
+  /// can neither add nor delete either arcs or nodes, and it needs just
   /// 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.
   ///
   /// \sa FullGraph
   class FullDigraph : public ExtendedFullDigraphBase {
 …
     /// \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
+    /// rebuild the digraph.  This cause that the maps of the digraph
+    /// will reallocated automatically and the previous values will be
+    /// lost.
+    /// Resizes the digraph. The function will fully destroy and
+    /// rebuild the digraph. This cause that the maps of the digraph will
+    /// reallocated automatically and the previous values will be lost.
     void resize(int n) {
       Parent::notifier(Arc()).clear();
       Parent::notifier(Node()).clear();
 …
     /// \brief Returns the node with the given index.
     ///
     /// Returns the node with the given index. Because it is a
     /// static size digraph the node's of the digraph can be indexed
     /// in the range <tt>[0..nodeNum()-1]</tt> and the index of
     /// the node can accessed by the \e index() member.
+    /// Returns the node with the given index. Since it is a static
+    /// digraph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
+    /// \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 digraph the node's of the digraph can be indexed
     /// in the range <tt>[0..nodeNum()-1]</tt> and the index of
     /// the node can accessed by the \e index() member.
+    /// Returns the index of the given node. Since it is a static
+    /// digraph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
+    /// \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);
+    }
 …
+    }
   public:
     Node operator()(int ix) const { return Node(ix); }
     int index(const Node& node) const { return node._id; }
 …
     class Edge {
       friend class FullGraphBase;
+      friend class Arc;
     protected:
       int _id;
 …
   ///
   /// 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
+  /// <tt>n(n-1)/2</tt>. It is completely static, so you can neither
+  /// therefore the number of edges in the graph is <tt>n(n-1)/2</tt>,
+  /// \f$n(n-1)/2\f$, \f$\frec{n(n-1)}{2}\f$.
+  /// This graph type is completely static, so you can neither
   /// add nor delete either edges or nodes, and it needs just constant
   /// space in memory.
   ///
   /// The \e FullDigraph and \e FullGraph classes are very similar,
   /// but there are two differences. While the \e FullDigraph class is
   /// conform just to the \ref concepts::Digraph "Digraph" concept,
   /// this class is conform to the \ref concepts::Graph "Graph"
   /// concept. In addition, the \e FullGraph class does not contain a
+  /// The \e FullGraph and \e FullDigraph classes are very similar,
+  /// but there are two differences. While the \e FullDigraph class
+  /// conforms only to the \ref concepts::Digraph "Digraph" concept,
+  /// this class conforms to the \ref concepts::Graph "Graph"
+  /// concept. In addition, the \e FullGraph class does not contain the
   /// loop arc from each node as the \e FullDigraph does.
   ///
   /// It also has an important extra feature that its maps are real
 …
     /// \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
+    /// the graph.  This cause that the maps of the graph will
+    /// reallocated automatically and the previous values will be
+    /// lost.
+    /// Resizes the graph. The function will fully destroy and
+    /// rebuild the graph. This cause that the maps of the graph will
+    /// reallocated automatically and the previous values will be lost.
     void resize(int n) {
       Parent::notifier(Arc()).clear();
       Parent::notifier(Edge()).clear();
 …
     /// \brief Returns the node with the given index.
     ///
     /// Returns the node with the given index. Because it is a static
     /// size graph the node's of the graph can be indexed in the range
     /// <tt>[0..nodeNum()-1]</tt> and the index of the node can
     /// accessed by the \e index() member.
+    /// Returns the node with the given index. Since it is a static
+    /// graph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
+    /// \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
     /// graph the node's of the graph can be indexed in the range
     /// <tt>[0..nodeNum()-1]</tt> and the index of the node can
     /// accessed by the \e index() member.
+    /// Returns the index of the given node. Since it is a static
+    /// graph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
+    /// \sa operator()
     int index(const Node& node) const { return Parent::index(node); }
+    /// \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.
+    /// \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& s, const Node& t) const {
       return Parent::arc(s, t);
+    }
 …
     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(); }
   };

test/digraph_test.cc

diff --git a/test/digraph_test.cc b/test/digraph_test.cc

-                      a
     checkConcept<ExtendableDigraphComponent<>, SmartDigraph>();
     checkConcept<ClearableDigraphComponent<>, SmartDigraph>();
+  }
 //  { // Checking FullDigraph
 //    checkConcept<Digraph, FullDigraph>();
 //  }
+  { // Checking FullDigraph
+    checkConcept<Digraph, FullDigraph>();
+  }
 //  { // Checking HyperCubeDigraph
 //    checkConcept<Digraph, HyperCubeDigraph>();
 //  }

Download in other formats:

Original Format