Changeset 909:6a22e0dfd453 in lemon-0.x

Timestamp:

09/26/04 23:43:38 (20 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1220

Message:

New symmetric Graph concept.
New symmetric list and smart graph.
Symmetric Graph tests based on the Graph Tests.

Location:

src

Files:

• hugo/Makefile.am (modified) (2 diffs)
• hugo/default_map.h (modified) (1 diff)
• hugo/list_graph.h (modified) (3 diffs)
• hugo/map_bits.h (modified) (1 diff)
• hugo/map_defines.h (modified) (2 diffs)
• hugo/map_registry.h (modified) (2 diffs)
• hugo/skeletons/sym_graph.h (added)
• hugo/smart_graph.h (modified) (4 diffs)
• hugo/sym_map.h (deleted)
• test/Makefile.am (modified) (2 diffs)
• test/graph_test.cc (modified) (4 diffs)
• test/sym_graph_test.cc (added)
• test/sym_graph_test.h (added)
• test/test_tools.h (modified) (2 diffs)

src/hugo/Makefile.am

@@ -19 +19 @@
         map_bits.h                                                      \
         maps.h                                                          \
-        min_cost_flow.h                                                \
+        min_cost_flow.h                                                 \
         suurballe.h                                                     \
         preflow.h                                                       \
         path.h                                                          \
         smart_graph.h                                                   \
-        sym_map.h                                                       \
         time_measure.h                                                  \
         unionfind.h                                                     \
@@ -32 +31 @@
 noinst_HEADERS =                                                        \
         skeletons/graph.h                                               \
+        skeletons/sym_graph.h                                           \
         skeletons/maps.h                                                \
         skeletons/path.h

src/hugo/default_map.h

@@ -60 +60 @@
 template <typename TT> \
 DefaultMap(const DefaultMap<MapRegistry, TT>& copy) \
-  : { \
-  Parent::MapBase::operator= \
-    (static_cast<const typename Parent::MapBase&>(copy)); \
+  : Parent(*copy.getGraph()) { \
   if (Parent::getGraph()) { \
     for (typename Parent::KeyIt it(*Parent::getGraph()); it!=INVALID; ++it) {\
-      Parent::add(it); \
       Parent::operator[](it) = copy[it]; \
     } \

src/hugo/list_graph.h

@@ -29 +29 @@
 #include <hugo/map_registry.h>
 #include <hugo/array_map.h>
-
-#include <hugo/sym_map.h>
 
 #include <hugo/map_defines.h>
@@ -439 +437 @@
   ///\todo this date structure need some reconsiderations. Maybe it
   ///should be implemented independently from ListGraph.
-  
+  /*  
   class SymListGraph : public ListGraph
   {
@@ -484 +482 @@
       ListGraph::erase(e);
     }    
+    };*/
+
+  class SymListGraph : public ListGraph {
+    typedef ListGraph Parent;
+  public:
+
+    typedef SymListGraph Graph;
+
+    typedef ListGraph::Node Node;
+    typedef ListGraph::NodeIt NodeIt;
+
+    class SymEdge;
+    class SymEdgeIt;
+
+    class Edge;
+    class EdgeIt;
+    class OutEdgeIt;
+    class InEdgeIt;
+
+    template <typename Value>
+    class NodeMap : public Parent::NodeMap<Value> {      
+    public:
+      NodeMap(const SymListGraph& g) 
+        : SymListGraph::Parent::NodeMap<Value>(g) {}
+      NodeMap(const SymListGraph& g, Value v) 
+        : SymListGraph::Parent::NodeMap<Value>(g, v) {}
+      template<typename TT> 
+      NodeMap(const NodeMap<TT>& copy) 
+        : SymListGraph::Parent::NodeMap<Value>(copy) { }            
+    };
+
+    template <typename Value>
+    class SymEdgeMap : public Parent::EdgeMap<Value> {
+    public:
+      typedef SymEdge KeyType;
+
+      SymEdgeMap(const SymListGraph& g) 
+        : SymListGraph::Parent::EdgeMap<Value>(g) {}
+      SymEdgeMap(const SymListGraph& g, Value v) 
+        : SymListGraph::Parent::EdgeMap<Value>(g, v) {}
+      template<typename TT> 
+      SymEdgeMap(const SymEdgeMap<TT>& copy) 
+        : SymListGraph::Parent::EdgeMap<Value>(copy) { }
+      
+    };
+
+    // Create edge map registry.
+    CREATE_EDGE_MAP_REGISTRY;
+    // Create edge maps.
+    CREATE_EDGE_MAP(ArrayMap);
+
+    class Edge {
+      friend class SymListGraph;
+      friend class SymListGraph::EdgeIt;
+      friend class SymListGraph::OutEdgeIt;
+      friend class SymListGraph::InEdgeIt;
+      
+    protected:
+      int id;
+
+      Edge(int pid) { id = pid; }
+
+    public:
+      /// An Edge with id \c n.
+
+      Edge() { }
+      Edge (Invalid) { id = -1; }
+
+      operator SymEdge(){ return SymEdge(id >> 1);}
+      
+      bool operator==(const Edge i) const {return id == i.id;}
+      bool operator!=(const Edge i) const {return id != i.id;}
+      bool operator<(const Edge i) const {return id < i.id;}
+      //      ///Validity check
+      //      operator bool() { return n!=-1; }
+    };
+
+    class SymEdge : public ListGraph::Edge {
+      friend class SymListGraph;
+      friend class SymListGraph::Edge;
+      typedef ListGraph::Edge Parent;
+
+    protected:      
+      SymEdge(int pid) : Parent(pid) {}
+    public:
+
+      SymEdge() { }
+      SymEdge(const ListGraph::Edge& i) : Parent(i) {} 
+      SymEdge (Invalid) : Parent(INVALID) {}
+
+    };
+
+    class OutEdgeIt {
+      Parent::OutEdgeIt out;
+      Parent::InEdgeIt in;      
+    public: 
+      OutEdgeIt() {}
+      OutEdgeIt(const SymListGraph& g, Edge e) { 
+        if (e.id & 1 == 0) {    
+          out = Parent::OutEdgeIt(g, SymEdge(e));
+          in = Parent::InEdgeIt(g, g.tail(e));
+        } else {
+          out = Parent::OutEdgeIt(INVALID);
+          in = Parent::InEdgeIt(g, SymEdge(e));
+        }
+      }
+      OutEdgeIt (Invalid i) : out(INVALID), in(INVALID) { }
+
+      OutEdgeIt(const SymListGraph& g, const Node v)
+        : out(g, v), in(g, v) {}
+      OutEdgeIt &operator++() { 
+        if (out != INVALID) {
+          ++out;
+        } else {
+          ++in;
+        }
+        return *this; 
+      }
+
+      operator Edge() const {
+        if (out == INVALID && in == INVALID) return INVALID;
+        return out != INVALID ? forward(out) : backward(in);
+      }
+
+      bool operator==(const Edge i) const {return Edge(*this) == i;}
+      bool operator!=(const Edge i) const {return Edge(*this) != i;}
+      bool operator<(const Edge i) const {return Edge(*this) < i;}
+    };
+
+    class InEdgeIt {
+      Parent::OutEdgeIt out;
+      Parent::InEdgeIt in;      
+    public: 
+      InEdgeIt() {}
+      InEdgeIt(const SymListGraph& g, Edge e) { 
+        if (e.id & 1 == 0) {    
+          out = Parent::OutEdgeIt(g, SymEdge(e));
+          in = Parent::InEdgeIt(g, g.tail(e));
+        } else {
+          out = Parent::OutEdgeIt(INVALID);
+          in = Parent::InEdgeIt(g, SymEdge(e));
+        }
+      }
+      InEdgeIt (Invalid i) : out(INVALID), in(INVALID) { }
+
+      InEdgeIt(const SymListGraph& g, const Node v)
+        : out(g, v), in(g, v) {}
+
+      InEdgeIt &operator++() { 
+        if (out != INVALID) {
+          ++out;
+        } else {
+          ++in;
+        }
+        return *this; 
+      }
+
+      operator Edge() const {
+        if (out == INVALID && in == INVALID) return INVALID;
+        return out != INVALID ? backward(out) : forward(in);
+      }
+
+      bool operator==(const Edge i) const {return Edge(*this) == i;}
+      bool operator!=(const Edge i) const {return Edge(*this) != i;}
+      bool operator<(const Edge i) const {return Edge(*this) < i;}
+    };
+
+    class SymEdgeIt : public Parent::EdgeIt {
+
+    public:
+      SymEdgeIt() {}
+
+      SymEdgeIt(const SymListGraph& g) 
+        : SymListGraph::Parent::EdgeIt(g) {}
+
+      SymEdgeIt(const SymListGraph& g, SymEdge e) 
+        : SymListGraph::Parent::EdgeIt(g, e) {}
+
+      SymEdgeIt(Invalid i) 
+        : SymListGraph::Parent::EdgeIt(INVALID) {}
+
+      SymEdgeIt& operator++() {
+        SymListGraph::Parent::EdgeIt::operator++();
+        return *this;
+      }
+
+      operator SymEdge() const {
+        return SymEdge
+          (static_cast<const SymListGraph::Parent::EdgeIt&>(*this));
+      }
+      bool operator==(const SymEdge i) const {return SymEdge(*this) == i;}
+      bool operator!=(const SymEdge i) const {return SymEdge(*this) != i;}
+      bool operator<(const SymEdge i) const {return SymEdge(*this) < i;}
+    };
+
+    class EdgeIt {
+      SymEdgeIt it;
+      bool fw;
+    public:
+      EdgeIt(const SymListGraph& g) : it(g), fw(true) {}
+      EdgeIt (Invalid i) : it(i) { }
+      EdgeIt(const SymListGraph& g, Edge e) 
+        : it(g, SymEdge(e)), fw(id(e) & 1 == 0) { }
+      EdgeIt() { }
+      EdgeIt& operator++() {
+        fw = !fw;
+        if (fw) ++it;
+        return *this;
+      }
+      operator Edge() const {
+        if (it == INVALID) return INVALID;
+        return fw ? forward(it) : backward(it);
+      }
+      bool operator==(const Edge i) const {return Edge(*this) == i;}
+      bool operator!=(const Edge i) const {return Edge(*this) != i;}
+      bool operator<(const Edge i) const {return Edge(*this) < i;}
+
+    };
+
+    ///Number of nodes.
+    int nodeNum() const { return Parent::nodeNum(); }
+    ///Number of edges.
+    int edgeNum() const { return 2*Parent::edgeNum(); }
+    ///Number of symmetric edges.
+    int symEdgeNum() const { return Parent::edgeNum(); }
+
+    ///Set the expected maximum number of edges.
+
+    ///With this function, it is possible to set the expected number of edges.
+    ///The use of this fasten the building of the graph and makes
+    ///it possible to avoid the superfluous memory allocation.
+    void reserveSymEdge(int n) { Parent::reserveEdge(n); };
+    
+    /// Maximum node ID.
+    
+    /// Maximum node ID.
+    ///\sa id(Node)
+    int maxNodeId() const { return Parent::maxNodeId(); } 
+    /// Maximum edge ID.
+    
+    /// Maximum edge ID.
+    ///\sa id(Edge)
+    int maxEdgeId() const { return 2*Parent::maxEdgeId(); }
+    /// Maximum symmetric edge ID.
+    
+    /// Maximum symmetric edge ID.
+    ///\sa id(SymEdge)
+    int maxSymEdgeId() const { return Parent::maxEdgeId(); }
+
+
+    Node tail(Edge e) const { 
+      return e.id & 1 == 0 ? 
+        Parent::tail(SymEdge(e)) : Parent::head(SymEdge(e)); 
+    }
+
+    Node head(Edge e) const { 
+      return e.id & 1 == 0 ? 
+        Parent::head(SymEdge(e)) : Parent::tail(SymEdge(e)); 
+    }
+
+    Node tail(SymEdge e) const { 
+      return Parent::tail(e); 
+    }
+
+    Node head(SymEdge e) const { 
+      return Parent::head(e); 
+    }
+
+    NodeIt& first(NodeIt& v) const { 
+      v=NodeIt(*this); return v; }
+    EdgeIt& first(EdgeIt& e) const { 
+      e=EdgeIt(*this); return e; }
+    SymEdgeIt& first(SymEdgeIt& e) const {
+      e=SymEdgeIt(*this); return e; }
+    OutEdgeIt& first(OutEdgeIt& e, const Node v) const { 
+      e=OutEdgeIt(*this,v); return e; }
+    InEdgeIt& first(InEdgeIt& e, const Node v) const { 
+      e=InEdgeIt(*this,v); return e; }
+
+    /// Node ID.
+    
+    /// The ID of a valid Node is a nonnegative integer not greater than
+    /// \ref maxNodeId(). The range of the ID's is not surely continuous
+    /// and the greatest node ID can be actually less then \ref maxNodeId().
+    ///
+    /// The ID of the \ref INVALID node is -1.
+    ///\return The ID of the node \c v. 
+    static int id(Node v) { return Parent::id(v); }
+    /// Edge ID.
+    
+    /// The ID of a valid Edge is a nonnegative integer not greater than
+    /// \ref maxEdgeId(). The range of the ID's is not surely continuous
+    /// and the greatest edge ID can be actually less then \ref maxEdgeId().
+    ///
+    /// The ID of the \ref INVALID edge is -1.
+    ///\return The ID of the edge \c e. 
+    static int id(Edge e) { return e.id; }
+
+    /// The ID of a valid SymEdge is a nonnegative integer not greater than
+    /// \ref maxSymEdgeId(). The range of the ID's is not surely continuous
+    /// and the greatest edge ID can be actually less then \ref maxSymEdgeId().
+    ///
+    /// The ID of the \ref INVALID symmetric edge is -1.
+    ///\return The ID of the edge \c e. 
+    static int id(SymEdge e) { return Parent::id(e); }
+
+    /// Adds a new node to the graph.
+
+    /// \warning It adds the new node to the front of the list.
+    /// (i.e. the lastly added node becomes the first.)
+    Node addNode() {
+      return Parent::addNode();
+    }
+    
+    SymEdge addEdge(Node u, Node v) {
+      SymEdge se = Parent::addEdge(u, v);
+      edge_maps.add(forward(se));
+      edge_maps.add(backward(se));
+      return se;
+    }
+    
+    /// Finds an edge between two nodes.
+
+    /// Finds an edge from node \c u to node \c v.
+    ///
+    /// If \c prev is \ref INVALID (this is the default value), then
+    /// It finds the first edge from \c u to \c v. Otherwise it looks for
+    /// the next edge from \c u to \c v after \c prev.
+    /// \return The found edge or INVALID if there is no such an edge.
+    Edge findEdge(Node u, Node v, Edge prev = INVALID) 
+    {     
+      if (prev == INVALID || id(prev) & 1 == 0) {
+        SymEdge se = Parent::findEdge(u, v, SymEdge(prev));
+        if (se != INVALID) return forward(se);
+      } else {
+        SymEdge se = Parent::findEdge(v, u, SymEdge(prev));
+        if (se != INVALID) return backward(se); 
+      }
+      return INVALID;
+    }
+
+    /// Finds an symmetric edge between two nodes.
+
+    /// Finds an symmetric edge from node \c u to node \c v.
+    ///
+    /// If \c prev is \ref INVALID (this is the default value), then
+    /// It finds the first edge from \c u to \c v. Otherwise it looks for
+    /// the next edge from \c u to \c v after \c prev.
+    /// \return The found edge or INVALID if there is no such an edge.
+
+//     SymEdge findEdge(Node u, Node v, SymEdge prev = INVALID) 
+//     {     
+//       if (prev == INVALID || id(prev) & 1 == 0) {
+//      SymEdge se = Parent::findEdge(u, v, SymEdge(prev));
+//      if (se != INVALID) return se;
+//       } else {
+//      SymEdge se = Parent::findEdge(v, u, SymEdge(prev));
+//      if (se != INVALID) return se;   
+//       }
+//       return INVALID;
+//     }
+    
+  public:
+
+    void erase(Node n) {      
+      for (OutEdgeIt it(*this, n); it != INVALID; ++it) {
+        edge_maps.erase(it);
+        edge_maps.erase(opposite(it));
+      }
+      Parent::erase(n);
+    }
+    
+    void erase(SymEdge e) { 
+      edge_maps.erase(forward(e));
+      edge_maps.erase(backward(e));
+      Parent::erase(e); 
+    };
+
+    void clear() {
+      edge_maps.clear();
+      Parent::clear();
+    }
+
+    static Edge opposite(Edge e) {
+      return Edge(id(e) ^ 1);
+    }
+
+    static Edge forward(SymEdge e) {
+      return Edge(id(e) << 1);
+    }
+
+    static Edge backward(SymEdge e) {
+      return Edge((id(e) << 1) & 1);
+    }
+
   };
-
 
   ///A graph class containing only nodes.

src/hugo/map_bits.h

@@ -55 +55 @@
   struct KeyInfo<Graph, typename Graph::SymEdgeIt> {
     static int maxId(const Graph& graph) {
-      return graph.maxEdgeId() >> 1;
+      return graph.maxSymEdgeId();
     }
-    static int id(const Graph& graph, const typename Graph::Edge& edge) {
-      return graph.id(edge) >> 1;
+    static int id(const Graph& graph, const typename Graph::SymEdge& edge) {
+      return graph.id(edge);
     }
   };

src/hugo/map_defines.h

@@ -115 +115 @@
  */
 #define CREATE_SYM_EDGE_MAP_REGISTRY \
-typedef SymEdgeIt<Graph, Edge, EdgeIt> SymEdgeIt; \
-typedef MapRegistry<Graph, Edge, SymEdgeIt> SymEdgeMapRegistry; \
+typedef MapRegistry<Graph, SymEdge, SymEdgeIt> SymEdgeMapRegistry; \
 mutable SymEdgeMapRegistry sym_edge_maps;
 
@@ -128 +127 @@
 #define CREATE_SYM_EDGE_MAP(DynMap) \
 template <typename Value> \
-class SymEdgeMap : public SymMap<DynMap, SymEdgeMapRegistry, Value> { \
-public: \
-typedef SymMap<DynMap, SymEdgeMapRegistry, Value> Parent; \
+class SymEdgeMap : public DynMap<SymEdgeMapRegistry, Value> { \
+public: \
+typedef DynMap<SymEdgeMapRegistry, Value> Parent; \
 \
 SymEdgeMap(const typename Parent::Graph& g) \

src/hugo/map_registry.h

@@ -253 +253 @@
      * Notify all the registered maps about a Key added.
      */
-    void add(KeyType& key) {
+    void add(const KeyType& key) {
       typename Container::iterator it;
       for (it = container.begin(); it != container.end(); ++it) {
@@ -263 +263 @@
      * Notify all the registered maps about a Key erased.
      */ 
-    void erase(KeyType& key) {
+    void erase(const KeyType& key) {
       typename Container::iterator it;
       for (it = container.begin(); it != container.end(); ++it) {

src/hugo/smart_graph.h

@@ -28 +28 @@
 
 #include <hugo/array_map.h>
-#include <hugo/sym_map.h>
-
 #include <hugo/map_registry.h>
 
@@ -299 +297 @@
   };
 
+
+
+  class SymSmartGraph : public SmartGraph {
+    typedef SmartGraph Parent;
+  public:
+
+    typedef SymSmartGraph Graph;
+
+    typedef SmartGraph::Node Node;
+    typedef SmartGraph::NodeIt NodeIt;
+
+    class SymEdge;
+    class SymEdgeIt;
+
+    class Edge;
+    class EdgeIt;
+    class OutEdgeIt;
+    class InEdgeIt;
+
+    template <typename Value>
+    class NodeMap : public Parent::NodeMap<Value> {      
+    public:
+      NodeMap(const SymSmartGraph& g) 
+        : SymSmartGraph::Parent::NodeMap<Value>(g) {}
+      NodeMap(const SymSmartGraph& g, Value v) 
+        : SymSmartGraph::Parent::NodeMap<Value>(g, v) {}
+      template<typename TT> 
+      NodeMap(const NodeMap<TT>& copy) 
+        : SymSmartGraph::Parent::NodeMap<Value>(copy) { }            
+    };
+
+    template <typename Value>
+    class SymEdgeMap : public Parent::EdgeMap<Value> {
+    public:
+      typedef SymEdge KeyType;
+
+      SymEdgeMap(const SymSmartGraph& g) 
+        : SymSmartGraph::Parent::EdgeMap<Value>(g) {}
+      SymEdgeMap(const SymSmartGraph& g, Value v) 
+        : SymSmartGraph::Parent::EdgeMap<Value>(g, v) {}
+      template<typename TT> 
+      SymEdgeMap(const SymEdgeMap<TT>& copy) 
+        : SymSmartGraph::Parent::EdgeMap<Value>(copy) { }
+      
+    };
+
+    // Create edge map registry.
+    CREATE_EDGE_MAP_REGISTRY;
+    // Create edge maps.
+    CREATE_EDGE_MAP(ArrayMap);
+
+    class Edge {
+      friend class SymSmartGraph;
+      friend class SymSmartGraph::EdgeIt;
+      friend class SymSmartGraph::OutEdgeIt;
+      friend class SymSmartGraph::InEdgeIt;
+      
+    protected:
+      int id;
+
+      Edge(int pid) { id = pid; }
+
+    public:
+      /// An Edge with id \c n.
+
+      Edge() { }
+      Edge (Invalid) { id = -1; }
+
+      operator SymEdge(){ return SymEdge(id >> 1);}
+      
+      bool operator==(const Edge i) const {return id == i.id;}
+      bool operator!=(const Edge i) const {return id != i.id;}
+      bool operator<(const Edge i) const {return id < i.id;}
+      //      ///Validity check
+      //      operator bool() { return n!=-1; }
+    };
+
+    class SymEdge : public SmartGraph::Edge {
+      friend class SymSmartGraph;
+      friend class SymSmartGraph::Edge;
+      typedef SmartGraph::Edge Parent;
+
+    protected:      
+      SymEdge(int pid) : Parent(pid) {}
+    public:
+
+      SymEdge() { }
+      SymEdge(const SmartGraph::Edge& i) : Parent(i) {} 
+      SymEdge (Invalid) : Parent(INVALID) {}
+
+    };
+
+    class OutEdgeIt {
+      Parent::OutEdgeIt out;
+      Parent::InEdgeIt in;      
+    public: 
+      OutEdgeIt() {}
+      OutEdgeIt(const SymSmartGraph& g, Edge e) { 
+        if (e.id & 1 == 0) {    
+          out = Parent::OutEdgeIt(g, SymEdge(e));
+          in = Parent::InEdgeIt(g, g.tail(e));
+        } else {
+          out = Parent::OutEdgeIt(INVALID);
+          in = Parent::InEdgeIt(g, SymEdge(e));
+        }
+      }
+      OutEdgeIt (Invalid i) : out(INVALID), in(INVALID) { }
+
+      OutEdgeIt(const SymSmartGraph& g, const Node v)
+        : out(g, v), in(g, v) {}
+      OutEdgeIt &operator++() { 
+        if (out != INVALID) {
+          ++out;
+        } else {
+          ++in;
+        }
+        return *this; 
+      }
+
+      operator Edge() const {
+        if (out == INVALID && in == INVALID) return INVALID;
+        return out != INVALID ? forward(out) : backward(in);
+      }
+
+      bool operator==(const Edge i) const {return Edge(*this) == i;}
+      bool operator!=(const Edge i) const {return Edge(*this) != i;}
+      bool operator<(const Edge i) const {return Edge(*this) < i;}
+    };
+
+    class InEdgeIt {
+      Parent::OutEdgeIt out;
+      Parent::InEdgeIt in;      
+    public: 
+      InEdgeIt() {}
+      InEdgeIt(const SymSmartGraph& g, Edge e) { 
+        if (e.id & 1 == 0) {    
+          out = Parent::OutEdgeIt(g, SymEdge(e));
+          in = Parent::InEdgeIt(g, g.tail(e));
+        } else {
+          out = Parent::OutEdgeIt(INVALID);
+          in = Parent::InEdgeIt(g, SymEdge(e));
+        }
+      }
+      InEdgeIt (Invalid i) : out(INVALID), in(INVALID) { }
+
+      InEdgeIt(const SymSmartGraph& g, const Node v)
+        : out(g, v), in(g, v) {}
+
+      InEdgeIt &operator++() { 
+        if (out != INVALID) {
+          ++out;
+        } else {
+          ++in;
+        }
+        return *this; 
+      }
+
+      operator Edge() const {
+        if (out == INVALID && in == INVALID) return INVALID;
+        return out != INVALID ? backward(out) : forward(in);
+      }
+
+      bool operator==(const Edge i) const {return Edge(*this) == i;}
+      bool operator!=(const Edge i) const {return Edge(*this) != i;}
+      bool operator<(const Edge i) const {return Edge(*this) < i;}
+    };
+
+    class SymEdgeIt : public Parent::EdgeIt {
+
+    public:
+      SymEdgeIt() {}
+
+      SymEdgeIt(const SymSmartGraph& g) 
+        : SymSmartGraph::Parent::EdgeIt(g) {}
+
+      SymEdgeIt(const SymSmartGraph& g, SymEdge e) 
+        : SymSmartGraph::Parent::EdgeIt(g, e) {}
+
+      SymEdgeIt(Invalid i) 
+        : SymSmartGraph::Parent::EdgeIt(INVALID) {}
+
+      SymEdgeIt& operator++() {
+        SymSmartGraph::Parent::EdgeIt::operator++();
+        return *this;
+      }
+
+      operator SymEdge() const {
+        return SymEdge
+          (static_cast<const SymSmartGraph::Parent::EdgeIt&>(*this));
+      }
+      bool operator==(const SymEdge i) const {return SymEdge(*this) == i;}
+      bool operator!=(const SymEdge i) const {return SymEdge(*this) != i;}
+      bool operator<(const SymEdge i) const {return SymEdge(*this) < i;}
+    };
+
+    class EdgeIt {
+      SymEdgeIt it;
+      bool fw;
+    public:
+      EdgeIt(const SymSmartGraph& g) : it(g), fw(true) {}
+      EdgeIt (Invalid i) : it(i) { }
+      EdgeIt(const SymSmartGraph& g, Edge e) 
+        : it(g, SymEdge(e)), fw(id(e) & 1 == 0) { }
+      EdgeIt() { }
+      EdgeIt& operator++() {
+        fw = !fw;
+        if (fw) ++it;
+        return *this;
+      }
+      operator Edge() const {
+        if (it == INVALID) return INVALID;
+        return fw ? forward(it) : backward(it);
+      }
+      bool operator==(const Edge i) const {return Edge(*this) == i;}
+      bool operator!=(const Edge i) const {return Edge(*this) != i;}
+      bool operator<(const Edge i) const {return Edge(*this) < i;}
+
+    };
+
+    ///Number of nodes.
+    int nodeNum() const { return Parent::nodeNum(); }
+    ///Number of edges.
+    int edgeNum() const { return 2*Parent::edgeNum(); }
+    ///Number of symmetric edges.
+    int symEdgeNum() const { return Parent::edgeNum(); }
+
+    /// Maximum node ID.
+    
+    /// Maximum node ID.
+    ///\sa id(Node)
+    int maxNodeId() const { return Parent::maxNodeId(); } 
+    /// Maximum edge ID.
+    
+    /// Maximum edge ID.
+    ///\sa id(Edge)
+    int maxEdgeId() const { return 2*Parent::maxEdgeId(); }
+    /// Maximum symmetric edge ID.
+    
+    /// Maximum symmetric edge ID.
+    ///\sa id(SymEdge)
+    int maxSymEdgeId() const { return Parent::maxEdgeId(); }
+
+
+    Node tail(Edge e) const { 
+      return e.id & 1 == 0 ? 
+        Parent::tail(SymEdge(e)) : Parent::head(SymEdge(e)); 
+    }
+
+    Node head(Edge e) const { 
+      return e.id & 1 == 0 ? 
+        Parent::head(SymEdge(e)) : Parent::tail(SymEdge(e)); 
+    }
+
+    Node tail(SymEdge e) const { 
+      return Parent::tail(e); 
+    }
+
+    Node head(SymEdge e) const { 
+      return Parent::head(e); 
+    }
+
+    NodeIt& first(NodeIt& v) const { 
+      v=NodeIt(*this); return v; }
+    EdgeIt& first(EdgeIt& e) const { 
+      e=EdgeIt(*this); return e; }
+    SymEdgeIt& first(SymEdgeIt& e) const {
+      e=SymEdgeIt(*this); return e; }
+    OutEdgeIt& first(OutEdgeIt& e, const Node v) const { 
+      e=OutEdgeIt(*this,v); return e; }
+    InEdgeIt& first(InEdgeIt& e, const Node v) const { 
+      e=InEdgeIt(*this,v); return e; }
+
+    /// Node ID.
+    
+    /// The ID of a valid Node is a nonnegative integer not greater than
+    /// \ref maxNodeId(). The range of the ID's is not surely continuous
+    /// and the greatest node ID can be actually less then \ref maxNodeId().
+    ///
+    /// The ID of the \ref INVALID node is -1.
+    ///\return The ID of the node \c v. 
+    static int id(Node v) { return Parent::id(v); }
+    /// Edge ID.
+    
+    /// The ID of a valid Edge is a nonnegative integer not greater than
+    /// \ref maxEdgeId(). The range of the ID's is not surely continuous
+    /// and the greatest edge ID can be actually less then \ref maxEdgeId().
+    ///
+    /// The ID of the \ref INVALID edge is -1.
+    ///\return The ID of the edge \c e. 
+    static int id(Edge e) { return e.id; }
+
+    /// The ID of a valid SymEdge is a nonnegative integer not greater than
+    /// \ref maxSymEdgeId(). The range of the ID's is not surely continuous
+    /// and the greatest edge ID can be actually less then \ref maxSymEdgeId().
+    ///
+    /// The ID of the \ref INVALID symmetric edge is -1.
+    ///\return The ID of the edge \c e. 
+    static int id(SymEdge e) { return Parent::id(e); }
+
+    /// Adds a new node to the graph.
+
+    /// \warning It adds the new node to the front of the list.
+    /// (i.e. the lastly added node becomes the first.)
+    Node addNode() {
+      return Parent::addNode();
+    }
+    
+    SymEdge addEdge(Node u, Node v) {
+      SymEdge se = Parent::addEdge(u, v);
+      edge_maps.add(forward(se));
+      edge_maps.add(backward(se));
+      return se;
+    }
+    
+    /// Finds an edge between two nodes.
+
+    /// Finds an edge from node \c u to node \c v.
+    ///
+    /// If \c prev is \ref INVALID (this is the default value), then
+    /// It finds the first edge from \c u to \c v. Otherwise it looks for
+    /// the next edge from \c u to \c v after \c prev.
+    /// \return The found edge or INVALID if there is no such an edge.
+    Edge findEdge(Node u, Node v, Edge prev = INVALID) 
+    {     
+      if (prev == INVALID || id(prev) & 1 == 0) {
+        SymEdge se = Parent::findEdge(u, v, SymEdge(prev));
+        if (se != INVALID) return forward(se);
+      } else {
+        SymEdge se = Parent::findEdge(v, u, SymEdge(prev));
+        if (se != INVALID) return backward(se); 
+      }
+      return INVALID;
+    }
+
+    /// Finds an symmetric edge between two nodes.
+
+    /// Finds an symmetric edge from node \c u to node \c v.
+    ///
+    /// If \c prev is \ref INVALID (this is the default value), then
+    /// It finds the first edge from \c u to \c v. Otherwise it looks for
+    /// the next edge from \c u to \c v after \c prev.
+    /// \return The found edge or INVALID if there is no such an edge.
+
+//     SymEdge findEdge(Node u, Node v, SymEdge prev = INVALID) 
+//     {     
+//       if (prev == INVALID || id(prev) & 1 == 0) {
+//      SymEdge se = Parent::findEdge(u, v, SymEdge(prev));
+//      if (se != INVALID) return se;
+//       } else {
+//      SymEdge se = Parent::findEdge(v, u, SymEdge(prev));
+//      if (se != INVALID) return se;   
+//       }
+//       return INVALID;
+//     }
+    
+  public:
+
+    void clear() {
+      edge_maps.clear();
+      Parent::clear();
+    }
+
+    static Edge opposite(Edge e) {
+      return Edge(id(e) ^ 1);
+    }
+
+    static Edge forward(SymEdge e) {
+      return Edge(id(e) << 1);
+    }
+
+    static Edge backward(SymEdge e) {
+      return Edge((id(e) << 1) & 1);
+    }
+
+  };
   ///Graph for bidirectional edges.
 
@@ -319 +692 @@
   //\sa SmartGraph.
 
-  class SymSmartGraph : public SmartGraph
+  /*  class SymSmartGraph : public SmartGraph
   {
   public:
@@ -354 +727 @@
     
 
-  };
+    };*/
   
   /// @}  

src/test/Makefile.am

@@ -10 +10 @@
         dijkstra_test \
         graph_test \
+        sym_graph_test \
         graph_wrapper_test \
         kruskal_test \
@@ -29 +30 @@
 dijkstra_test_SOURCES = dijkstra_test.cc
 graph_test_SOURCES = graph_test.cc
+sym_graph_test_SOURCES = sym_graph_test.cc
 graph_wrapper_test_SOURCES = graph_wrapper_test.cc
 kruskal_test_SOURCES = kruskal_test.cc

src/test/graph_test.cc

@@ -64 +64 @@
     checkGraphInEdgeList(G,n,3);
     checkGraphOutEdgeList(G,n,3);
-    ++n;
   }  
 }
@@ -83 +82 @@
 
 //Compile SymSmartGraph
-template void hugo::checkCompileGraph<SymSmartGraph>(SymSmartGraph &);
-template void hugo::checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);
+//template void hugo::checkCompileGraph<SymSmartGraph>(SymSmartGraph &);
+//template void hugo::checkCompileGraphFindEdge<SymSmartGraph>(SymSmartGraph &);
 
 //Compile ListGraph
@@ -93 +92 @@
 
 //Compile SymListGraph
-template void hugo::checkCompileGraph<SymListGraph>(SymListGraph &);
-template void hugo::checkCompileErasableGraph<SymListGraph>(SymListGraph &);
-template void hugo::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
+//template void hugo::checkCompileGraph<SymListGraph>(SymListGraph &);
+//template void hugo::checkCompileErasableGraph<SymListGraph>(SymListGraph &);
+//template void hugo::checkCompileGraphFindEdge<SymListGraph>(SymListGraph &);
 
 //Compile FullGraph
@@ -132 +131 @@
   }
   {
-    SymSmartGraph G;
-    addPetersen(G);
-    checkPetersen(G);
+    //    SymSmartGraph G;
+    //    addPetersen(G);
+    //    checkPetersen(G);
   }
   {
-    SymListGraph G;
-    addPetersen(G);
-    checkPetersen(G);
+    //    SymListGraph G;
+    //    addPetersen(G);
+    //    checkPetersen(G);
   }
 

src/test/test_tools.h

@@ -68 +68 @@
 
 ///Adds a Petersen graph to \c G.
-///\return The nodes end edges og the generated graph.
+///\return The nodes and edges of the generated graph.
 
 template<typename Graph>
@@ -88 +88 @@
 }
 
+///Structure returned by \ref addSymPetersen().
 
+///Structure returned by \ref addSymPetersen().
+///
+template<class Graph> struct SymPetStruct
+{
+  ///Vector containing the outer nodes.
+  std::vector<typename Graph::Node> outer;
+  ///Vector containing the inner nodes.
+  std::vector<typename Graph::Node> inner;
+  ///Vector containing the edges of the inner circle.
+  std::vector<typename Graph::SymEdge> incir;
+  ///Vector containing the edges of the outer circle.
+  std::vector<typename Graph::SymEdge> outcir;
+  ///Vector containing the chord edges.
+  std::vector<typename Graph::SymEdge> chords;
+};
+
+///Adds a Petersen graph to the symmetric \c G.
+
+///Adds a Petersen graph to the symmetric \c G.
+///\return The nodes and edges of the generated graph.
+
+template<typename Graph>
+SymPetStruct<Graph> addSymPetersen(Graph &G,int num=5)
+{
+  SymPetStruct<Graph> n;
+
+  for(int i=0;i<num;i++) {
+    n.outer.push_back(G.addNode());
+    n.inner.push_back(G.addNode());
+  }
+
+ for(int i=0;i<num;i++) {
+   n.chords.push_back(G.addEdge(n.outer[i],n.inner[i]));
+   n.outcir.push_back(G.addEdge(n.outer[i],n.outer[(i+1)%5]));
+   n.incir.push_back(G.addEdge(n.inner[i],n.inner[(i+2)%5]));
+  }
+ return n;
+}
 
 #endif