RhodeCode

    /// @}

    /// \name Execution Control

    /// The algorithm can be executed using \ref run().

    /// @{

    /// \brief Run the algorithm.

    ///

    /// This function runs the algorithm.

    /// The paramters can be specified using functions \ref lowerMap(),

    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(), 

    /// \ref supplyType().

    /// For example,

    /// \code

    ///   NetworkSimplex<ListDigraph> ns(graph);

    ///   ns.lowerMap(lower).upperMap(upper).costMap(cost)

    ///     .supplyMap(sup).run();

    /// \endcode

    ///

    /// This function can be called more than once. All the parameters

    /// that have been given are kept for the next call, unless

    /// \ref reset() is called, thus only the modified parameters

    /// have to be set again. See \ref reset() for examples.

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

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

    ///

    /// \param pivot_rule The pivot rule that will be used during the

    /// algorithm. For more information see \ref PivotRule.

    ///

    /// \return \c INFEASIBLE if no feasible flow exists,

    /// \n \c OPTIMAL if the problem has optimal solution

    /// (i.e. it is feasible and bounded), and the algorithm has found

    /// optimal flow and node potentials (primal and dual solutions),

    /// \n \c UNBOUNDED if the objective function of the problem is

    /// unbounded, i.e. there is a directed cycle having negative total

    /// cost and infinite upper bound.

    ///

    /// \see ProblemType, PivotRule

    ProblemType run(PivotRule pivot_rule = BLOCK_SEARCH) {

      if (!init()) return INFEASIBLE;

      return start(pivot_rule);

    }

    /// \brief Reset all the parameters that have been given before.

    ///

    /// This function resets all the paramaters that have been given

    /// before using functions \ref lowerMap(), \ref upperMap(),

    /// \ref costMap(), \ref supplyMap(), \ref stSupply(), \ref supplyType().

    ///

    /// It is useful for multiple run() calls. If this function is not

    /// used, all the parameters given before are kept for the next

    /// \ref run() call.

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

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

    ///

    /// For example,

    /// \code

    ///   NetworkSimplex<ListDigraph> ns(graph);

    ///

    ///   // First run

    ///   ns.lowerMap(lower).upperMap(upper).costMap(cost)

    ///     .supplyMap(sup).run();

    ///

    ///   // Run again with modified cost map (reset() is not called,

    ///   // so only the cost map have to be set again)

    ///   cost[e] += 100;

    ///   ns.costMap(cost).run();

    ///

    ///   // Run again from scratch using reset()

    ///   // (the lower bounds will be set to zero on all arcs)

    ///   ns.reset();

    ///   ns.upperMap(capacity).costMap(cost)

    ///     .supplyMap(sup).run();

    /// \endcode

    ///

    /// \return <tt>(*this)</tt>

    NetworkSimplex& reset() {

      for (int i = 0; i != _node_num; ++i) {

        _supply[i] = 0;

      }

      for (int i = 0; i != _arc_num; ++i) {

        _lower[i] = 0;

        _upper[i] = INF;

        _cost[i] = 1;

      }

      _have_lower = false;

      _stype = GEQ;

      return *this;

    }

    /// @}

    /// \name Query Functions

    /// The results of the algorithm can be obtained using these

    /// functions.\n

    /// The \ref run() function must be called before using them.

    /// @{

    /// \brief Return the total cost of the found flow.

    ///

    /// This function returns the total cost of the found flow.

    /// Its complexity is O(e).

    ///

    /// \note The return type of the function can be specified as a

    /// template parameter. For example,

    /// \code

    ///   ns.totalCost<double>();

    /// \endcode

    /// It is useful if the total cost cannot be stored in the \c Cost

    /// type of the algorithm, which is the default return type of the

    /// function.

    ///

    /// \pre \ref run() must be called before using this function.

    template <typename Number>

    Number totalCost() const {

      Number c = 0;

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

        int i = _arc_id[a];

        c += Number(_flow[i]) * Number(_cost[i]);

      }

      return c;

    }

