Changeset 919:6153d9cf78c6 in lemon-0.x for src

Timestamp:

09/29/04 16:02:14 (21 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

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

Message:

• Backport -r1227 and -r1220
• Temporarily remove (move to attic) tight_edge_filter.h

Location:

src

Files:

• hugo/Makefile.am (modified) (2 diffs)
• hugo/attic/tight_edge_filter_map.h (moved) (moved from src/hugo/tight_edge_filter_map.h)
• hugo/default_map.h (modified) (1 diff)
• hugo/list_graph.h (modified) (4 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 (deleted)
• hugo/smart_graph.h (modified) (4 diffs)
• hugo/sym_map.h (added)
• test/Makefile.am (modified) (2 diffs)
• test/graph_test.cc (modified) (4 diffs)
• test/graph_test.h (modified) (2 diffs)
• test/sym_graph_test.cc (deleted)
• test/sym_graph_test.h (deleted)
• 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                                                     \
@@ -31 +32 @@
 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(*copy.getGraph()) { \
+  : { \
+  Parent::MapBase::operator= \
+    (static_cast<const typename Parent::MapBase&>(copy)); \
   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

@@ -30 +30 @@
 #include <hugo/array_map.h>
 
+#include <hugo/sym_map.h>
+
 #include <hugo/map_defines.h>
 
@@ -103 +105 @@
         first_free_edge(_g.first_free_edge) {}
     
-    /// \bug In the vector can be hole if a node is erased from the graph.
     ///Number of nodes.
     int nodeNum() const { return nodes.size(); }
@@ -438 +439 @@
   ///\todo this date structure need some reconsiderations. Maybe it
   ///should be implemented independently from ListGraph.
-  /*  
+  
   class SymListGraph : public ListGraph
   {
@@ -483 +484 @@
       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.maxSymEdgeId();
+      return graph.maxEdgeId() >> 1;
     }
-    static int id(const Graph& graph, const typename Graph::SymEdge& edge) {
-      return graph.id(edge);
+    static int id(const Graph& graph, const typename Graph::Edge& edge) {
+      return graph.id(edge) >> 1;
     }
   };

src/hugo/map_defines.h

@@ -115 +115 @@
  */
 #define CREATE_SYM_EDGE_MAP_REGISTRY \
-typedef MapRegistry<Graph, SymEdge, SymEdgeIt> SymEdgeMapRegistry; \
+typedef SymEdgeIt<Graph, Edge, EdgeIt> SymEdgeIt; \
+typedef MapRegistry<Graph, Edge, SymEdgeIt> SymEdgeMapRegistry; \
 mutable SymEdgeMapRegistry sym_edge_maps;
 
@@ -127 +128 @@
 #define CREATE_SYM_EDGE_MAP(DynMap) \
 template <typename Value> \
-class SymEdgeMap : public DynMap<SymEdgeMapRegistry, Value> { \
-public: \
-typedef DynMap<SymEdgeMapRegistry, Value> Parent; \
+class SymEdgeMap : public SymMap<DynMap, SymEdgeMapRegistry, Value> { \
+public: \
+typedef SymMap<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(const KeyType& key) {
+    void add(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(const KeyType& key) {
+    void erase(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>
 
@@ -297 +299 @@
   };
 
-
-
-  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.
 
@@ -692 +319 @@
   //\sa SmartGraph.
 
-  /*  class SymSmartGraph : public SmartGraph
+  class SymSmartGraph : public SmartGraph
   {
   public:
@@ -727 +354 @@
     
 
-    };*/
+  };
   
   /// @}  

src/test/Makefile.am

@@ -10 +10 @@
         dijkstra_test \
         graph_test \
-        sym_graph_test \
         graph_wrapper_test \
         kruskal_test \
@@ -30 +29 @@
 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;
   }  
 }
@@ -82 +83 @@
 
 //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
@@ -92 +93 @@
 
 //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
@@ -131 +132 @@
   }
   {
-    //    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/graph_test.h

@@ -299 +299 @@
       for(int i=0;i<nn;i++) {
         check(e!=INVALID,"Wrong OutEdge list linking.");
-        check(n==G.tail(e), "Wrong OutEdge list linking.");
         ++e;
       }
@@ -312 +311 @@
       for(int i=0;i<nn;i++) {
         check(e!=INVALID,"Wrong InEdge list linking.");
-        check(n==G.head(e), "Wrong InEdge list linking.");
         ++e;
       }

src/test/test_tools.h

@@ -68 +68 @@
 
 ///Adds a Petersen graph to \c G.
-///\return The nodes and edges of the generated graph.
+///\return The nodes end edges og 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