LEMON/LEMON-main Changeset - r149:2f7ae34e1333

Repositories » LEMON » LEMON-main

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r149:2f7ae34e1333

« 148:4e2581

154:f4e4db »

r149:2f7ae34e1333

Thu, 24 Apr 2008 14:53:09

[Not Reviewed]

0 comments (0 inline)

deba@inf.elte.hu
deba@inf.elte.hu

Item validity checking for ListGraph and SmartGraph

0 3 0

default

3 files changed with 211 insertions and 46 deletions:

lemon/list_graph.h

lemon/smart_graph.h

test/graph_test.cc

↑ Collapse diff ↑

lemon/list_graph.h

Show inline comments

@@ -107,193 +107,204 @@
+		    }
 		    void next(Node& node) const {
 		      node.id = nodes[node.id].next;
+		    }
 		    void first(Arc& arc) const {
 		      int n;
 		      for(n = first_node;
 			  n!=-1 && nodes[n].first_in == -1;
 			  n = nodes[n].next);
 		      arc.id = (n == -1) ? -1 : nodes[n].first_in;
+		    }
 		    void next(Arc& arc) const {
 		      if (arcs[arc.id].next_in != -1) {
 			arc.id = arcs[arc.id].next_in;
 		      } else {
 			int n;
 			for(n = nodes[arcs[arc.id].target].next;
 			  n!=-1 && nodes[n].first_in == -1;
 			  n = nodes[n].next);
 			arc.id = (n == -1) ? -1 : nodes[n].first_in;
+		      }
+		    }
 		    void firstOut(Arc &e, const Node& v) const {
 		      e.id = nodes[v.id].first_out;
+		    }
 		    void nextOut(Arc &e) const {
 		      e.id=arcs[e.id].next_out;
+		    }
 		    void firstIn(Arc &e, const Node& v) const {
 		      e.id = nodes[v.id].first_in;
+		    }
 		    void nextIn(Arc &e) const {
 		      e.id=arcs[e.id].next_in;
+		    }
 		    static int id(Node v) { return v.id; }
 		    static int id(Arc e) { return e.id; }
 		    static Node nodeFromId(int id) { return Node(id);}
 		    static Arc arcFromId(int id) { return Arc(id);}
 		    bool valid(Node n) const {
 		      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
 			nodes[n.id].prev != -2;
+		    }
 		    bool valid(Arc a) const {
 		      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
 			arcs[a.id].prev_in != -2;
+		    }
 		    Node addNode() {
 		      int n;
 		      if(first_free_node==-1) {
 			n = nodes.size();
 			nodes.push_back(NodeT());
 		      } else {
 			n = first_free_node;
 			first_free_node = nodes[n].next;
+		      }
 		      nodes[n].next = first_node;
 		      if(first_node != -1) nodes[first_node].prev = n;
 		      first_node = n;
 		      nodes[n].prev = -1;
 		      nodes[n].first_in = nodes[n].first_out = -1;
 		      return Node(n);
+		    }
 		    Arc addArc(Node u, Node v) {
 		      int n;
 		      if (first_free_arc == -1) {
 			n = arcs.size();
 			arcs.push_back(ArcT());
 		      } else {
 			n = first_free_arc;
 			first_free_arc = arcs[n].next_in;
+		      }
 		      arcs[n].source = u.id;
 		      arcs[n].target = v.id;
 		      arcs[n].next_out = nodes[u.id].first_out;
 		      if(nodes[u.id].first_out != -1) {
 			arcs[nodes[u.id].first_out].prev_out = n;
+		      }
 		      arcs[n].next_in = nodes[v.id].first_in;
 		      if(nodes[v.id].first_in != -1) {
 			arcs[nodes[v.id].first_in].prev_in = n;
+		      }
 		      arcs[n].prev_in = arcs[n].prev_out = -1;
 		      nodes[u.id].first_out = nodes[v.id].first_in = n;
 		      return Arc(n);
+		    }
 		    void erase(const Node& node) {
 		      int n = node.id;
 		      if(nodes[n].next != -1) {
 			nodes[nodes[n].next].prev = nodes[n].prev;
+		      }
 		      if(nodes[n].prev != -1) {
 			nodes[nodes[n].prev].next = nodes[n].next;
 		      } else {
 			first_node = nodes[n].next;
+		      }
 		      nodes[n].next = first_free_node;
 		      first_free_node = n;
 		      nodes[n].prev = -2;
+		    }
 		    void erase(const Arc& arc) {
 		      int n = arc.id;
 		      if(arcs[n].next_in!=-1) {
 			arcs[arcs[n].next_in].prev_in = arcs[n].prev_in;
+		      }
 		      if(arcs[n].prev_in!=-1) {
 			arcs[arcs[n].prev_in].next_in = arcs[n].next_in;
 		      } else {
 			nodes[arcs[n].target].first_in = arcs[n].next_in;
+		      }
 		      if(arcs[n].next_out!=-1) {
 			arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+		      }
 		      if(arcs[n].prev_out!=-1) {
 			arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
 		      } else {
 			nodes[arcs[n].source].first_out = arcs[n].next_out;
+		      }
 		      arcs[n].next_in = first_free_arc;
 		      first_free_arc = n;
+		      arcs[n].prev_in = -2;
+		    }
 		    void clear() {
 		      arcs.clear();
 		      nodes.clear();
 		      first_node = first_free_node = first_free_arc = -1;
+		    }
 		  protected:
 		    void changeTarget(Arc e, Node n)
