COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Ticket #179: 179-10-impl-impr-8642452f583c.patch

File 179-10-impl-impr-8642452f583c.patch, 9.2 KB (added by Peter Kovacs, 15 years ago)

  • lemon/hartmann_orlin.h 

    # HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1250023955 -7200
# Node ID 8642452f583c94b3f0bbb9a023ae7f402c11a196
# Parent  00dd2f3ccfa9844f9a7c98b86948f9e56462a06b
Simplify comparisons in min mean cycle classes (#179)
using extreme INF values instead of bool flags.

diff --git a/lemon/hartmann_orlin.h b/lemon/hartmann_orlin.h
    a b  
    2525/// \brief Hartmann-Orlin's algorithm for finding a minimum mean cycle.
    2626
    2727#include <vector>
     28#include <limits>
    2829#include <lemon/core.h>
    2930#include <lemon/path.h>
    3031#include <lemon/tolerance.h>
    … …  
    149150    // Data sturcture for path data
    150151    struct PathData
    151152    {
    152       bool found;
    153153      LargeValue dist;
    154154      Arc pred;
    155       PathData(bool f = false, LargeValue d = 0, Arc p = INVALID) :
    156         found(f), dist(d), pred(p) {}
     155      PathData(LargeValue d, Arc p = INVALID) :
     156        dist(d), pred(p) {}
    157157    };
    158158
    159159    typedef typename Digraph::template NodeMap<std::vector<PathData> >
    … …  
    190190
    191191    Tolerance _tolerance;
    192192
     193    // Infinite constant
     194    const LargeValue INF;
     195
    193196  public:
    194197
    195198    /// \name Named Template Parameters
    … …  
    244247                   const LengthMap &length ) :
    245248      _gr(digraph), _length(length), _comp(digraph), _out_arcs(digraph),
    246249      _best_found(false), _best_length(0), _best_size(1),
    247       _cycle_path(NULL), _local_path(false), _data(digraph)
     250      _cycle_path(NULL), _local_path(false), _data(digraph),
     251      INF(std::numeric_limits<LargeValue>::has_infinity ?
     252          std::numeric_limits<LargeValue>::infinity() :
     253          std::numeric_limits<LargeValue>::max())
    248254    {}
    249255
    250256    /// Destructor.
    … …  
    471477        return false;
    472478      }     
    473479      for (int i = 0; i < n; ++i) {
    474         _data[(*_nodes)[i]].resize(n + 1);
     480        _data[(*_nodes)[i]].resize(n + 1, PathData(INF));
    475481      }
    476482      return true;
    477483    }
    … …  
    481487    // node to node v containing exactly k arcs.
    482488    void processRounds() {
    483489      Node start = (*_nodes)[0];
    484       _data[start][0] = PathData(true, 0);
     490      _data[start][0] = PathData(0);
    485491      _process.clear();
    486492      _process.push_back(start);
    487493
    … …  
    516522          e = _out_arcs[u][j];
    517523          v = _gr.target(e);
    518524          d = _data[u][k-1].dist + _length[e];
    519           if (!_data[v][k].found) {
    520             next.push_back(v);
    521             _data[v][k] = PathData(true, _data[u][k-1].dist + _length[e], e);
    522           }
    523           else if (_tolerance.less(d, _data[v][k].dist)) {
    524             _data[v][k] = PathData(true, d, e);
     525          if (_tolerance.less(d, _data[v][k].dist)) {
     526            if (_data[v][k].dist == INF) next.push_back(v);
     527            _data[v][k] = PathData(d, e);
    525528          }
    526529        }
    527530      }
    … …  
    539542          e = _out_arcs[u][j];
    540543          v = _gr.target(e);
    541544          d = _data[u][k-1].dist + _length[e];
    542           if (!_data[v][k].found || _tolerance.less(d, _data[v][k].dist)) {
    543             _data[v][k] = PathData(true, d, e);
     545          if (_tolerance.less(d, _data[v][k].dist)) {
     546            _data[v][k] = PathData(d, e);
    544547          }
    545548        }
    546549      }
    … …  
    560563      _curr_found = false;
    561564      for (int i = 0; i < n; ++i) {
    562565        u = (*_nodes)[i];
    563         if (!_data[u][k].found) continue;
     566        if (_data[u][k].dist == INF) continue;
    564567        for (int j = k; j >= 0; --j) {
    565568          if (level[u].first == i && level[u].second > 0) {
    566569            // A cycle is found
    … …  
    585588        // Find node potentials
    586589        for (int i = 0; i < n; ++i) {
    587590          u = (*_nodes)[i];
    588           pi[u] = std::numeric_limits<LargeValue>::max();
     591          pi[u] = INF;
    589592          for (int j = 0; j <= k; ++j) {
    590             d = _data[u][j].dist * _curr_size - j * _curr_length;
    591             if (_data[u][j].found && _tolerance.less(d, pi[u])) {
    592               pi[u] = d;
     593            if (_data[u][j].dist < INF) {
     594              d = _data[u][j].dist * _curr_size - j * _curr_length;
     595              if (_tolerance.less(d, pi[u])) pi[u] = d;
    593596            }
    594597          }
    595598        }

  • lemon/howard.h 

    diff --git a/lemon/howard.h b/lemon/howard.h
    a b  
    2525/// \brief Howard's algorithm for finding a minimum mean cycle.
    2626
    2727#include <vector>
     28#include <limits>
    2829#include <lemon/core.h>
    2930#include <lemon/path.h>
    3031#include <lemon/tolerance.h>
    … …  
    177178
    178179    Tolerance _tolerance;
    179180 
     181    // Infinite constant
     182    const LargeValue INF;
     183
    180184  public:
    181185 
    182186    /// \name Named Template Parameters
    … …  
    229233    /// \param length The lengths (costs) of the arcs.
    230234    Howard( const Digraph &digraph,
    231235            const LengthMap &length ) :
    232       _gr(digraph), _length(length), _cycle_path(NULL), _local_path(false),
     236      _gr(digraph), _length(length), _best_found(false),
     237      _best_length(0), _best_size(1), _cycle_path(NULL), _local_path(false),
    233238      _policy(digraph), _reached(digraph), _level(digraph), _dist(digraph),
    234       _comp(digraph), _in_arcs(digraph)
     239      _comp(digraph), _in_arcs(digraph),
     240      INF(std::numeric_limits<LargeValue>::has_infinity ?
     241          std::numeric_limits<LargeValue>::infinity() :
     242          std::numeric_limits<LargeValue>::max())
    235243    {}
    236244
    237245    /// Destructor.
    … …  
    306314          if (!computeNodeDistances()) break;
    307315        }
    308316        // Update the best cycle (global minimum mean cycle)
    309         if ( !_best_found || (_curr_found &&
     317        if ( _curr_found && (!_best_found ||
    310318             _curr_length * _best_size < _best_length * _curr_size) ) {
    311319          _best_found = true;
    312320          _best_length = _curr_length;
    … …  
    445453        return false;
    446454      }
    447455      for (int i = 0; i < int(_nodes->size()); ++i) {
    448         _dist[(*_nodes)[i]] = std::numeric_limits<LargeValue>::max();
     456        _dist[(*_nodes)[i]] = INF;
    449457      }
    450458      Node u, v;
    451459      Arc e;

  • lemon/karp.h 

    diff --git a/lemon/karp.h b/lemon/karp.h
    a b  
    2525/// \brief Karp's algorithm for finding a minimum mean cycle.
    2626
    2727#include <vector>
     28#include <limits>
    2829#include <lemon/core.h>
    2930#include <lemon/path.h>
    3031#include <lemon/tolerance.h>
    … …  
    147148    // Data sturcture for path data
    148149    struct PathData
    149150    {
    150       bool found;
    151151      LargeValue dist;
    152152      Arc pred;
    153       PathData(bool f = false, LargeValue d = 0, Arc p = INVALID) :
    154         found(f), dist(d), pred(p) {}
     153      PathData(LargeValue d, Arc p = INVALID) :
     154        dist(d), pred(p) {}
    155155    };
    156156
    157157    typedef typename Digraph::template NodeMap<std::vector<PathData> >
    … …  
    185185    std::vector<Node> _process;
    186186
    187187    Tolerance _tolerance;
     188   
     189    // Infinite constant
     190    const LargeValue INF;
    188191
    189192  public:
    190193
    … …  
    240243          const LengthMap &length ) :
    241244      _gr(digraph), _length(length), _comp(digraph), _out_arcs(digraph),
    242245      _cycle_length(0), _cycle_size(1), _cycle_node(INVALID),
    243       _cycle_path(NULL), _local_path(false), _data(digraph)
     246      _cycle_path(NULL), _local_path(false), _data(digraph),
     247      INF(std::numeric_limits<LargeValue>::has_infinity ?
     248          std::numeric_limits<LargeValue>::infinity() :
     249          std::numeric_limits<LargeValue>::max())
    244250    {}
    245251
    246252    /// Destructor.
    … …  
    457463        return false;
    458464      }     
    459465      for (int i = 0; i < n; ++i) {
    460         _data[(*_nodes)[i]].resize(n + 1);
     466        _data[(*_nodes)[i]].resize(n + 1, PathData(INF));
    461467      }
    462468      return true;
    463469    }
    … …  
    467473    // node to node v containing exactly k arcs.
    468474    void processRounds() {
    469475      Node start = (*_nodes)[0];
    470       _data[start][0] = PathData(true, 0);
     476      _data[start][0] = PathData(0);
    471477      _process.clear();
    472478      _process.push_back(start);
    473479
    … …  
    492498          e = _out_arcs[u][j];
    493499          v = _gr.target(e);
    494500          d = _data[u][k-1].dist + _length[e];
    495           if (!_data[v][k].found) {
    496             next.push_back(v);
    497             _data[v][k] = PathData(true, _data[u][k-1].dist + _length[e], e);
    498           }
    499           else if (_tolerance.less(d, _data[v][k].dist)) {
    500             _data[v][k] = PathData(true, d, e);
     501          if (_tolerance.less(d, _data[v][k].dist)) {
     502            if (_data[v][k].dist == INF) next.push_back(v);
     503            _data[v][k] = PathData(d, e);
    501504          }
    502505        }
    503506      }
    … …  
    515518          e = _out_arcs[u][j];
    516519          v = _gr.target(e);
    517520          d = _data[u][k-1].dist + _length[e];
    518           if (!_data[v][k].found || _tolerance.less(d, _data[v][k].dist)) {
    519             _data[v][k] = PathData(true, d, e);
     521          if (_tolerance.less(d, _data[v][k].dist)) {
     522            _data[v][k] = PathData(d, e);
    520523          }
    521524        }
    522525      }
    … …  
    527530      int n = _nodes->size();
    528531      for (int i = 0; i < n; ++i) {
    529532        Node u = (*_nodes)[i];
    530         if (!_data[u][n].found) continue;
     533        if (_data[u][n].dist == INF) continue;
    531534        LargeValue length, max_length = 0;
    532535        int size, max_size = 1;
    533536        bool found_curr = false;
    534537        for (int k = 0; k < n; ++k) {
    535           if (!_data[u][k].found) continue;
     538          if (_data[u][k].dist == INF) continue;
    536539          length = _data[u][n].dist - _data[u][k].dist;
    537540          size = n - k;
    538541          if (!found_curr || length * max_size > max_length * size) {