RhodeCode

    }

    /// Execute the algorithm performing augment and relabel operations

    void startAugment(int max_length) {

      // Paramters for heuristics

      const int EARLY_TERM_EPSILON_LIMIT = 1000;

        (_res_node_num + _sup_node_num * _sup_node_num));

      // Perform cost scaling phases

      for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?

                                        1 : _epsilon / _alpha )

      {

        // Early termination heuristic

        if (_epsilon <= EARLY_TERM_EPSILON_LIMIT) {

          if (earlyTermination()) break;

            _active_nodes.pop_front();

          }

          if (_active_nodes.size() == 0) break;

          int start = _active_nodes.front();

          // Find an augmenting path from the start node

          int tip = start;

            int u;

            int last_out = _first_out[tip+1];

            for (int a = _next_out[tip]; a != last_out; ++a) {

              }

            }

            // Relabel tip node

            if (tip != start) {

              int ra = _reverse[path.back()];

            }

            for (int a = _first_out[tip]; a != last_out; ++a) {

              }

            }

            _pi[tip] -= min_red_cost + _epsilon;

            _next_out[tip] = _first_out[tip];

            ++relabel_cnt;

            // Step back

            if (tip != start) {

              path.pop_back();

            }

          next_step: ;

          }

          // Augment along the found path (as much flow as possible)

          Value delta;

          int pa, u, v = start;

          for (int i = 0; i != int(path.size()); ++i) {

            pa = path[i];

            u = v;

            v = _target[pa];

            delta = std::min(_res_cap[pa], _excess[u]);

            _res_cap[pa] -= delta;

            _res_cap[_reverse[pa]] += delta;

            _excess[u] -= delta;

            _excess[v] += delta;

              _active_nodes.push_back(v);

          }

          // Global update heuristic

            globalUpdate();

          }

        }

      }

    }

    /// Execute the algorithm performing push and relabel operations

    void startPush() {

      // Paramters for heuristics

      const int EARLY_TERM_EPSILON_LIMIT = 1000;

      const double GLOBAL_UPDATE_FACTOR = 2.0;

        (_res_node_num + _sup_node_num * _sup_node_num));

      // Perform cost scaling phases

      BoolVector hyper(_res_node_num, false);

      LargeCostVector hyper_cost(_res_node_num);

      for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?

                                        1 : _epsilon / _alpha )

      {

        // Early termination heuristic

        if (_epsilon <= EARLY_TERM_EPSILON_LIMIT) {

          if (earlyTermination()) break;

          // Relabel the node if it is still active (or hyper)

          if (_excess[n] > 0 || hyper[n]) {

             min_red_cost = hyper[n] ? -hyper_cost[n] :

               std::numeric_limits<LargeCost>::max();

            for (int a = _first_out[n]; a != last_out; ++a) {

              }

            }

            _pi[n] -= min_red_cost + _epsilon;

            _next_out[n] = _first_out[n];

            hyper[n] = false;

            ++relabel_cnt;

                  _excess[_active_nodes.front()] <= 0 &&

                  !hyper[_active_nodes.front()] ) {

            _active_nodes.pop_front();

          }

          // Global update heuristic

            globalUpdate();

            for (int u = 0; u != _res_node_num; ++u)

              hyper[u] = false;

          }

        }

      }

    }

  }; //class CostScaling