COIN-OR::LEMON - Graph Library

Changeset 565:18787f6db0db in lemon-0.x


Ignore:
Timestamp:
05/07/04 08:33:02 (16 years ago)
Author:
marci
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@740
Message:

ResGraphWrapper? mods.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/hugo/graph_wrapper.h

    r561 r565  
    598598      friend class ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>;
    599599    protected:
    600       bool forward; //true, iff forward
     600      bool backward; //true, iff backward
    601601//      typename Graph::Edge e;
    602602    public:
    603603      Edge() { }
    604       Edge(const typename Graph::Edge& _e, bool _forward) :
    605         Graph::Edge(_e), forward(_forward) { }
    606       Edge(const Invalid& i) : Graph::Edge(i), forward(false) { }
     604      Edge(const typename Graph::Edge& _e, bool _backward) :
     605        Graph::Edge(_e), backward(_backward) { }
     606      Edge(const Invalid& i) : Graph::Edge(i), backward(true) { }
    607607//the unique invalid iterator
    608608      friend bool operator==(const Edge& u, const Edge& v) {
    609         return (v.forward==u.forward &&
     609        return (v.backward==u.backward &&
    610610                static_cast<typename Graph::Edge>(u)==
    611611                static_cast<typename Graph::Edge>(v));
    612612      }
    613613      friend bool operator!=(const Edge& u, const Edge& v) {
    614         return (v.forward!=u.forward ||
     614        return (v.backward!=u.backward ||
    615615                static_cast<typename Graph::Edge>(u)!=
    616616                static_cast<typename Graph::Edge>(v));
     
    623623      typename Graph::OutEdgeIt out;
    624624      typename Graph::InEdgeIt in;
    625       bool forward;
     625      bool backward;
    626626    public:
    627627      OutEdgeIt() { }
    628628      //FIXME
    629629//      OutEdgeIt(const Edge& e) : Edge(e) { }
    630       OutEdgeIt(const Invalid& i) : out(i), in(i), forward(false) { }
     630      OutEdgeIt(const Invalid& i) : out(i), in(i), backward(true) { }
    631631//the unique invalid iterator
    632632      OutEdgeIt(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& resG, Node v) {
    633         forward=true;
     633        backward=false;
    634634        resG.graph->first(out, v);
    635635        while( resG.graph->valid(out) && !(resG.resCap(*this)>0) ) { resG.graph->next(out); }
    636636        if (!resG.graph->valid(out)) {
    637           forward=false;
     637          backward=true;
    638638          resG.graph->first(in, v);
    639639          while( resG.graph->valid(in) && !(resG.resCap(*this)>0) ) { resG.graph->next(in); }
     
    645645//      if (this->forward) e=out; else e=in;
    646646//      return e;
    647         if (this->forward)
    648           return Edge(out, this->forward);
     647        if (this->backward)
     648          return Edge(in, this->backward);
    649649        else
    650           return Edge(in, this->forward);
     650          return Edge(out, this->backward);
    651651      }
    652652    };
     
    657657      typename Graph::OutEdgeIt out;
    658658      typename Graph::InEdgeIt in;
    659       bool forward;
     659      bool backward;
    660660    public:
    661661      InEdgeIt() { }
    662662      //FIXME
    663663//      OutEdgeIt(const Edge& e) : Edge(e) { }
    664       InEdgeIt(const Invalid& i) : out(i), in(i), forward(false) { }
     664      InEdgeIt(const Invalid& i) : out(i), in(i), backward(true) { }
    665665//the unique invalid iterator
    666666      InEdgeIt(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& resG, Node v) {
    667         forward=true;
     667        backward=false;
    668668        resG.graph->first(in, v);
    669669        while( resG.graph->valid(in) && !(resG.resCap(*this)>0) ) { resG.graph->next(in); }
    670670        if (!resG.graph->valid(in)) {
    671           forward=false;
     671          backward=true;
    672672          resG.graph->first(out, v);
    673673          while( resG.graph->valid(out) && !(resG.resCap(*this)>0) ) { resG.graph->next(out); }
     
    679679//      if (this->forward) e=out; else e=in;
    680680//      return e;
    681         if (this->forward)
    682           return Edge(in, this->forward);
     681        if (this->backward)
     682          return Edge(out, this->backward);
    683683        else
    684           return Edge(out, this->forward);
     684          return Edge(in, this->backward);
    685685      }
    686686    };
     
    690690    protected:
    691691      typename Graph::EdgeIt e;
    692       bool forward;
     692      bool backward;
    693693    public:
    694694      EdgeIt() { }
    695       EdgeIt(const Invalid& i) : e(i), forward(false) { }
     695      EdgeIt(const Invalid& i) : e(i), backward(true) { }
    696696      EdgeIt(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& resG) {
    697         forward=true;
     697        backward=false;
    698698        resG.graph->first(e);
    699699        while (resG.graph->valid(e) && !(resG.resCap(*this)>0)) resG.graph->next(e);
    700700        if (!resG.graph->valid(e)) {
    701           forward=false;
     701          backward=true;
    702702          resG.graph->first(e);
    703703          while (resG.graph->valid(e) && !(resG.resCap(*this)>0)) resG.graph->next(e);
     
    705705      }
    706706      operator Edge() const {
    707         return Edge(e, this->forward);
     707        return Edge(e, this->backward);
    708708      }
    709709    };
     
    727727//    NodeIt& next(NodeIt& n) const { GraphWrapper<Graph>::next(n); return n; }
    728728    OutEdgeIt& next(OutEdgeIt& e) const {
    729       if (e.forward) {
     729      if (!e.backward) {
    730730        Node v=this->graph->aNode(e.out);
    731731        this->graph->next(e.out);
     
    733733          this->graph->next(e.out); }
    734734        if (!this->graph->valid(e.out)) {
    735           e.forward=false;
     735          e.backward=true;
    736736          this->graph->first(e.in, v);
    737737          while( this->graph->valid(e.in) && !(resCap(e)>0) ) {
     
    747747//     FIXME Not tested
    748748    InEdgeIt& next(InEdgeIt& e) const {
    749       if (e.forward) {
     749      if (!e.backward) {
    750750        Node v=this->graph->aNode(e.in);
    751751        this->graph->next(e.in);
     
    753753          this->graph->next(e.in); }
    754754        if (!this->graph->valid(e.in)) {
    755           e.forward=false;
     755          e.backward=true;
    756756          this->graph->first(e.out, v);
    757757          while( this->graph->valid(e.out) && !(resCap(e)>0) ) {
     
    766766    }
    767767    EdgeIt& next(EdgeIt& e) const {
    768       if (e.forward) {
     768      if (!e.backward) {
    769769        this->graph->next(e.e);
    770770        while( this->graph->valid(e.e) && !(resCap(e)>0) ) {
    771771          this->graph->next(e.e); }
    772772        if (!this->graph->valid(e.e)) {
    773           e.forward=false;
     773          e.backward=true;
    774774          this->graph->first(e.e);
    775775          while( this->graph->valid(e.e) && !(resCap(e)>0) ) {
     
    785785
    786786    Node tail(Edge e) const {
    787       return ((e.forward) ? this->graph->tail(e) : this->graph->head(e)); }
     787      return ((!e.backward) ? this->graph->tail(e) : this->graph->head(e)); }
    788788    Node head(Edge e) const {
    789       return ((e.forward) ? this->graph->head(e) : this->graph->tail(e)); }
     789      return ((!e.backward) ? this->graph->head(e) : this->graph->tail(e)); }
    790790
    791791    Node aNode(OutEdgeIt e) const {
    792       return ((e.forward) ? this->graph->aNode(e.out) :
     792      return ((!e.backward) ? this->graph->aNode(e.out) :
    793793              this->graph->aNode(e.in)); }
    794794    Node bNode(OutEdgeIt e) const {
    795       return ((e.forward) ? this->graph->bNode(e.out) :
     795      return ((!e.backward) ? this->graph->bNode(e.out) :
    796796              this->graph->bNode(e.in)); }
    797797
    798798    Node aNode(InEdgeIt e) const {
    799       return ((e.forward) ? this->graph->aNode(e.in) :
     799      return ((!e.backward) ? this->graph->aNode(e.in) :
    800800              this->graph->aNode(e.out)); }
    801801    Node bNode(InEdgeIt e) const {
    802       return ((e.forward) ? this->graph->bNode(e.in) :
     802      return ((!e.backward) ? this->graph->bNode(e.in) :
    803803              this->graph->bNode(e.out)); }
    804804
     
    817817    }
    818818
    819     bool forward(const Edge& e) const { return e.forward; }
    820     bool backward(const Edge& e) const { return !e.forward; }
     819    bool forward(const Edge& e) const { return !e.backward; }
     820    bool backward(const Edge& e) const { return e.backward; }
    821821
    822822    void augment(const Edge& e, Number a) const {
    823       if (e.forward) 
     823      if (!e.backward) 
    824824//      flow->set(e.out, flow->get(e.out)+a);
    825825        flow->set(e, (*flow)[e]+a);
     
    830830
    831831    Number resCap(const Edge& e) const {
    832       if (e.forward)
     832      if (!e.backward)
    833833//      return (capacity->get(e.out)-flow->get(e.out));
    834834        return ((*capacity)[e]-(*flow)[e]);
     
    855855      EdgeMap(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& _G, T a) : forward_map(*(_G.graph), a), backward_map(*(_G.graph), a) { }
    856856      void set(Edge e, T a) {
    857         if (e.forward)
     857        if (!e.backward)
    858858          forward_map.set(e.out, a);
    859859        else
     
    861861      }
    862862      T operator[](Edge e) const {
    863         if (e.forward)
     863        if (!e.backward)
    864864          return forward_map[e.out];
    865865        else
Note: See TracChangeset for help on using the changeset viewer.