+		    {
 		      if(arcs[e.id].next_in != -1)
 			arcs[arcs[e.id].next_in].prev_in = arcs[e.id].prev_in;
 		      if(arcs[e.id].prev_in != -1)
 			arcs[arcs[e.id].prev_in].next_in = arcs[e.id].next_in;
 		      else nodes[arcs[e.id].target].first_in = arcs[e.id].next_in;
 		      if (nodes[n.id].first_in != -1) {
 			arcs[nodes[n.id].first_in].prev_in = e.id;
+		      }
 		      arcs[e.id].target = n.id;
 		      arcs[e.id].prev_in = -1;
 		      arcs[e.id].next_in = nodes[n.id].first_in;
 		      nodes[n.id].first_in = e.id;
+		    }
 		    void changeSource(Arc e, Node n)
+		    {
 		      if(arcs[e.id].next_out != -1)
 			arcs[arcs[e.id].next_out].prev_out = arcs[e.id].prev_out;
 		      if(arcs[e.id].prev_out != -1)
 			arcs[arcs[e.id].prev_out].next_out = arcs[e.id].next_out;
 		      else nodes[arcs[e.id].source].first_out = arcs[e.id].next_out;
 		      if (nodes[n.id].first_out != -1) {
 			arcs[nodes[n.id].first_out].prev_out = e.id;
+		      }
 		      arcs[e.id].source = n.id;
 		      arcs[e.id].prev_out = -1;
 		      arcs[e.id].next_out = nodes[n.id].first_out;
 		      nodes[n.id].first_out = e.id;
+		    }
 		  };
 		  typedef DigraphExtender<ListDigraphBase> ExtendedListDigraphBase;
 		  /// \addtogroup graphs
 		  /// @{
 		  ///A general directed graph structure.