#ifndef DOXYGEN

    Cost totalCost() const {

      return totalCost<Cost>();

    }

#endif

    /// \brief Return the flow on the given arc.

    ///

    /// This function returns the flow on the given arc.

    ///

    /// \pre \ref run() must be called before using this function.

    Value flow(const Arc& a) const {

      return _flow[_arc_id[a]];

    }

    /// \brief Return the flow map (the primal solution).

    ///

    /// This function copies the flow value on each arc into the given

    /// map. The \c Value type of the algorithm must be convertible to

    /// the \c Value type of the map.

    ///

    /// \pre \ref run() must be called before using this function.

    template <typename FlowMap>

    void flowMap(FlowMap &map) const {

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

        map.set(a, _flow[_arc_id[a]]);

      }

    }

    /// \brief Return the potential (dual value) of the given node.

    ///

    /// This function returns the potential (dual value) of the

    /// given node.

    ///

    /// \pre \ref run() must be called before using this function.

    Cost potential(const Node& n) const {

      return _pi[_node_id[n]];

    }

    /// \brief Return the potential map (the dual solution).

    ///

    /// This function copies the potential (dual value) of each node

    /// into the given map.

    /// The \c Cost type of the algorithm must be convertible to the

    /// \c Value type of the map.

    ///

    /// \pre \ref run() must be called before using this function.

    template <typename PotentialMap>

    void potentialMap(PotentialMap &map) const {

      for (NodeIt n(_graph); n != INVALID; ++n) {

        map.set(n, _pi[_node_id[n]]);

      }

    }

    /// @}

  private:

    // Initialize internal data structures

    bool init() {

      if (_node_num == 0) return false;

      // Check the sum of supply values

      _sum_supply = 0;

      for (int i = 0; i != _node_num; ++i) {

        _sum_supply += _supply[i];

      }

      // Remove non-zero lower bounds

      if (_have_lower) {

        for (int i = 0; i != _arc_num; ++i) {

          Value c = _lower[i];

          if (c >= 0) {

            _cap[i] = _upper[i] < INF ? _upper[i] - c : INF;

          } else {

            _cap[i] = _upper[i] < INF + c ? _upper[i] - c : INF;

          }

          _supply[_source[i]] -= c;

          _supply[_target[i]] += c;

        }

      } else {

        for (int i = 0; i != _arc_num; ++i) {

          _cap[i] = _upper[i];

        }

      }

      // Initialize artifical cost

      Cost ART_COST;

      if (std::numeric_limits<Cost>::is_exact) {

        ART_COST = std::numeric_limits<Cost>::max() / 4 + 1;

      } else {

        ART_COST = std::numeric_limits<Cost>::min();

        for (int i = 0; i != _arc_num; ++i) {

          if (_cost[i] > ART_COST) ART_COST = _cost[i];

        }

        ART_COST = (ART_COST + 1) * _node_num;

      }

      // Initialize arc maps

      for (int i = 0; i != _arc_num; ++i) {

        _flow[i] = 0;

        _state[i] = STATE_LOWER;

      }

      // Set data for the artificial root node

      _root = _node_num;

      _parent[_root] = -1;

      _pred[_root] = -1;

      _thread[_root] = 0;

      _rev_thread[0] = _root;

      _succ_num[_root] = _node_num + 1;

      _last_succ[_root] = _root - 1;

      _supply[_root] = -_sum_supply;

      _pi[_root] = _sum_supply < 0 ? -ART_COST : ART_COST;

      // Add artificial arcs and initialize the spanning tree data structure

      for (int u = 0, e = _arc_num; u != _node_num; ++u, ++e) {

        _parent[u] = _root;

        _pred[u] = e;

        _thread[u] = u + 1;

        _rev_thread[u + 1] = u;

        _succ_num[u] = 1;

        _last_succ[u] = u;

        _cost[e] = ART_COST;

        _cap[e] = INF;

        _state[e] = STATE_TREE;

        if (_supply[u] > 0 || (_supply[u] == 0 && _sum_supply <= 0)) {

          _flow[e] = _supply[u];

          _forward[u] = true;

          _pi[u] = -ART_COST + _pi[_root];

        } else {

          _flow[e] = -_supply[u];

          _forward[u] = false;

          _pi[u] = ART_COST + _pi[_root];

        }

      }

      return true;

    }

    // Find the join node

    void findJoinNode() {

      int u = _source[in_arc];

      int v = _target[in_arc];

      while (u != v) {

        if (_succ_num[u] < _succ_num[v]) {

          u = _parent[u];

        } else {

          v = _parent[v];

        }

      }

      join = u;

    }

    // Find the leaving arc of the cycle and returns true if the

    // leaving arc is not the same as the entering arc

    bool findLeavingArc() {

      // Initialize first and second nodes according to the direction

      // of the cycle

      if (_state[in_arc] == STATE_LOWER) {

        first  = _source[in_arc];

        second = _target[in_arc];

      } else {

        first  = _target[in_arc];

        second = _source[in_arc];

      }

      delta = _cap[in_arc];

      int result = 0;

      Value d;

      int e;

      // Search the cycle along the path form the first node to the root

      for (int u = first; u != join; u = _parent[u]) {

        e = _pred[u];

        d = _forward[u] ?

          _flow[e] : (_cap[e] == INF ? INF : _cap[e] - _flow[e]);

        if (d < delta) {

          delta = d;

          u_out = u;

          result = 1;

        }

      }

      // Search the cycle along the path form the second node to the root

      for (int u = second; u != join; u = _parent[u]) {

        e = _pred[u];

        d = _forward[u] ? 

          (_cap[e] == INF ? INF : _cap[e] - _flow[e]) : _flow[e];

        if (d <= delta) {

          delta = d;

          u_out = u;

          result = 2;

        }

      }

      if (result == 1) {

        u_in = first;

        v_in = second;

      } else {

        u_in = second;

        v_in = first;

      }

      return result != 0;

    }

    // Change _flow and _state vectors

    void changeFlow(bool change) {

      // Augment along the cycle

      if (delta > 0) {

        Value val = _state[in_arc] * delta;

        _flow[in_arc] += val;

        for (int u = _source[in_arc]; u != join; u = _parent[u]) {

          _flow[_pred[u]] += _forward[u] ? -val : val;

        }

        for (int u = _target[in_arc]; u != join; u = _parent[u]) {

          _flow[_pred[u]] += _forward[u] ? val : -val;

        }

      }

      // Update the state of the entering and leaving arcs

      if (change) {

        _state[in_arc] = STATE_TREE;

        _state[_pred[u_out]] =

          (_flow[_pred[u_out]] == 0) ? STATE_LOWER : STATE_UPPER;

      } else {

        _state[in_arc] = -_state[in_arc];

      }

    }

    // Update the tree structure

    void updateTreeStructure() {

      int u, w;

      int old_rev_thread = _rev_thread[u_out];

      int old_succ_num = _succ_num[u_out];

      int old_last_succ = _last_succ[u_out];

      v_out = _parent[u_out];

      u = _last_succ[u_in];  // the last successor of u_in

      right = _thread[u];    // the node after it

      // Handle the case when old_rev_thread equals to v_in

      // (it also means that join and v_out coincide)

      if (old_rev_thread == v_in) {

        last = _thread[_last_succ[u_out]];

      } else {

        last = _thread[v_in];

      }

      // Update _thread and _parent along the stem nodes (i.e. the nodes

      // between u_in and u_out, whose parent have to be changed)

      _thread[v_in] = stem = u_in;

      _dirty_revs.clear();

      _dirty_revs.push_back(v_in);

      par_stem = v_in;

      while (stem != u_out) {

        // Insert the next stem node into the thread list

        new_stem = _parent[stem];

        _thread[u] = new_stem;

        _dirty_revs.push_back(u);

        // Remove the subtree of stem from the thread list