RhodeCode

    int _factor;

    /// class have been constructed, since it copies and extends the graph.

    /// \param factor The capacity scaling factor. It must be larger than

    /// one to use scaling. If it is less or equal to one, then scaling

    /// will be disabled.

    ProblemType run(int factor = 4) {

      _factor = factor;

      ProblemType pt = init();

    /// However, the underlying digraph must not be modified after this

    ProblemType init() {

      if (_factor > 1) {

        for (_delta = 1; 2 * _delta <= max_sup; _delta *= 2) ;

        _delta = _delta <= _factor ? 1 : _delta / _factor;

  ///

  /// \note %CostScaling provides three different internal methods,

  /// from which the most efficient one is used by default.

  /// For more information, see \ref Method.

    /// \brief Constants for selecting the internal method.

    ///

    /// Enum type containing constants for selecting the internal method

    /// for the \ref run() function.

    ///

    /// \ref CostScaling provides three internal methods that differ mainly

    /// in their base operations, which are used in conjunction with the

    /// relabel operation.

    /// By default, the so called \ref PARTIAL_AUGMENT

    /// "Partial Augment-Relabel" method is used, which proved to be

    /// the most efficient and the most robust on various test inputs.

    /// However, the other methods can be selected using the \ref run()

    /// function with the proper parameter.

    enum Method {

      /// Local push operations are used, i.e. flow is moved only on one

      /// admissible arc at once.

      PUSH,

      /// Augment operations are used, i.e. flow is moved on admissible

      /// paths from a node with excess to a node with deficit.

      AUGMENT,

      /// Partial augment operations are used, i.e. flow is moved on 

      /// admissible paths started from a node with excess, but the

      /// lengths of these paths are limited. This method can be viewed

      /// as a combined version of the previous two operations.

      PARTIAL_AUGMENT

    };

    /// However, the underlying digraph must not be modified after this

    /// class have been constructed, since it copies and extends the graph.

    /// \param method The internal method that will be used in the

    /// algorithm. For more information, see \ref Method.

    /// \param factor The cost scaling factor. It must be larger than one.

    /// \see ProblemType, Method

    ProblemType run(Method method = PARTIAL_AUGMENT, int factor = 8) {

      _alpha = factor;

      start(method);

    void start(Method method) {

      // Maximum path length for partial augment

      const int MAX_PATH_LENGTH = 4;

      switch (method) {

        case PUSH:

          startPush();

          break;

        case AUGMENT:

          startAugment();

          break;

        case PARTIAL_AUGMENT:

          startAugment(MAX_PATH_LENGTH);

          break;

    /// Execute the algorithm performing augment and relabel operations

    void startAugment(int max_length = std::numeric_limits<int>::max()) {

                 int(path_nodes.size()) <= max_length) {

    void startPush() {