@@ -305,96 +316,116 @@
 		  ///It conforms to the \ref concepts::Digraph "Digraph concept" and it
 		  ///also provides several useful additional functionalities.
 		  ///Most of the member functions and nested classes are documented
 		  ///only in the concept class.
 		  ///
 		  ///An important extra feature of this digraph implementation is that
 		  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
 		  ///
 		  ///\sa concepts::Digraph
 		  class ListDigraph : public ExtendedListDigraphBase {
 		  private:
 		    ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.
 		    ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.
 		    ///
 		    ListDigraph(const ListDigraph &) :ExtendedListDigraphBase() {};
 		    ///\brief Assignment of ListDigraph to another one is \e not allowed.
 		    ///Use copyDigraph() instead.
 		    ///Assignment of ListDigraph to another one is \e not allowed.
 		    ///Use copyDigraph() instead.
 		    void operator=(const ListDigraph &) {}
 		  public:
 		    typedef ExtendedListDigraphBase Parent;
 		    /// Constructor
 		    /// Constructor.
 		    ///
 		    ListDigraph() {}
 		    ///Add a new node to the digraph.
 		    ///Add a new node to the digraph.
 		    ///\return the new node.
 		    Node addNode() { return Parent::addNode(); }
 		    ///Add a new arc to the digraph.
 		    ///Add a new arc to the digraph with source node \c s
 		    ///and target node \c t.
 		    ///\return the new arc.
 		    Arc addArc(const Node& s, const Node& t) {
 		      return Parent::addArc(s, t);
+		    }
 		    /// Node validity check
 		    /// This function gives back true if the given node is valid,
 		    /// ie. it is a real node of the graph.
 		    ///
 		    /// \warning A Node pointing to a removed item
 		    /// could become valid again later if new nodes are
 		    /// added to the graph.
 		    bool valid(Node n) const { return Parent::valid(n); }
 		    /// Arc validity check
 		    /// This function gives back true if the given arc is valid,
 		    /// ie. it is a real arc of the graph.
 		    ///
 		    /// \warning An Arc pointing to a removed item
 		    /// could become valid again later if new nodes are
 		    /// added to the graph.
 		    bool valid(Arc a) const { return Parent::valid(a); }
 		    /// Change the target of \c e to \c n
 		    /// Change the target of \c e to \c n
 		    ///
 		    ///\note The <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s referencing
 		    ///the changed arc remain valid. However <tt>InArcIt</tt>s are
 		    ///invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the Snapshot
 		    ///feature.
 		    void changeTarget(Arc e, Node n) {
 		      Parent::changeTarget(e,n);
+		    }
 		    /// Change the source of \c e to \c n
 		    /// Change the source of \c e to \c n
 		    ///
 		    ///\note The <tt>ArcIt</tt>s and <tt>InArcIt</tt>s referencing
 		    ///the changed arc remain valid. However <tt>OutArcIt</tt>s are
 		    ///invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the Snapshot
 		    ///feature.
 		    void changeSource(Arc e, Node n) {
 		      Parent::changeSource(e,n);
+		    }
 		    /// Invert the direction of an arc.
 		    ///\note The <tt>ArcIt</tt>s referencing the changed arc remain
 		    ///valid. However <tt>OutArcIt</tt>s and <tt>InArcIt</tt>s are
 		    ///invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the Snapshot
 		    ///feature.
 		    void reverseArc(Arc e) {
 		      Node t=target(e);
 		      changeTarget(e,source(e));
 		      changeSource(e,t);
+		    }
 		    /// Reserve memory for nodes.
 		    /// Using this function it is possible to avoid the superfluous memory
 		    /// allocation: if you know that the digraph you want to build will
 		    /// be very large (e.g. it will contain millions of nodes and/or arcs)
 		    /// then it is worth reserving space for this amount before starting
 		    /// to build the digraph.
@@ -900,192 +931,209 @@
 		      e.id = -1;
+		    }
 		    void firstOut(Arc &e, const Node& v) const {
 		      e.id = nodes[v.id].first_out;
+		    }
 		    void nextOut(Arc &e) const {
 		      e.id = arcs[e.id].next_out;
+		    }
 		    void firstIn(Arc &e, const Node& v) const {
 		      e.id = ((nodes[v.id].first_out) ^ 1);
 		      if (e.id == -2) e.id = -1;
+		    }
 		    void nextIn(Arc &e) const {
 		      e.id = ((arcs[e.id ^ 1].next_out) ^ 1);
 		      if (e.id == -2) e.id = -1;
+		    }
 		    void firstInc(Edge &e, bool& d, const Node& v) const {
 		      int a = nodes[v.id].first_out;
 		      if (a != -1 ) {
 		        e.id = a / 2;
 		        d = ((a & 1) == 1);
 		      } else {
 		        e.id = -1;
 		        d = true;
+		      }
+		    }
 		    void nextInc(Edge &e, bool& d) const {
 		      int a = (arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
 		      if (a != -1 ) {
 		        e.id = a / 2;
 		        d = ((a & 1) == 1);
 		      } else {
 		        e.id = -1;
 		        d = true;
+		      }
+		    }
 		    static int id(Node v) { return v.id; }
 		    static int id(Arc e) { return e.id; }
 		    static int id(Edge e) { return e.id; }
 		    static Node nodeFromId(int id) { return Node(id);}
 		    static Arc arcFromId(int id) { return Arc(id);}
 		    static Edge edgeFromId(int id) { return Edge(id);}
 		    bool valid(Node n) const {
 		      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
 			nodes[n.id].prev != -2;
+		    }
 		    bool valid(Arc a) const {
 		      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
 			arcs[a.id].prev_out != -2;
+		    }
 		    bool valid(Edge e) const {
 		      return e.id >= 0 && 2 * e.id < static_cast<int>(arcs.size()) &&
 			arcs[2 * e.id].prev_out != -2;
+		    }
 		    Node addNode() {
 		      int n;
 		      if(first_free_node==-1) {
 			n = nodes.size();
 			nodes.push_back(NodeT());
 		      } else {
 			n = first_free_node;
 			first_free_node = nodes[n].next;
+		      }
 		      nodes[n].next = first_node;
 		      if (first_node != -1) nodes[first_node].prev = n;
 		      first_node = n;
 		      nodes[n].prev = -1;
 		      nodes[n].first_out = -1;
 		      return Node(n);
+		    }
 		    Edge addEdge(Node u, Node v) {
 		      int n;
 		      if (first_free_arc == -1) {
 			n = arcs.size();
 			arcs.push_back(ArcT());
 			arcs.push_back(ArcT());
 		      } else {
 			n = first_free_arc;
 			first_free_arc = arcs[n].next_out;
+		      }
 		      arcs[n].target = u.id;
 		      arcs[n | 1].target = v.id;
 		      arcs[n].next_out = nodes[v.id].first_out;
 		      if (nodes[v.id].first_out != -1) {
 			arcs[nodes[v.id].first_out].prev_out = n;
+		      }
 		      arcs[n].prev_out = -1;
 		      nodes[v.id].first_out = n;
 		      arcs[n | 1].next_out = nodes[u.id].first_out;
 		      if (nodes[u.id].first_out != -1) {
 			arcs[nodes[u.id].first_out].prev_out = (n | 1);
+		      }
 		      arcs[n | 1].prev_out = -1;
 		      nodes[u.id].first_out = (n | 1);
 		      return Edge(n / 2);
+		    }
 		    void erase(const Node& node) {
 		      int n = node.id;
 		      if(nodes[n].next != -1) {
 			nodes[nodes[n].next].prev = nodes[n].prev;
+		      }
 		      if(nodes[n].prev != -1) {
 			nodes[nodes[n].prev].next = nodes[n].next;
 		      } else {
 			first_node = nodes[n].next;
+		      }
 		      nodes[n].next = first_free_node;
 		      first_free_node = n;
+		      nodes[n].prev = -2;
+		    }
 		    void erase(const Edge& edge) {
 		      int n = edge.id * 2;
 		      if (arcs[n].next_out != -1) {
 			arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+		      }
 		      if (arcs[n].prev_out != -1) {
 			arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
 		      } else {
 			nodes[arcs[n | 1].target].first_out = arcs[n].next_out;
+		      }
 		      if (arcs[n | 1].next_out != -1) {
 			arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
+		      }
 		      if (arcs[n | 1].prev_out != -1) {
 			arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;
 		      } else {
 			nodes[arcs[n].target].first_out = arcs[n | 1].next_out;
+		      }
 		      arcs[n].next_out = first_free_arc;
 		      first_free_arc = n;
 		      arcs[n].prev_out = -2;
 		      arcs[n | 1].prev_out = -2;
+		    }
 		    void clear() {
 		      arcs.clear();
 		      nodes.clear();
 		      first_node = first_free_node = first_free_arc = -1;
+		    }
 		  protected:
 		    void changeTarget(Edge e, Node n) {
 		      if(arcs[2 * e.id].next_out != -1) {
 			arcs[arcs[2 * e.id].next_out].prev_out = arcs[2 * e.id].prev_out;
+		      }
 		      if(arcs[2 * e.id].prev_out != -1) {
 			arcs[arcs[2 * e.id].prev_out].next_out =
 		          arcs[2 * e.id].next_out;
 		      } else {
 		        nodes[arcs[(2 * e.id) | 1].target].first_out =
 		          arcs[2 * e.id].next_out;
+		      }
 		      if (nodes[n.id].first_out != -1) {
 			arcs[nodes[n.id].first_out].prev_out = 2 * e.id;
+		      }
 		      arcs[(2 * e.id) | 1].target = n.id;
 		      arcs[2 * e.id].prev_out = -1;
 		      arcs[2 * e.id].next_out = nodes[n.id].first_out;
 		      nodes[n.id].first_out = 2 * e.id;
+		    }
 		    void changeSource(Edge e, Node n) {
 		      if(arcs[(2 * e.id) | 1].next_out != -1) {
 			arcs[arcs[(2 * e.id) | 1].next_out].prev_out =
 		          arcs[(2 * e.id) | 1].prev_out;
+		      }
 		      if(arcs[(2 * e.id) | 1].prev_out != -1) {
 			arcs[arcs[(2 * e.id) | 1].prev_out].next_out =
 		          arcs[(2 * e.id) | 1].next_out;
 		      } else {
 		        nodes[arcs[2 * e.id].target].first_out =
 		          arcs[(2 * e.id) | 1].next_out;
+		      }
 		      if (nodes[n.id].first_out != -1) {
 			arcs[nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
+		      }
@@ -1112,96 +1160,123 @@
 		  ///It conforms to the \ref concepts::Graph "Graph concept" and it
 		  ///also provides several useful additional functionalities.
 		  ///Most of the member functions and nested classes are documented
 		  ///only in the concept class.
 		  ///
 		  ///An important extra feature of this graph implementation is that
 		  ///its maps are real \ref concepts::ReferenceMap "reference map"s.
 		  ///
 		  ///\sa concepts::Graph
 		  class ListGraph : public ExtendedListGraphBase {
 		  private:
 		    ///ListGraph is \e not copy constructible. Use copyGraph() instead.
 		    ///ListGraph is \e not copy constructible. Use copyGraph() instead.
 		    ///
 		    ListGraph(const ListGraph &) :ExtendedListGraphBase()  {};
 		    ///\brief Assignment of ListGraph to another one is \e not allowed.
 		    ///Use copyGraph() instead.
 		    ///Assignment of ListGraph to another one is \e not allowed.
 		    ///Use copyGraph() instead.
 		    void operator=(const ListGraph &) {}
 		  public:
 		    /// Constructor
 		    /// Constructor.
 		    ///
 		    ListGraph() {}
 		    typedef ExtendedListGraphBase Parent;
 		    typedef Parent::OutArcIt IncEdgeIt;
 		    /// \brief Add a new node to the graph.
 		    ///
 		    /// Add a new node to the graph.
 		    /// \return the new node.
 		    Node addNode() { return Parent::addNode(); }
 		    /// \brief Add a new edge to the graph.
 		    ///
 		    /// Add a new edge to the graph with source node \c s
 		    /// and target node \c t.
 		    /// \return the new edge.
 		    Edge addEdge(const Node& s, const Node& t) {
 		      return Parent::addEdge(s, t);
+		    }
 		    /// Node validity check
 		    /// This function gives back true if the given node is valid,
 		    /// ie. it is a real node of the graph.
 		    ///
 		    /// \warning A Node pointing to a removed item
 		    /// could become valid again later if new nodes are
 		    /// added to the graph.
 		    bool valid(Node n) const { return Parent::valid(n); }
 		    /// Arc validity check
 		    /// This function gives back true if the given arc is valid,
 		    /// ie. it is a real arc of the graph.
 		    ///
 		    /// \warning An Arc pointing to a removed item
 		    /// could become valid again later if new edges are
 		    /// added to the graph.
 		    bool valid(Arc a) const { return Parent::valid(a); }
 		    /// Edge validity check
 		    /// This function gives back true if the given edge is valid,
 		    /// ie. it is a real arc of the graph.
 		    ///
 		    /// \warning A Edge pointing to a removed item
 		    /// could become valid again later if new edges are
 		    /// added to the graph.
 		    bool valid(Edge e) const { return Parent::valid(e); }
 		    /// \brief Change the source of \c e to \c n
 		    ///
 		    /// This function changes the source of \c e to \c n.
 		    ///
 		    ///\note The <tt>ArcIt</tt>s and <tt>InArcIt</tt>s
 		    ///referencing the changed arc remain
 		    ///valid. However <tt>OutArcIt</tt>s are invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the
 		    ///Snapshot feature.
 		    void changeSource(Edge e, Node n) {
 		      Parent::changeSource(e,n);
+		    }
 		    /// \brief Change the target of \c e to \c n
 		    ///
 		    /// This function changes the target of \c e to \c n.
 		    ///
 		    /// \note The <tt>ArcIt</tt>s referencing the changed arc remain
 		    /// valid. However the other iterators may be invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the
 		    ///Snapshot feature.
 		    void changeTarget(Edge e, Node n) {
 		      Parent::changeTarget(e,n);
+		    }
 		    /// \brief Change the source of \c e to \c n
 		    ///
 		    /// This function changes the source of \c e to \c n.
 		    /// It also changes the proper node of the represented edge.
 		    ///
 		    ///\note The <tt>ArcIt</tt>s and <tt>InArcIt</tt>s
 		    ///referencing the changed arc remain
 		    ///valid. However <tt>OutArcIt</tt>s are invalidated.
 		    ///
 		    ///\warning This functionality cannot be used together with the
 		    ///Snapshot feature.
 		    void changeSource(Arc e, Node n) {
 		      if (Parent::direction(e)) {
 		        Parent::changeSource(e,n);
 		      } else {
 		        Parent::changeTarget(e,n);
+		      }
+		    }
 		    /// \brief Change the target of \c e to \c n
 		    ///
 		    /// This function changes the target of \c e to \c n.
 		    /// It also changes the proper node of the represented edge.
 		    ///

lemon/smart_graph.h

Show inline comments

@@ -70,96 +70,103 @@
 		    SmartDigraphBase() : nodes(), arcs() { }
 		    SmartDigraphBase(const SmartDigraphBase &_g)
 		      : nodes(_g.nodes), arcs(_g.arcs) { }
 		    typedef True NodeNumTag;
 		    typedef True EdgeNumTag;
 		    int nodeNum() const { return nodes.size(); }
 		    int arcNum() const { return arcs.size(); }
 		    int maxNodeId() const { return nodes.size()-1; }
 		    int maxArcId() const { return arcs.size()-1; }
 		    Node addNode() {
 		      int n = nodes.size();
 		      nodes.push_back(NodeT());
 		      nodes[n].first_in = -1;
 		      nodes[n].first_out = -1;
 		      return Node(n);
+		    }
 		    Arc addArc(Node u, Node v) {
 		      int n = arcs.size();
 		      arcs.push_back(ArcT());
 		      arcs[n].source = u._id;
 		      arcs[n].target = v._id;
 		      arcs[n].next_out = nodes[u._id].first_out;
 		      arcs[n].next_in = nodes[v._id].first_in;
 		      nodes[u._id].first_out = nodes[v._id].first_in = n;
 		      return Arc(n);
+		    }
 		    void clear() {
 		      arcs.clear();
 		      nodes.clear();
+		    }
 		    Node source(Arc a) const { return Node(arcs[a._id].source); }
 		    Node target(Arc a) const { return Node(arcs[a._id].target); }
 		    static int id(Node v) { return v._id; }
 		    static int id(Arc a) { return a._id; }
 		    static Node nodeFromId(int id) { return Node(id);}
 		    static Arc arcFromId(int id) { return Arc(id);}
 		    bool valid(Node n) const {
 		      return n._id >= 0 && n._id < static_cast<int>(nodes.size());
+		    }
 		    bool valid(Arc a) const {
 		      return a._id >= 0 && a._id < static_cast<int>(arcs.size());
+		    }
 		    class Node {
 		      friend class SmartDigraphBase;
 		      friend class SmartDigraph;
 		    protected:
 		      int _id;
 		      explicit Node(int id) : _id(id) {}
 		    public:
 		      Node() {}
 		      Node (Invalid) : _id(-1) {}
 		      bool operator==(const Node i) const {return _id == i._id;}
 		      bool operator!=(const Node i) const {return _id != i._id;}
 		      bool operator<(const Node i) const {return _id < i._id;}
 		    };
 		    class Arc {
 		      friend class SmartDigraphBase;
 		      friend class SmartDigraph;
 		    protected:
 		      int _id;
 		      explicit Arc(int id) : _id(id) {}
 		    public:
 		      Arc() { }
 		      Arc (Invalid) : _id(-1) {}
 		      bool operator==(const Arc i) const {return _id == i._id;}
 		      bool operator!=(const Arc i) const {return _id != i._id;}
 		      bool operator<(const Arc i) const {return _id < i._id;}
 		    };
 		    void first(Node& node) const {
 		      node._id = nodes.size() - 1;
+		    }
 		    static void next(Node& node) {
 		      --node._id;
+		    }
 		    void first(Arc& arc) const {
 		      arc._id = arcs.size() - 1;
+		    }
 		    static void next(Arc& arc) {
 		      --arc._id;
+		    }
 		    void firstOut(Arc& arc, const Node& node) const {
@@ -216,96 +223,114 @@
 		    ///Use DigraphCopy() instead.
 		    void operator=(const SmartDigraph &) {}
 		  public:
 		    /// Constructor
 		    /// Constructor.
 		    ///
 		    SmartDigraph() {};
 		    ///Add a new node to the digraph.
 		    /// \return the new node.
 		    ///
 		    Node addNode() { return Parent::addNode(); }
 		    ///Add a new arc to the digraph.
 		    ///Add a new arc to the digraph with source node \c s
 		    ///and target node \c t.
 		    ///\return the new arc.
 		    Arc addArc(const Node& s, const Node& t) {
 		      return Parent::addArc(s, t);
+		    }
 		    /// \brief Using this it is possible to avoid the superfluous memory
 		    /// allocation.
 		    /// Using this it is possible to avoid the superfluous memory
 		    /// allocation: if you know that the digraph you want to build will
 		    /// be very large (e.g. it will contain millions of nodes and/or arcs)
 		    /// then it is worth reserving space for this amount before starting
 		    /// to build the digraph.
 		    /// \sa reserveArc
 		    void reserveNode(int n) { nodes.reserve(n); };
 		    /// \brief Using this it is possible to avoid the superfluous memory
 		    /// allocation.
 		    /// Using this it is possible to avoid the superfluous memory
 		    /// allocation: if you know that the digraph you want to build will
 		    /// be very large (e.g. it will contain millions of nodes and/or arcs)
 		    /// then it is worth reserving space for this amount before starting
 		    /// to build the digraph.
 		    /// \sa reserveNode
 		    void reserveArc(int m) { arcs.reserve(m); };
 		    /// \brief Node validity check
 		    ///
 		    /// This function gives back true if the given node is valid,
 		    /// ie. it is a real node of the graph.
 		    ///
 		    /// \warning A removed node (using Snapshot) could become valid again
 		    /// when new nodes are added to the graph.
 		    bool valid(Node n) const { return Parent::valid(n); }
 		    /// \brief Arc validity check
 		    ///
 		    /// This function gives back true if the given arc is valid,
 		    /// ie. it is a real arc of the graph.
 		    ///
 		    /// \warning A removed arc (using Snapshot) could become valid again
 		    /// when new arcs are added to the graph.
 		    bool valid(Arc a) const { return Parent::valid(a); }
 		    ///Clear the digraph.
 		    ///Erase all the nodes and arcs from the digraph.
 		    ///
 		    void clear() {
 		      Parent::clear();
+		    }
 		    ///Split a node.
 		    ///This function splits a node. First a new node is added to the digraph,
 		    ///then the source of each outgoing arc of \c n is moved to this new node.
 		    ///If \c connect is \c true (this is the default value), then a new arc
 		    ///from \c n to the newly created node is also added.
 		    ///\return The newly created node.
 		    ///
 		    ///\note The <tt>Arc</tt>s
 		    ///referencing a moved arc remain
 		    ///valid. However <tt>InArc</tt>'s and <tt>OutArc</tt>'s
 		    ///may be invalidated.
 		    ///\warning This functionality cannot be used together with the Snapshot
 		    ///feature.
 		    ///\todo It could be implemented in a bit faster way.
 		    Node split(Node n, bool connect = true)
+		    {
 		      Node b = addNode();
 		      nodes[b._id].first_out=nodes[n._id].first_out;
 		      nodes[n._id].first_out=-1;
 		      for(int i=nodes[b._id].first_out;i!=-1;i++) arcs[i].source=b._id;
 		      if(connect) addArc(n,b);
 		      return b;
+		    }
 		  public:
 		    class Snapshot;
 		  protected:
 		    void restoreSnapshot(const Snapshot &s)
+		    {
 		      while(s.arc_num<arcs.size()) {
 		        Arc arc = arcFromId(arcs.size()-1);
 			Parent::notifier(Arc()).erase(arc);
 			nodes[arcs.back().source].first_out=arcs.back().next_out;
 			nodes[arcs.back().target].first_in=arcs.back().next_in;
 			arcs.pop_back();
+		      }
@@ -505,188 +530,225 @@
 		      --arc._id;
+		    }
 		    void firstOut(Arc &arc, const Node& v) const {
 		      arc._id = nodes[v._id].first_out;
+		    }
 		    void nextOut(Arc &arc) const {
 		      arc._id = arcs[arc._id].next_out;
+		    }
 		    void firstIn(Arc &arc, const Node& v) const {
 		      arc._id = ((nodes[v._id].first_out) ^ 1);
 		      if (arc._id == -2) arc._id = -1;
+		    }
 		    void nextIn(Arc &arc) const {
 		      arc._id = ((arcs[arc._id ^ 1].next_out) ^ 1);
 		      if (arc._id == -2) arc._id = -1;
+		    }
 		    void firstInc(Edge &arc, bool& d, const Node& v) const {
 		      int de = nodes[v._id].first_out;
 		      if (de != -1) {
 		        arc._id = de / 2;
 		        d = ((de & 1) == 1);
 		      } else {
 		        arc._id = -1;
 		        d = true;
+		      }
+		    }
 		    void nextInc(Edge &arc, bool& d) const {
 		      int de = (arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
 		      if (de != -1) {
 		        arc._id = de / 2;
 		        d = ((de & 1) == 1);
 		      } else {
 		        arc._id = -1;
 		        d = true;
+		      }
+		    }
 		    static int id(Node v) { return v._id; }
 		    static int id(Arc e) { return e._id; }
 		    static int id(Edge e) { return e._id; }
 		    static Node nodeFromId(int id) { return Node(id);}
 		    static Arc arcFromId(int id) { return Arc(id);}
 		    static Edge edgeFromId(int id) { return Edge(id);}
 		    bool valid(Node n) const {
 		      return n._id >= 0 && n._id < static_cast<int>(nodes.size());
+		    }
 		    bool valid(Arc a) const {
 		      return a._id >= 0 && a._id < static_cast<int>(arcs.size());
+		    }
 		    bool valid(Edge e) const {
 		      return e._id >= 0 && 2 * e._id < static_cast<int>(arcs.size());
+		    }
 		    Node addNode() {
 		      int n = nodes.size();
 		      nodes.push_back(NodeT());
 		      nodes[n].first_out = -1;
 		      return Node(n);
+		    }
 		    Edge addEdge(Node u, Node v) {
 		      int n = arcs.size();
 		      arcs.push_back(ArcT());
 		      arcs.push_back(ArcT());
 		      arcs[n].target = u._id;
 		      arcs[n | 1].target = v._id;
 		      arcs[n].next_out = nodes[v._id].first_out;
 		      nodes[v._id].first_out = n;
 		      arcs[n | 1].next_out = nodes[u._id].first_out;
 		      nodes[u._id].first_out = (n | 1);
 		      return Edge(n / 2);
+		    }
 		    void clear() {
 		      arcs.clear();
 		      nodes.clear();
+		    }
 		  };
 		  typedef GraphExtender<SmartGraphBase> ExtendedSmartGraphBase;
 		  /// \ingroup graphs
 		  ///
 		  /// \brief A smart undirected graph class.
 		  ///
 		  /// This is a simple and fast graph implementation.
 		  /// It is also quite memory efficient, but at the price
 		  /// that <b> it does support only limited (only stack-like)
 		  /// node and arc deletions</b>.
 		  /// Except from this it conforms to
 		  /// the \ref concepts::Graph "Graph concept".
 		  ///
 		  /// It also has an
 		  /// important extra feature that
 		  /// its maps are real \ref concepts::ReferenceMap "reference map"s.
 		  ///
 		  /// \sa concepts::Graph.
 		  ///
 		  class SmartGraph : public ExtendedSmartGraphBase {
 		  private:
 		    ///SmartGraph is \e not copy constructible. Use GraphCopy() instead.
 		    ///SmartGraph is \e not copy constructible. Use GraphCopy() instead.
 		    ///
 		    SmartGraph(const SmartGraph &) : ExtendedSmartGraphBase() {};
 		    ///\brief Assignment of SmartGraph to another one is \e not allowed.
 		    ///Use GraphCopy() instead.
 		    ///Assignment of SmartGraph to another one is \e not allowed.
 		    ///Use GraphCopy() instead.
 		    void operator=(const SmartGraph &) {}
 		  public:
 		    typedef ExtendedSmartGraphBase Parent;
 		    /// Constructor
 		    /// Constructor.
 		    ///
 		    SmartGraph() {}
 		    ///Add a new node to the graph.
 		    /// \return the new node.
 		    ///
 		    Node addNode() { return Parent::addNode(); }
 		    ///Add a new edge to the graph.
 		    ///Add a new edge to the graph with node \c s
 		    ///and \c t.
 		    ///\return the new edge.
 		    Edge addEdge(const Node& s, const Node& t) {
 		      return Parent::addEdge(s, t);
+		    }
 		    /// \brief Node validity check
 		    ///
 		    /// This function gives back true if the given node is valid,
 		    /// ie. it is a real node of the graph.
 		    ///
 		    /// \warning A removed node (using Snapshot) could become valid again
 		    /// when new nodes are added to the graph.
 		    bool valid(Node n) const { return Parent::valid(n); }
 		    /// \brief Arc validity check
 		    ///
 		    /// This function gives back true if the given arc is valid,
 		    /// ie. it is a real arc of the graph.
 		    ///
 		    /// \warning A removed arc (using Snapshot) could become valid again
 		    /// when new edges are added to the graph.
 		    bool valid(Arc a) const { return Parent::valid(a); }
 		    /// \brief Edge validity check
 		    ///
 		    /// This function gives back true if the given edge is valid,
 		    /// ie. it is a real edge of the graph.
 		    ///
 		    /// \warning A removed edge (using Snapshot) could become valid again
 		    /// when new edges are added to the graph.
 		    bool valid(Edge e) const { return Parent::valid(e); }
 		    ///Clear the graph.
 		    ///Erase all the nodes and edges from the graph.
 		    ///
 		    void clear() {
 		      Parent::clear();
+		    }
 		  public:
 		    class Snapshot;
 		  protected:
 		    void saveSnapshot(Snapshot &s)
+		    {
 		      s._graph = this;
 		      s.node_num = nodes.size();
 		      s.arc_num = arcs.size();
+		    }
 		    void restoreSnapshot(const Snapshot &s)
+		    {
 		      while(s.arc_num<arcs.size()) {
 		        int n=arcs.size()-1;
 		        Edge arc=edgeFromId(n/2);
 			Parent::notifier(Edge()).erase(arc);
 		        std::vector<Arc> dir;
 		        dir.push_back(arcFromId(n));
 		        dir.push_back(arcFromId(n-1));
 			Parent::notifier(Arc()).erase(dir);
 			nodes[arcs[n].target].first_out=arcs[n].next_out;
 			nodes[arcs[n-1].target].first_out=arcs[n-1].next_out;
 			arcs.pop_back();
 			arcs.pop_back();
+		      }
 		      while(s.node_num<nodes.size()) {
 		        int n=nodes.size()-1;
 		        Node node = nodeFromId(n);
 			Parent::notifier(Node()).erase(node);
 			nodes.pop_back();
+		      }
+		    }
 		  public:
 		    ///Class to make a snapshot of the digraph and to restrore to it later.

test/graph_test.cc

Show inline comments

 		/* -*- C++ -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 *
 		 * Copyright (C) 2003-2008
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#include <lemon/concepts/graph.h>
 		#include <lemon/list_graph.h>
 		#include <lemon/smart_graph.h>
 		// #include <lemon/full_graph.h>
 		// #include <lemon/grid_graph.h>
-		//#include <lemon/graph_utils.h>
 		#include <lemon/graph_utils.h>
 		#include "test_tools.h"
 		using namespace lemon;
 		using namespace lemon::concepts;
 		void check_concepts() {
 		  { // checking digraph components
 		    checkConcept<BaseGraphComponent, BaseGraphComponent >();
 		    checkConcept<IDableGraphComponent<>,
 		      IDableGraphComponent<> >();
 		    checkConcept<IterableGraphComponent<>,
 		      IterableGraphComponent<> >();
 		    checkConcept<MappableGraphComponent<>,
 		      MappableGraphComponent<> >();
+		  }
+		  {
 		    checkConcept<Graph, ListGraph>();
 		    checkConcept<Graph, SmartGraph>();
 		//     checkConcept<Graph, FullGraph>();
 		//     checkConcept<Graph, Graph>();
 		//     checkConcept<Graph, GridGraph>();
+		  }
+		}
 		template <typename Graph>
 		void check_item_counts(Graph &g, int n, int e) {
 		  int nn = 0;
 		  for (typename Graph::NodeIt it(g); it != INVALID; ++it) {
 		    ++nn;
+		  }
 		  check(nn == n, "Wrong node number.");
 		  //  check(countNodes(g) == n, "Wrong node number.");
 		  int ee = 0;
 		  for (typename Graph::ArcIt it(g); it != INVALID; ++it) {
 		    ++ee;
+		  }
 		  check(ee == 2*e, "Wrong arc number.");
 		  //  check(countArcs(g) == 2*e, "Wrong arc number.");
 		  int uee = 0;
 		  for (typename Graph::EdgeIt it(g); it != INVALID; ++it) {
 		    ++uee;
+		  }
 		  check(uee == e, "Wrong edge number.");
 		  //  check(countEdges(g) == e, "Wrong edge number.");
+		}
 		template <typename Graph>
-		void print_items(Graph &g) {
+		void check_graph_counts() {
 		  typedef typename Graph::NodeIt NodeIt;
 		  typedef typename Graph::EdgeIt EdgeIt;
 		  typedef typename Graph::ArcIt ArcIt;
 		  std::cout << "Nodes" << std::endl;
 		  int i=0;
 		  for(NodeIt it(g); it!=INVALID; ++it, ++i) {
 		    std::cout << "  " << i << ": " << g.id(it) << std::endl;
+		  }
 		  std::cout << "Edge" << std::endl;
 		  i=0;
 		  for(EdgeIt it(g); it!=INVALID; ++it, ++i) {
 		    std::cout << "  " << i << ": " << g.id(it)
 			 << " (" << g.id(g.source(it)) << ", " << g.id(g.target(it))
 			 << ")" << std::endl;
+		  }
 		  std::cout << "Arc" << std::endl;
 		  i=0;
 		  for(ArcIt it(g); it!=INVALID; ++it, ++i) {
 		    std::cout << "  " << i << ": " << g.id(it)
 			 << " (" << g.id(g.source(it)) << ", " << g.id(g.target(it))
 			 << ")" << std::endl;
+		  }
+		}
 		template <typename Graph>
 		void check_graph() {
 		  typedef typename Graph::Node Node;
 		  typedef typename Graph::Edge Edge;
 		  typedef typename Graph::Arc Arc;
 		  typedef typename Graph::NodeIt NodeIt;
 		  typedef typename Graph::EdgeIt EdgeIt;
 		  typedef typename Graph::ArcIt ArcIt;
 		  TEMPLATE_GRAPH_TYPEDEFS(Graph);
 		  Graph g;
 		  check_item_counts(g,0,0);
 		  Node
 		    n1 = g.addNode(),
 		    n2 = g.addNode(),
 		    n3 = g.addNode();
 		  Edge
 		    e1 = g.addEdge(n1, n2),
 		    e2 = g.addEdge(n2, n3);
 		  // print_items(g);
 		  check_item_counts(g,3,2);
+		}
 		template <typename Graph>
 		void check_graph_validity() {
 		  TEMPLATE_GRAPH_TYPEDEFS(Graph);
 		  Graph g;
 		  check_item_counts(g,0,0);
 		  Node
 		    n1 = g.addNode(),
 		    n2 = g.addNode(),
 		    n3 = g.addNode();
 		  Edge
 		    e1 = g.addEdge(n1, n2),
 		    e2 = g.addEdge(n2, n3);
 		  check(g.valid(n1), "Validity check");
 		  check(g.valid(e1), "Validity check");
 		  check(g.valid(g.direct(e1, true)), "Validity check");
 		  check(!g.valid(g.nodeFromId(-1)), "Validity check");
 		  check(!g.valid(g.edgeFromId(-1)), "Validity check");
 		  check(!g.valid(g.arcFromId(-1)), "Validity check");
+		}
 		template <typename Graph>
 		void check_graph_validity_erase() {
 		  TEMPLATE_GRAPH_TYPEDEFS(Graph);
 		  Graph g;
 		  check_item_counts(g,0,0);
 		  Node
 		    n1 = g.addNode(),
 		    n2 = g.addNode(),
 		    n3 = g.addNode();
 		  Edge
 		    e1 = g.addEdge(n1, n2),
 		    e2 = g.addEdge(n2, n3);
 		  check(g.valid(n1), "Validity check");
 		  check(g.valid(e1), "Validity check");
 		  check(g.valid(g.direct(e1, true)), "Validity check");
 		  g.erase(n1);
 		  check(!g.valid(n1), "Validity check");
 		  check(g.valid(n2), "Validity check");
 		  check(g.valid(n3), "Validity check");
 		  check(!g.valid(e1), "Validity check");
 		  check(g.valid(e2), "Validity check");
 		  check(!g.valid(g.nodeFromId(-1)), "Validity check");
 		  check(!g.valid(g.edgeFromId(-1)), "Validity check");
 		  check(!g.valid(g.arcFromId(-1)), "Validity check");
+		}
 		// void checkGridGraph(const GridGraph& g, int w, int h) {
 		//   check(g.width() == w, "Wrong width");
 		//   check(g.height() == h, "Wrong height");
 		//   for (int i = 0; i < w; ++i) {
 		//     for (int j = 0; j < h; ++j) {
 		//       check(g.col(g(i, j)) == i, "Wrong col");
 		//       check(g.row(g(i, j)) == j, "Wrong row");
 		//     }
 		//   }
 		//   for (int i = 0; i < w; ++i) {
 		//     for (int j = 0; j < h - 1; ++j) {
 		//       check(g.source(g.down(g(i, j))) == g(i, j), "Wrong down");
 		//       check(g.target(g.down(g(i, j))) == g(i, j + 1), "Wrong down");
 		//     }
 		//     check(g.down(g(i, h - 1)) == INVALID, "Wrong down");
 		//   }
 		//   for (int i = 0; i < w; ++i) {
 		//     for (int j = 1; j < h; ++j) {
 		//       check(g.source(g.up(g(i, j))) == g(i, j), "Wrong up");
 		//       check(g.target(g.up(g(i, j))) == g(i, j - 1), "Wrong up");
 		//     }
 		//     check(g.up(g(i, 0)) == INVALID, "Wrong up");
 		//   }
 		//   for (int j = 0; j < h; ++j) {
 		//     for (int i = 0; i < w - 1; ++i) {
 		//       check(g.source(g.right(g(i, j))) == g(i, j), "Wrong right");
 		//       check(g.target(g.right(g(i, j))) == g(i + 1, j), "Wrong right");
 		//     }
 		//     check(g.right(g(w - 1, j)) == INVALID, "Wrong right");
 		//   }
 		//   for (int j = 0; j < h; ++j) {
 		//     for (int i = 1; i < w; ++i) {
 		//       check(g.source(g.left(g(i, j))) == g(i, j), "Wrong left");
 		//       check(g.target(g.left(g(i, j))) == g(i - 1, j), "Wrong left");
 		//     }
 		//     check(g.left(g(0, j)) == INVALID, "Wrong left");
 		//   }
 		// }
 		int main() {
 		  check_concepts();
 		  check_graph<ListGraph>();
 		  check_graph<SmartGraph>();
 		  check_graph_counts<ListGraph>();
 		  check_graph_counts<SmartGraph>();
 		  check_graph_validity_erase<ListGraph>();
 		  check_graph_validity<SmartGraph>();
 		//   {
 		//     FullGraph g(5);
 		//     check_item_counts(g, 5, 10);
 		//   }
 		//   {
 		//     GridGraph g(5, 6);
 		//     check_item_counts(g, 30, 49);
 		//     checkGridGraph(g, 5, 6);
 		//   }
 		  std::cout << __FILE__ ": All tests passed.\n";
 		  return 0;
+		}

0 comments (0 inline)

RhodeCode

Login to your account