COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Ticket #478: 478-330264b171cf-c0c2f5c87aa6.patch

File 478-330264b171cf-c0c2f5c87aa6.patch, 10.0 KB (added by Peter Kovacs, 11 years ago)

  • lemon/capacity_scaling.h 

    # HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1381994977 -7200
# Node ID 330264b171cf7ed09fb3117033abddc4d3ebf74d
# Parent  ee9bac10f58e04dfc86f266cae4a1ad968cd8d20
Fix debug checking + simplify lower bound handling (#478)

diff --git a/lemon/capacity_scaling.h b/lemon/capacity_scaling.h
    a b  
    356356      _have_lower = true;
    357357      for (ArcIt a(_graph); a != INVALID; ++a) {
    358358        _lower[_arc_idf[a]] = map[a];
    359         _lower[_arc_idb[a]] = map[a];
    360359      }
    361360      return *this;
    362361    }
    … …  
    836835      return OPTIMAL;
    837836    }
    838837   
    839     // Check if the upper bound is greater or equal to the lower bound
    840     // on each arc.
     838    // Check if the upper bound is greater than or equal to the lower bound
     839    // on each forward arc.
    841840    bool checkBoundMaps() {
    842841      for (int j = 0; j != _res_arc_num; ++j) {
    843         if (_upper[j] < _lower[j]) return false;
     842        if (_forward[j] && _upper[j] < _lower[j]) return false;
    844843      }
    845844      return true;
    846845    }
    … …  
    857856      if (_have_lower) {
    858857        int limit = _first_out[_root];
    859858        for (int j = 0; j != limit; ++j) {
    860           if (!_forward[j]) _res_cap[j] += _lower[j];
     859          if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];
    861860        }
    862861      }
    863862

  • lemon/cost_scaling.h 

    diff --git a/lemon/cost_scaling.h b/lemon/cost_scaling.h
    a b  
    370370      _have_lower = true;
    371371      for (ArcIt a(_graph); a != INVALID; ++a) {
    372372        _lower[_arc_idf[a]] = map[a];
    373         _lower[_arc_idb[a]] = map[a];
    374373      }
    375374      return *this;
    376375    }
    … …  
    902901      return OPTIMAL;
    903902    }
    904903   
    905     // Check if the upper bound is greater or equal to the lower bound
    906     // on each arc.
     904    // Check if the upper bound is greater than or equal to the lower bound
     905    // on each forward arc.
    907906    bool checkBoundMaps() {
    908907      for (int j = 0; j != _res_arc_num; ++j) {
    909         if (_upper[j] < _lower[j]) return false;
     908        if (_forward[j] && _upper[j] < _lower[j]) return false;
    910909      }
    911910      return true;
    912911    }
    … …  
    989988      if (_have_lower) {
    990989        int limit = _first_out[_root];
    991990        for (int j = 0; j != limit; ++j) {
    992           if (!_forward[j]) _res_cap[j] += _lower[j];
     991          if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];
    993992        }
    994993      }
    995994    }

  • lemon/cycle_canceling.h 

    diff --git a/lemon/cycle_canceling.h b/lemon/cycle_canceling.h
    a b  
    281281      _have_lower = true;
    282282      for (ArcIt a(_graph); a != INVALID; ++a) {
    283283        _lower[_arc_idf[a]] = map[a];
    284         _lower[_arc_idb[a]] = map[a];
    285284      }
    286285      return *this;
    287286    }
    … …  
    784783      return OPTIMAL;
    785784    }
    786785   
    787     // Check if the upper bound is greater or equal to the lower bound
    788     // on each arc.
     786    // Check if the upper bound is greater than or equal to the lower bound
     787    // on each forward arc.
    789788    bool checkBoundMaps() {
    790789      for (int j = 0; j != _res_arc_num; ++j) {
    791         if (_upper[j] < _lower[j]) return false;
     790        if (_forward[j] && _upper[j] < _lower[j]) return false;
    792791      }
    793792      return true;
    794793    }
    … …  
    838837      if (_have_lower) {
    839838        int limit = _first_out[_root];
    840839        for (int j = 0; j != limit; ++j) {
    841           if (!_forward[j]) _res_cap[j] += _lower[j];
     840          if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];
    842841        }
    843842      }
    844843    }

  • lemon/network_simplex.h 

    diff --git a/lemon/network_simplex.h b/lemon/network_simplex.h
    a b  
    12351235      return true;
    12361236    }
    12371237   
    1238     // Check if the upper bound is greater or equal to the lower bound
     1238    // Check if the upper bound is greater than or equal to the lower bound
    12391239    // on each arc.
    12401240    bool checkBoundMaps() {
    12411241      for (int j = 0; j != _arc_num; ++j) {

  • lemon/capacity_scaling.h 

    # HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1381995057 -7200
# Node ID c0c2f5c87aa648bc03a301c4443797ea80b6b83d
# Parent  330264b171cf7ed09fb3117033abddc4d3ebf74d
Rename field in min cost flow codes (#478)

diff --git a/lemon/capacity_scaling.h b/lemon/capacity_scaling.h
    a b  
    160160    int _root;
    161161
    162162    // Parameters of the problem
    163     bool _have_lower;
     163    bool _has_lower;
    164164    Value _sum_supply;
    165165
    166166    // Data structures for storing the digraph
    … …  
    353353    /// \return <tt>(*this)</tt>
    354354    template <typename LowerMap>
    355355    CapacityScaling& lowerMap(const LowerMap& map) {
    356       _have_lower = true;
     356      _has_lower = true;
    357357      for (ArcIt a(_graph); a != INVALID; ++a) {
    358358        _lower[_arc_idf[a]] = map[a];
    359359      }
    … …  
    539539        _upper[j] = INF;
    540540        _cost[j] = _forward[j] ? 1 : -1;
    541541      }
    542       _have_lower = false;
     542      _has_lower = false;
    543543      return *this;
    544544    }
    545545
    … …  
    750750      // Remove non-zero lower bounds
    751751      const Value MAX = std::numeric_limits<Value>::max();
    752752      int last_out;
    753       if (_have_lower) {
     753      if (_has_lower) {
    754754        for (int i = 0; i != _root; ++i) {
    755755          last_out = _first_out[i+1];
    756756          for (int j = _first_out[i]; j != last_out; ++j) {
    … …  
    853853        pt = startWithoutScaling();
    854854
    855855      // Handle non-zero lower bounds
    856       if (_have_lower) {
     856      if (_has_lower) {
    857857        int limit = _first_out[_root];
    858858        for (int j = 0; j != limit; ++j) {
    859859          if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];

  • lemon/cost_scaling.h 

    diff --git a/lemon/cost_scaling.h b/lemon/cost_scaling.h
    a b  
    251251    int _root;
    252252
    253253    // Parameters of the problem
    254     bool _have_lower;
     254    bool _has_lower;
    255255    Value _sum_supply;
    256256    int _sup_node_num;
    257257
    … …  
    367367    /// \return <tt>(*this)</tt>
    368368    template <typename LowerMap>
    369369    CostScaling& lowerMap(const LowerMap& map) {
    370       _have_lower = true;
     370      _has_lower = true;
    371371      for (ArcIt a(_graph); a != INVALID; ++a) {
    372372        _lower[_arc_idf[a]] = map[a];
    373373      }
    … …  
    562562        _scost[j] = 0;
    563563        _scost[_reverse[j]] = 0;
    564564      }
    565       _have_lower = false;
     565      _has_lower = false;
    566566      return *this;
    567567    }
    568568
    … …  
    774774      // Remove infinite upper bounds and check negative arcs
    775775      const Value MAX = std::numeric_limits<Value>::max();
    776776      int last_out;
    777       if (_have_lower) {
     777      if (_has_lower) {
    778778        for (int i = 0; i != _root; ++i) {
    779779          last_out = _first_out[i+1];
    780780          for (int j = _first_out[i]; j != last_out; ++j) {
    … …  
    831831      for (NodeIt n(_graph); n != INVALID; ++n) {
    832832        sup[n] = _supply[_node_id[n]];
    833833      }
    834       if (_have_lower) {
     834      if (_has_lower) {
    835835        for (ArcIt a(_graph); a != INVALID; ++a) {
    836836          int j = _arc_idf[a];
    837837          Value c = _lower[j];
    … …  
    985985      }
    986986
    987987      // Handle non-zero lower bounds
    988       if (_have_lower) {
     988      if (_has_lower) {
    989989        int limit = _first_out[_root];
    990990        for (int j = 0; j != limit; ++j) {
    991991          if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];

  • lemon/cycle_canceling.h 

    diff --git a/lemon/cycle_canceling.h b/lemon/cycle_canceling.h
    a b  
    195195    int _root;
    196196
    197197    // Parameters of the problem
    198     bool _have_lower;
     198    bool _has_lower;
    199199    Value _sum_supply;
    200200
    201201    // Data structures for storing the digraph
    … …  
    278278    /// \return <tt>(*this)</tt>
    279279    template <typename LowerMap>
    280280    CycleCanceling& lowerMap(const LowerMap& map) {
    281       _have_lower = true;
     281      _has_lower = true;
    282282      for (ArcIt a(_graph); a != INVALID; ++a) {
    283283        _lower[_arc_idf[a]] = map[a];
    284284      }
    … …  
    470470        _cost[j] = 0;
    471471        _cost[_reverse[j]] = 0;
    472472      }
    473       _have_lower = false;
     473      _has_lower = false;
    474474      return *this;
    475475    }
    476476
    … …  
    683683      // Remove infinite upper bounds and check negative arcs
    684684      const Value MAX = std::numeric_limits<Value>::max();
    685685      int last_out;
    686       if (_have_lower) {
     686      if (_has_lower) {
    687687        for (int i = 0; i != _root; ++i) {
    688688          last_out = _first_out[i+1];
    689689          for (int j = _first_out[i]; j != last_out; ++j) {
    … …  
    726726      for (NodeIt n(_graph); n != INVALID; ++n) {
    727727        sup[n] = _supply[_node_id[n]];
    728728      }
    729       if (_have_lower) {
     729      if (_has_lower) {
    730730        for (ArcIt a(_graph); a != INVALID; ++a) {
    731731          int j = _arc_idf[a];
    732732          Value c = _lower[j];
    … …  
    834834      }
    835835
    836836      // Handle non-zero lower bounds
    837       if (_have_lower) {
     837      if (_has_lower) {
    838838        int limit = _first_out[_root];
    839839        for (int j = 0; j != limit; ++j) {
    840840          if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];

  • lemon/network_simplex.h 

    diff --git a/lemon/network_simplex.h b/lemon/network_simplex.h
    a b  
    198198    int _search_arc_num;
    199199
    200200    // Parameters of the problem
    201     bool _have_lower;
     201    bool _has_lower;
    202202    SupplyType _stype;
    203203    Value _sum_supply;
    204204
    … …  
    682682    /// \return <tt>(*this)</tt>
    683683    template <typename LowerMap>
    684684    NetworkSimplex& lowerMap(const LowerMap& map) {
    685       _have_lower = true;
     685      _has_lower = true;
    686686      for (ArcIt a(_graph); a != INVALID; ++a) {
    687687        _lower[_arc_id[a]] = map[a];
    688688      }
    … …  
    879879        _upper[i] = INF;
    880880        _cost[i] = 1;
    881881      }
    882       _have_lower = false;
     882      _has_lower = false;
    883883      _stype = GEQ;
    884884      return *this;
    885885    }
    … …  
    10721072          "Upper bounds must be greater or equal to the lower bounds");
    10731073
    10741074      // Remove non-zero lower bounds
    1075       if (_have_lower) {
     1075      if (_has_lower) {
    10761076        for (int i = 0; i != _arc_num; ++i) {
    10771077          Value c = _lower[i];
    10781078          if (c >= 0) {
    … …  
    16121612      }
    16131613
    16141614      // Transform the solution and the supply map to the original form
    1615       if (_have_lower) {
     1615      if (_has_lower) {
    16161616        for (int i = 0; i != _arc_num; ++i) {
    16171617          Value c = _lower[i];
    16181618          if (c != 0) {