RhodeCode

  private:

    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);

    // Data sturcture for path data

    struct PathData

    {

      LargeValue dist;

      Arc pred;

    };

    typedef typename Digraph::template NodeMap<std::vector<PathData> >

      PathDataNodeMap;

  private:

    // The digraph the algorithm runs on

    // Node map for storing path data

    PathDataNodeMap _data;

    // The processed nodes in the last round

    std::vector<Node> _process;

    Tolerance _tolerance;

  public:

    /// \name Named Template Parameters

    /// @{

    template <typename T>

    struct SetLargeValueTraits : public Traits {

      typedef T LargeValue;

    /// The constructor of the class.

    ///

    /// \param digraph The digraph the algorithm runs on.

    /// \param length The lengths (costs) of the arcs.

    HartmannOrlin( const Digraph &digraph,

                   const LengthMap &length ) :

      _gr(digraph), _length(length), _comp(digraph), _out_arcs(digraph),

      _best_found(false), _best_length(0), _best_size(1),

    {}

    /// Destructor.

    ~HartmannOrlin() {

      if (_local_path) delete _cycle_path;

    }

    /// \brief Set the path structure for storing the found cycle.

    // Initialize path data for the current component

    bool initComponent(int comp) {

      _nodes = &(_comp_nodes[comp]);

      int n = _nodes->size();

      if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) {

        return false;

      }      

      for (int i = 0; i < n; ++i) {

      }

      return true;

    }

    // Process all rounds of computing path data for the current component.

    // _data[v][k] is the length of a shortest directed walk from the root

    // node to node v containing exactly k arcs.

    void processRounds() {

      Node start = (*_nodes)[0];

      _process.clear();

      _process.push_back(start);

      int k, n = _nodes->size();

      int next_check = 4;

      bool terminate = false;

      for (k = 1; k <= n && int(_process.size()) < n && !terminate; ++k) {

        processNextBuildRound(k);

      Arc e;

      LargeValue d;

      for (int i = 0; i < int(_process.size()); ++i) {

        u = _process[i];

        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {

          e = _out_arcs[u][j];

          v = _gr.target(e);

          d = _data[u][k-1].dist + _length[e];

          }

        }

      }

      _process.swap(next);

    }

    // Process one round using _nodes instead of _process

    void processNextFullRound(int k) {

      Arc e;

      LargeValue d;

      for (int i = 0; i < int(_nodes->size()); ++i) {

        u = (*_nodes)[i];

        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {

          e = _out_arcs[u][j];

          v = _gr.target(e);

          d = _data[u][k-1].dist + _length[e];

          }

        }

      }

    }

    // Check early termination

    bool checkTermination(int k) {

      typedef std::pair<int, int> Pair;

      LargeValue length;

      int size;

      Node u;

      // Search for cycles that are already found

      _curr_found = false;

      for (int i = 0; i < n; ++i) {

        u = (*_nodes)[i];

        for (int j = k; j >= 0; --j) {

          if (level[u].first == i && level[u].second > 0) {

            // A cycle is found

            length = _data[u][level[u].second].dist - _data[u][j].dist;

            size = level[u].second - j;

            if (!_curr_found || length * _curr_size < _curr_length * size) {

              _curr_length = length;

              _curr_size = size;

      }

      // If at least one cycle is found, check the optimality condition

      LargeValue d;

      if (_curr_found && k < n) {

        // Find node potentials

        for (int i = 0; i < n; ++i) {

          u = (*_nodes)[i];

          for (int j = 0; j <= k; ++j) {

            }

          }

        }

        // Check the optimality condition for all arcs

        bool done = true;

        for (ArcIt a(_gr); a != INVALID; ++a) {

          if (_tolerance.less(_length[a] * _curr_size - _curr_length,

    typename Digraph::template NodeMap<std::vector<Arc> > _in_arcs;

    // Queue used for BFS search

    std::vector<Node> _queue;

    int _qfront, _qback;

    Tolerance _tolerance;

  public:

    /// \name Named Template Parameters

    /// @{

    template <typename T>

    struct SetLargeValueTraits : public Traits {

      typedef T LargeValue;

    /// \brief Constructor.

    ///

    /// The constructor of the class.

    ///

    /// \param digraph The digraph the algorithm runs on.

    /// \param length The lengths (costs) of the arcs.

    Howard( const Digraph &digraph,

            const LengthMap &length ) :

      _policy(digraph), _reached(digraph), _level(digraph), _dist(digraph),

    {}

    /// Destructor.

    ~Howard() {

      if (_local_path) delete _cycle_path;

    }

    /// \brief Set the path structure for storing the found cycle.

      for (int comp = 0; comp < _comp_num; ++comp) {

        // Find the minimum mean cycle in the current component

        if (!buildPolicyGraph(comp)) continue;

        while (true) {

          findPolicyCycle();

          if (!computeNodeDistances()) break;

        }

        // Update the best cycle (global minimum mean cycle)

             _curr_length * _best_size < _best_length * _curr_size) ) {

          _best_found = true;

          _best_length = _curr_length;

          _best_size = _curr_size;

          _best_node = _curr_node;

        }

      }

      return _best_found;

    // (the out-degree of every node is 1)

    bool buildPolicyGraph(int comp) {

      _nodes = &(_comp_nodes[comp]);

      if (_nodes->size() < 1 ||

          (_nodes->size() == 1 && _in_arcs[(*_nodes)[0]].size() == 0)) {

        return false;

      }

      for (int i = 0; i < int(_nodes->size()); ++i) {

      }

      Node u, v;

      Arc e;

      for (int i = 0; i < int(_nodes->size()); ++i) {

        v = (*_nodes)[i];

        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {

          e = _in_arcs[v][j];

          u = _gr.source(e);

  private:

    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);

    // Data sturcture for path data

    struct PathData

    {

      LargeValue dist;

      Arc pred;

    };

    typedef typename Digraph::template NodeMap<std::vector<PathData> >

      PathDataNodeMap;

  private:

    // The digraph the algorithm runs on

    bool _local_path;

    // Node map for storing path data

    PathDataNodeMap _data;

    // The processed nodes in the last round

    std::vector<Node> _process;

    Tolerance _tolerance;

  public:

    /// \name Named Template Parameters

    /// @{

    template <typename T>

    struct SetLargeValueTraits : public Traits {

    /// The constructor of the class.

    ///

    /// \param digraph The digraph the algorithm runs on.

    /// \param length The lengths (costs) of the arcs.

    Karp( const Digraph &digraph,

          const LengthMap &length ) :

      _gr(digraph), _length(length), _comp(digraph), _out_arcs(digraph),

      _cycle_length(0), _cycle_size(1), _cycle_node(INVALID),

    {}

    /// Destructor.

    ~Karp() {

      if (_local_path) delete _cycle_path;

    }

    /// \brief Set the path structure for storing the found cycle.

    // Initialize path data for the current component

    bool initComponent(int comp) {

      _nodes = &(_comp_nodes[comp]);

      int n = _nodes->size();

      if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) {

        return false;

      }      

      for (int i = 0; i < n; ++i) {

      }

      return true;

    }

    // Process all rounds of computing path data for the current component.

    // _data[v][k] is the length of a shortest directed walk from the root

    // node to node v containing exactly k arcs.

    void processRounds() {

      Node start = (*_nodes)[0];

      _process.clear();

      _process.push_back(start);

      int k, n = _nodes->size();

      for (k = 1; k <= n && int(_process.size()) < n; ++k) {

        processNextBuildRound(k);

      }

      for ( ; k <= n; ++k) {

      Arc e;

      LargeValue d;

      for (int i = 0; i < int(_process.size()); ++i) {

        u = _process[i];

        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {

          e = _out_arcs[u][j];

          v = _gr.target(e);

          d = _data[u][k-1].dist + _length[e];

          }

        }

      }

      _process.swap(next);

    }

    // Process one round using _nodes instead of _process

    void processNextFullRound(int k) {

      Arc e;

      LargeValue d;

      for (int i = 0; i < int(_nodes->size()); ++i) {

        u = (*_nodes)[i];

        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {

          e = _out_arcs[u][j];

          v = _gr.target(e);

          d = _data[u][k-1].dist + _length[e];

          }

        }

      }

    }

    // Update the minimum cycle mean

    void updateMinMean() {

      int n = _nodes->size();

      for (int i = 0; i < n; ++i) {

        Node u = (*_nodes)[i];

        LargeValue length, max_length = 0;

        int size, max_size = 1;

        bool found_curr = false;

        for (int k = 0; k < n; ++k) {

          length = _data[u][n].dist - _data[u][k].dist;

          size = n - k;

          if (!found_curr || length * max_size > max_length * size) {

            found_curr = true;

            max_length = length;

            max_size = size;

          }

        }