COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changes in / [1104:a78e5b779b69:1101:15e233f588da] in lemon-main


Ignore:
Location:
lemon
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • lemon/capacity_scaling.h

    r1104 r1092  
    164164
    165165    // Parameters of the problem
    166     bool _has_lower;
     166    bool _have_lower;
    167167    Value _sum_supply;
    168168
    … …  
    357357    template <typename LowerMap>
    358358    CapacityScaling& lowerMap(const LowerMap& map) {
    359       _has_lower = true;
     359      _have_lower = true;
    360360      for (ArcIt a(_graph); a != INVALID; ++a) {
    361361        _lower[_arc_idf[a]] = map[a];
     362        _lower[_arc_idb[a]] = map[a];
    362363      }
    363364      return *this;
    … …  
    543544        _cost[j] = _forward[j] ? 1 : -1;
    544545      }
    545       _has_lower = false;
     546      _have_lower = false;
    546547      return *this;
    547548    }
    … …  
    754755      const Value MAX = std::numeric_limits<Value>::max();
    755756      int last_out;
    756       if (_has_lower) {
     757      if (_have_lower) {
    757758        for (int i = 0; i != _root; ++i) {
    758759          last_out = _first_out[i+1];
    … …  
    839840    }
    840841
    841     // Check if the upper bound is greater than or equal to the lower bound
    842     // on each forward arc.
     842    // Check if the upper bound is greater or equal to the lower bound
     843    // on each arc.
    843844    bool checkBoundMaps() {
    844845      for (int j = 0; j != _res_arc_num; ++j) {
    845         if (_forward[j] && _upper[j] < _lower[j]) return false;
     846        if (_upper[j] < _lower[j]) return false;
    846847      }
    847848      return true;
    … …  
    857858
    858859      // Handle non-zero lower bounds
    859       if (_has_lower) {
     860      if (_have_lower) {
    860861        int limit = _first_out[_root];
    861862        for (int j = 0; j != limit; ++j) {
    862           if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];
     863          if (!_forward[j]) _res_cap[j] += _lower[j];
    863864        }
    864865      }

  • lemon/cost_scaling.h

    r1104 r1093  
    257257
    258258    // Parameters of the problem
    259     bool _has_lower;
     259    bool _have_lower;
    260260    Value _sum_supply;
    261261    int _sup_node_num;
    … …  
    373373    template <typename LowerMap>
    374374    CostScaling& lowerMap(const LowerMap& map) {
    375       _has_lower = true;
     375      _have_lower = true;
    376376      for (ArcIt a(_graph); a != INVALID; ++a) {
    377377        _lower[_arc_idf[a]] = map[a];
     378        _lower[_arc_idb[a]] = map[a];
    378379      }
    379380      return *this;
    … …  
    568569        _scost[_reverse[j]] = 0;
    569570      }
    570       _has_lower = false;
     571      _have_lower = false;
    571572      return *this;
    572573    }
    … …  
    780781      const Value MAX = std::numeric_limits<Value>::max();
    781782      int last_out;
    782       if (_has_lower) {
     783      if (_have_lower) {
    783784        for (int i = 0; i != _root; ++i) {
    784785          last_out = _first_out[i+1];
    … …  
    837838        sup[n] = _supply[_node_id[n]];
    838839      }
    839       if (_has_lower) {
     840      if (_have_lower) {
    840841        for (ArcIt a(_graph); a != INVALID; ++a) {
    841842          int j = _arc_idf[a];
    … …  
    907908    }
    908909
    909     // Check if the upper bound is greater than or equal to the lower bound
    910     // on each forward arc.
     910    // Check if the upper bound is greater or equal to the lower bound
     911    // on each arc.
    911912    bool checkBoundMaps() {
    912913      for (int j = 0; j != _res_arc_num; ++j) {
    913         if (_forward[j] && _upper[j] < _lower[j]) return false;
     914        if (_upper[j] < _lower[j]) return false;
    914915      }
    915916      return true;
    … …  
    991992
    992993      // Handle non-zero lower bounds
    993       if (_has_lower) {
     994      if (_have_lower) {
    994995        int limit = _first_out[_root];
    995996        for (int j = 0; j != limit; ++j) {
    996           if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];
     997          if (!_forward[j]) _res_cap[j] += _lower[j];
    997998        }
    998999      }

  • lemon/cycle_canceling.h

    r1104 r1092  
    196196
    197197    // Parameters of the problem
    198     bool _has_lower;
     198    bool _have_lower;
    199199    Value _sum_supply;
    200200
    … …  
    279279    template <typename LowerMap>
    280280    CycleCanceling& lowerMap(const LowerMap& map) {
    281       _has_lower = true;
     281      _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];
    284285      }
    285286      return *this;
    … …  
    471472        _cost[_reverse[j]] = 0;
    472473      }
    473       _has_lower = false;
     474      _have_lower = false;
    474475      return *this;
    475476    }
    … …  
    684685      const Value MAX = std::numeric_limits<Value>::max();
    685686      int last_out;
    686       if (_has_lower) {
     687      if (_have_lower) {
    687688        for (int i = 0; i != _root; ++i) {
    688689          last_out = _first_out[i+1];
    … …  
    727728        sup[n] = _supply[_node_id[n]];
    728729      }
    729       if (_has_lower) {
     730      if (_have_lower) {
    730731        for (ArcIt a(_graph); a != INVALID; ++a) {
    731732          int j = _arc_idf[a];
    … …  
    784785    }
    785786
    786     // Check if the upper bound is greater than or equal to the lower bound
    787     // on each forward arc.
     787    // Check if the upper bound is greater or equal to the lower bound
     788    // on each arc.
    788789    bool checkBoundMaps() {
    789790      for (int j = 0; j != _res_arc_num; ++j) {
    790         if (_forward[j] && _upper[j] < _lower[j]) return false;
     791        if (_upper[j] < _lower[j]) return false;
    791792      }
    792793      return true;
    … …  
    835836
    836837      // Handle non-zero lower bounds
    837       if (_has_lower) {
     838      if (_have_lower) {
    838839        int limit = _first_out[_root];
    839840        for (int j = 0; j != limit; ++j) {
    840           if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];
     841          if (!_forward[j]) _res_cap[j] += _lower[j];
    841842        }
    842843      }

  • lemon/network_simplex.h

    r1104 r1092  
    199199
    200200    // Parameters of the problem
    201     bool _has_lower;
     201    bool _have_lower;
    202202    SupplyType _stype;
    203203    Value _sum_supply;
    … …  
    683683    template <typename LowerMap>
    684684    NetworkSimplex& lowerMap(const LowerMap& map) {
    685       _has_lower = true;
     685      _have_lower = true;
    686686      for (ArcIt a(_graph); a != INVALID; ++a) {
    687687        _lower[_arc_id[a]] = map[a];
    … …  
    880880        _cost[i] = 1;
    881881      }
    882       _has_lower = false;
     882      _have_lower = false;
    883883      _stype = GEQ;
    884884      return *this;
    … …  
    10731073
    10741074      // Remove non-zero lower bounds
    1075       if (_has_lower) {
     1075      if (_have_lower) {
    10761076        for (int i = 0; i != _arc_num; ++i) {
    10771077          Value c = _lower[i];
    … …  
    12361236    }
    12371237
    1238     // Check if the upper bound is greater than or equal to the lower bound
     1238    // Check if the upper bound is greater or equal to the lower bound
    12391239    // on each arc.
    12401240    bool checkBoundMaps() {
    … …  
    16131613
    16141614      // Transform the solution and the supply map to the original form
    1615       if (_has_lower) {
     1615      if (_have_lower) {
    16161616        for (int i = 0; i != _arc_num; ++i) {
    16171617          Value c = _lower[i];
Note: See TracChangeset for help on using the changeset viewer.