COIN-OR::LEMON - Graph Library

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


Ignore:
Timestamp:
01/26/06 17:24:40 (13 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:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/bits/graph_extender.h

    r1909 r1910  
    33 *
    44 * Copyright (C) 2006 Egervary Jeno Kombinatorikus Optimalizalasi
    5  * Kutatocsoport (Egervary Research Group on Combinatorial Optimization,
     5 * Kutatocsoport (Egervary Research Groin on Combinatorial Optimization,
    66 * EGRES).
    77 *
     
    380380
    381381  template <typename _Base>
    382   class UBipartiteGraphExtender : public _Base {
     382  class BpUGraphExtender : public _Base {
    383383  public:
    384384    typedef _Base Parent;
    385     typedef UBipartiteGraphExtender Graph;
     385    typedef BpUGraphExtender Graph;
    386386
    387387    typedef typename Parent::Node Node;
     
    394394
    395395    Node source(const UEdge& edge) const {
    396       return upperNode(edge);
     396      return aNode(edge);
    397397    }
    398398    Node target(const UEdge& edge) const {
    399       return lowerNode(edge);
     399      return bNode(edge);
    400400    }
    401401
    402402    void firstInc(UEdge& edge, bool& direction, const Node& node) const {
    403       if (Parent::upper(node)) {
    404         Parent::firstDown(edge, node);
     403      if (Parent::aNode(node)) {
     404        Parent::firstOut(edge, node);
    405405        direction = true;
    406406      } else {
    407         Parent::firstUp(edge, node);
     407        Parent::firstIn(edge, node);
    408408        direction = static_cast<UEdge&>(edge) == INVALID;
    409409      }
     
    411411    void nextInc(UEdge& edge, bool& direction) const {
    412412      if (direction) {
    413         Parent::nextDown(edge);
    414       } else {
    415         Parent::nextUp(edge);
     413        Parent::nextOut(edge);
     414      } else {
     415        Parent::nextIn(edge);
    416416        if (edge == INVALID) direction = true;
    417417      }
     
    427427
    428428    class Edge : public UEdge {
    429       friend class UBipartiteGraphExtender;
     429      friend class BpUGraphExtender;
    430430    protected:
    431431      bool forward;
     
    462462
    463463    void firstOut(Edge& edge, const Node& node) const {
    464       if (Parent::upper(node)) {
    465         Parent::firstDown(edge, node);
     464      if (Parent::aNode(node)) {
     465        Parent::firstOut(edge, node);
    466466        edge.forward = true;
    467467      } else {
    468         Parent::firstUp(edge, node);
     468        Parent::firstIn(edge, node);
    469469        edge.forward = static_cast<UEdge&>(edge) == INVALID;
    470470      }
     
    472472    void nextOut(Edge& edge) const {
    473473      if (edge.forward) {
    474         Parent::nextDown(edge);
    475       } else {
    476         Parent::nextUp(edge);
     474        Parent::nextOut(edge);
     475      } else {
     476        Parent::nextIn(edge);
    477477        edge.forward = static_cast<UEdge&>(edge) == INVALID;
    478478      }
     
    480480
    481481    void firstIn(Edge& edge, const Node& node) const {
    482       if (Parent::lower(node)) {
    483         Parent::firstUp(edge, node);
     482      if (Parent::bNode(node)) {
     483        Parent::firstIn(edge, node);
    484484        edge.forward = true;   
    485485      } else {
    486         Parent::firstDown(edge, node);
     486        Parent::firstOut(edge, node);
    487487        edge.forward = static_cast<UEdge&>(edge) == INVALID;
    488488      }
     
    490490    void nextIn(Edge& edge) const {
    491491      if (edge.forward) {
    492         Parent::nextUp(edge);
    493       } else {
    494         Parent::nextDown(edge);
     492        Parent::nextIn(edge);
     493      } else {
     494        Parent::nextOut(edge);
    495495        edge.forward = static_cast<UEdge&>(edge) == INVALID;
    496496      }
     
    498498
    499499    Node source(const Edge& edge) const {
    500       return edge.forward ? Parent::upperNode(edge) : Parent::lowerNode(edge);
     500      return edge.forward ? Parent::aNode(edge) : Parent::bNode(edge);
    501501    }
    502502    Node target(const Edge& edge) const {
    503       return edge.forward ? Parent::lowerNode(edge) : Parent::upperNode(edge);
     503      return edge.forward ? Parent::bNode(edge) : Parent::aNode(edge);
    504504    }
    505505
     
    535535    }
    536536
    537     class UpperNode : public Node {
    538       friend class UBipartiteGraphExtender;
     537    class ANode : public Node {
     538      friend class BpUGraphExtender;
    539539    public:
    540       UpperNode() {}
    541       UpperNode(const Node& node) : Node(node) {
    542         LEMON_ASSERT(Parent::upper(node) || node == INVALID,
     540      ANode() {}
     541      ANode(const Node& node) : Node(node) {
     542        LEMON_ASSERT(Parent::aNode(node) || node == INVALID,
    543543                     typename Parent::NodeSetError());
    544544      }
    545       UpperNode(Invalid) : Node(INVALID) {}
     545      ANode(Invalid) : Node(INVALID) {}
    546546    };
    547547
    548     void first(UpperNode& node) const {
    549       Parent::firstUpper(static_cast<Node&>(node));
    550     }
    551     void next(UpperNode& node) const {
    552       Parent::nextUpper(static_cast<Node&>(node));
    553     }
    554 
    555     int id(const UpperNode& node) const {
    556       return Parent::upperId(node);
    557     }
    558 
    559     class LowerNode : public Node {
    560       friend class UBipartiteGraphExtender;
     548    void first(ANode& node) const {
     549      Parent::firstANode(static_cast<Node&>(node));
     550    }
     551    void next(ANode& node) const {
     552      Parent::nextANode(static_cast<Node&>(node));
     553    }
     554
     555    int id(const ANode& node) const {
     556      return Parent::aNodeId(node);
     557    }
     558
     559    class BNode : public Node {
     560      friend class BpUGraphExtender;
    561561    public:
    562       LowerNode() {}
    563       LowerNode(const Node& node) : Node(node) {
    564         LEMON_ASSERT(Parent::lower(node) || node == INVALID,
     562      BNode() {}
     563      BNode(const Node& node) : Node(node) {
     564        LEMON_ASSERT(Parent::bNode(node) || node == INVALID,
    565565                     typename Parent::NodeSetError());
    566566      }
    567       LowerNode(Invalid) : Node(INVALID) {}
     567      BNode(Invalid) : Node(INVALID) {}
    568568    };
    569569
    570     void first(LowerNode& node) const {
    571       Parent::firstLower(static_cast<Node&>(node));
    572     }
    573     void next(LowerNode& node) const {
    574       Parent::nextLower(static_cast<Node&>(node));
     570    void first(BNode& node) const {
     571      Parent::firstBNode(static_cast<Node&>(node));
     572    }
     573    void next(BNode& node) const {
     574      Parent::nextBNode(static_cast<Node&>(node));
    575575    }
    576576 
    577     int id(const LowerNode& node) const {
    578       return Parent::upperId(node);
     577    int id(const BNode& node) const {
     578      return Parent::aNodeId(node);
    579579    }
    580580
     
    584584      return Parent::maxNodeId();
    585585    }
    586     int maxId(LowerNode) const {
    587       return Parent::maxLowerId();
    588     }
    589     int maxId(UpperNode) const {
    590       return Parent::maxUpperId();
     586    int maxId(BNode) const {
     587      return Parent::maxBNodeId();
     588    }
     589    int maxId(ANode) const {
     590      return Parent::maxANodeId();
    591591    }
    592592    int maxId(Edge) const {
     
    601601      return Parent::nodeFromId(id);
    602602    }
    603     UpperNode fromId(int id, UpperNode) const {
    604       return Parent::fromUpperId(id);
    605     }
    606     LowerNode fromId(int id, LowerNode) const {
    607       return Parent::fromLowerId(id);
     603    ANode fromId(int id, ANode) const {
     604      return Parent::fromANodeId(id);
     605    }
     606    BNode fromId(int id, BNode) const {
     607      return Parent::fromBNodeId(id);
    608608    }
    609609    Edge fromId(int id, Edge) const {
Note: See TracChangeset for help on using the changeset viewer.