Changeset 1910:f95eea8c34b0 in lemon-0.x for lemon/bits/graph_extender.h

Timestamp:

01/26/06 17:24:40 (18 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

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

Message:

Bipartite => Bp
Upper => A
Lower => B

+ some bug fix

File:

• lemon/bits/graph_extender.h (modified) (13 diffs)

lemon/bits/graph_extender.h

@@ -3 +3 @@
  *
  * Copyright (C) 2006 Egervary Jeno Kombinatorikus Optimalizalasi
- * Kutatocsoport (Egervary Research Group on Combinatorial Optimization,
+ * Kutatocsoport (Egervary Research Groin on Combinatorial Optimization,
  * EGRES).
  *
@@ -380 +380 @@
 
   template <typename _Base>
-  class UBipartiteGraphExtender : public _Base {
+  class BpUGraphExtender : public _Base {
   public:
     typedef _Base Parent;
-    typedef UBipartiteGraphExtender Graph;
+    typedef BpUGraphExtender Graph;
 
     typedef typename Parent::Node Node;
@@ -394 +394 @@
 
     Node source(const UEdge& edge) const {
-      return upperNode(edge);
+      return aNode(edge);
     }
     Node target(const UEdge& edge) const {
-      return lowerNode(edge);
+      return bNode(edge);
     }
 
     void firstInc(UEdge& edge, bool& direction, const Node& node) const {
-      if (Parent::upper(node)) {
-        Parent::firstDown(edge, node);
+      if (Parent::aNode(node)) {
+        Parent::firstOut(edge, node);
         direction = true;
       } else {
-        Parent::firstUp(edge, node);
+        Parent::firstIn(edge, node);
         direction = static_cast<UEdge&>(edge) == INVALID;
       }
@@ -411 +411 @@
     void nextInc(UEdge& edge, bool& direction) const {
       if (direction) {
-        Parent::nextDown(edge);
-      } else {
-        Parent::nextUp(edge);
+        Parent::nextOut(edge);
+      } else {
+        Parent::nextIn(edge);
         if (edge == INVALID) direction = true;
       }
@@ -427 +427 @@
 
     class Edge : public UEdge {
-      friend class UBipartiteGraphExtender;
+      friend class BpUGraphExtender;
     protected:
       bool forward;
@@ -462 +462 @@
 
     void firstOut(Edge& edge, const Node& node) const {
-      if (Parent::upper(node)) {
-        Parent::firstDown(edge, node);
+      if (Parent::aNode(node)) {
+        Parent::firstOut(edge, node);
         edge.forward = true;
       } else {
-        Parent::firstUp(edge, node);
+        Parent::firstIn(edge, node);
         edge.forward = static_cast<UEdge&>(edge) == INVALID;
       }
@@ -472 +472 @@
     void nextOut(Edge& edge) const {
       if (edge.forward) {
-        Parent::nextDown(edge);
-      } else {
-        Parent::nextUp(edge);
+        Parent::nextOut(edge);
+      } else {
+        Parent::nextIn(edge);
         edge.forward = static_cast<UEdge&>(edge) == INVALID;
       }
@@ -480 +480 @@
 
     void firstIn(Edge& edge, const Node& node) const {
-      if (Parent::lower(node)) {
-        Parent::firstUp(edge, node);
+      if (Parent::bNode(node)) {
+        Parent::firstIn(edge, node);
         edge.forward = true;    
       } else {
-        Parent::firstDown(edge, node);
+        Parent::firstOut(edge, node);
         edge.forward = static_cast<UEdge&>(edge) == INVALID;
       }
@@ -490 +490 @@
     void nextIn(Edge& edge) const {
       if (edge.forward) {
-        Parent::nextUp(edge);
-      } else {
-        Parent::nextDown(edge);
+        Parent::nextIn(edge);
+      } else {
+        Parent::nextOut(edge);
         edge.forward = static_cast<UEdge&>(edge) == INVALID;
       }
@@ -498 +498 @@
 
     Node source(const Edge& edge) const {
-      return edge.forward ? Parent::upperNode(edge) : Parent::lowerNode(edge);
+      return edge.forward ? Parent::aNode(edge) : Parent::bNode(edge);
     }
     Node target(const Edge& edge) const {
-      return edge.forward ? Parent::lowerNode(edge) : Parent::upperNode(edge);
+      return edge.forward ? Parent::bNode(edge) : Parent::aNode(edge);
     }
 
@@ -535 +535 @@
     }
 
-    class UpperNode : public Node {
-      friend class UBipartiteGraphExtender;
+    class ANode : public Node {
+      friend class BpUGraphExtender;
     public:
-      UpperNode() {}
-      UpperNode(const Node& node) : Node(node) {
-        LEMON_ASSERT(Parent::upper(node) || node == INVALID, 
+      ANode() {}
+      ANode(const Node& node) : Node(node) {
+        LEMON_ASSERT(Parent::aNode(node) || node == INVALID, 
                      typename Parent::NodeSetError());
       }
-      UpperNode(Invalid) : Node(INVALID) {}
+      ANode(Invalid) : Node(INVALID) {}
     };
 
-    void first(UpperNode& node) const {
-      Parent::firstUpper(static_cast<Node&>(node));
-    }
-    void next(UpperNode& node) const {
-      Parent::nextUpper(static_cast<Node&>(node));
-    }
-
-    int id(const UpperNode& node) const {
-      return Parent::upperId(node);
-    }
-
-    class LowerNode : public Node {
-      friend class UBipartiteGraphExtender;
+    void first(ANode& node) const {
+      Parent::firstANode(static_cast<Node&>(node));
+    }
+    void next(ANode& node) const {
+      Parent::nextANode(static_cast<Node&>(node));
+    }
+
+    int id(const ANode& node) const {
+      return Parent::aNodeId(node);
+    }
+
+    class BNode : public Node {
+      friend class BpUGraphExtender;
     public:
-      LowerNode() {}
-      LowerNode(const Node& node) : Node(node) {
-        LEMON_ASSERT(Parent::lower(node) || node == INVALID,
+      BNode() {}
+      BNode(const Node& node) : Node(node) {
+        LEMON_ASSERT(Parent::bNode(node) || node == INVALID,
                      typename Parent::NodeSetError());
       }
-      LowerNode(Invalid) : Node(INVALID) {}
+      BNode(Invalid) : Node(INVALID) {}
     };
 
-    void first(LowerNode& node) const {
-      Parent::firstLower(static_cast<Node&>(node));
-    }
-    void next(LowerNode& node) const {
-      Parent::nextLower(static_cast<Node&>(node));
+    void first(BNode& node) const {
+      Parent::firstBNode(static_cast<Node&>(node));
+    }
+    void next(BNode& node) const {
+      Parent::nextBNode(static_cast<Node&>(node));
     }
   
-    int id(const LowerNode& node) const {
-      return Parent::upperId(node);
+    int id(const BNode& node) const {
+      return Parent::aNodeId(node);
     }
 
@@ -584 +584 @@
       return Parent::maxNodeId();
     }
-    int maxId(LowerNode) const {
-      return Parent::maxLowerId();
-    }
-    int maxId(UpperNode) const {
-      return Parent::maxUpperId();
+    int maxId(BNode) const {
+      return Parent::maxBNodeId();
+    }
+    int maxId(ANode) const {
+      return Parent::maxANodeId();
     }
     int maxId(Edge) const {
@@ -601 +601 @@
       return Parent::nodeFromId(id);
     }
-    UpperNode fromId(int id, UpperNode) const {
-      return Parent::fromUpperId(id);
-    }
-    LowerNode fromId(int id, LowerNode) const {
-      return Parent::fromLowerId(id);
+    ANode fromId(int id, ANode) const {
+      return Parent::fromANodeId(id);
+    }
+    BNode fromId(int id, BNode) const {
+      return Parent::fromBNodeId(id);
     }
     Edge fromId(int id, Edge) const {