RhodeCode

    /// Returns a const reference to the elevator.

    ///

    /// \pre Either \ref run() or \ref init() must be called before

    /// using this function.

    const Elevator& elevator() const {

      return *_level;

    }

    ///

    Circulation& tolerance(const Tolerance& tolerance) {

      _tol = tolerance;

      return *this;

    }

    /// \brief Returns a const reference to the tolerance.

    ///

    const Tolerance& tolerance() const {

      return _tol;

    }

    /// \name Execution Control

    /// The simplest way to execute the algorithm is to call \ref run().\n

    /// If you need more control on the initial solution or the execution,

    /// first you have to call one of the \ref init() functions, then

  /// \ingroup max_flow

  ///

  /// \brief %Preflow algorithm class.

  ///

  /// This class provides an implementation of Goldberg-Tarjan's \e preflow

  /// \e push-relabel algorithm producing a \ref max_flow

  /// "flow of maximum value" in a digraph.

  /// The preflow algorithms are the fastest known maximum

  /// \e "highest label" and the \e "bound decrease" heuristics.

  /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$.

  ///

  /// The algorithm consists of two phases. After the first phase

  /// the maximum flow value and the minimum cut is obtained. The

  /// second phase constructs a feasible maximum flow on each arc.

  ///

  /// \tparam GR The type of the digraph the algorithm runs on.

    /// Returns a const reference to the elevator.

    ///

    /// \pre Either \ref run() or \ref init() must be called before

    /// using this function.

    const Elevator& elevator() const {

      return *_level;

    }

    ///

    Preflow& tolerance(const Tolerance& tolerance) {

      _tolerance = tolerance;

      return *this;

    }

    /// \brief Returns a const reference to the tolerance.

    ///

    const Tolerance& tolerance() const {

      return _tolerance;

    }

    /// \name Execution Control

    /// The simplest way to execute the preflow algorithm is to use

    /// \ref run() or \ref runMinCut().\n

    /// If you need more control on the initial solution or the execution,

  CirculationType circ_test(g, lcap, ucap, supply);

  const CirculationType& const_circ_test = circ_test;

  circ_test

    .lowerMap(lcap)

    .upperMap(ucap)

    .supplyMap(supply)

    .flowMap(flow);

  circ_test.init();

  circ_test.greedyInit();

  circ_test.start();

  circ_test.run();

  v = const_circ_test.flow(a);

  const FlowMap& fm = const_circ_test.flowMap();

  typedef Preflow<Digraph, CapMap>

            ::SetFlowMap<FlowMap>

            ::SetElevator<Elev>

            ::SetStandardElevator<LinkedElev>

            ::Create PreflowType;

  PreflowType preflow_test(g, cap, n, n);

  const PreflowType& const_preflow_test = preflow_test;

  preflow_test

    .capacityMap(cap)

    .flowMap(flow)

    .source(n)

    .target(n);

  preflow_test.init();