RhodeCode

#include <limits>

#include <algorithm>

#include <lemon/math.h>

namespace lemon {

  private:

    // References for the original data

    const LowerMap *_orig_lower;

    const CapacityMap &_orig_cap;

    const CostMap &_orig_cost;

    Capacity _orig_flow_value;

    // Result maps

    bool _local_flow;

    bool _local_potential;

    // The number of nodes and arcs in the original graph

    int _node_num;

    int _arc_num;

    // Node and arc maps

    CapacityVector _cap;

    CostVector _cost;

    CapacityVector _flow;

    CostVector _pi;

    IntVector _depth;

    IntVector _parent;

    IntVector _pred;

    IntVector _thread;

    BoolVector _forward;

    IntVector _state;

    int _root;

    // Temporary data used in the current pivot iteration

    int stem, par_stem, new_stem;

    Capacity delta;

    private:

      // References to the NetworkSimplex class

      const IntVector  &_source;

      const IntVector  &_target;

      const CostVector &_cost;

      /// Constructor

      FirstEligiblePivotRule(NetworkSimplex &ns) :

        _cost(ns._cost), _state(ns._state), _pi(ns._pi),

      {}

      /// Find next entering arc

    private:

      // References to the NetworkSimplex class

      const IntVector  &_source;

      const IntVector  &_target;

      const CostVector &_cost;

      /// Constructor

      BestEligiblePivotRule(NetworkSimplex &ns) :

        _cost(ns._cost), _state(ns._state), _pi(ns._pi),

      {}

      /// Find next entering arc

    private:

      // References to the NetworkSimplex class

      const IntVector  &_source;

      const IntVector  &_target;

      const CostVector &_cost;

      /// Constructor

      BlockSearchPivotRule(NetworkSimplex &ns) :

        _cost(ns._cost), _state(ns._state), _pi(ns._pi),

      {

        // The main parameters of the pivot rule

        const double BLOCK_SIZE_FACTOR = 2.0;

    private:

      // References to the NetworkSimplex class

      const IntVector  &_source;

      const IntVector  &_target;

      const CostVector &_cost;

      /// Constructor

      CandidateListPivotRule(NetworkSimplex &ns) :

        _cost(ns._cost), _state(ns._state), _pi(ns._pi),

      {

        // The main parameters of the pivot rule

        const double LIST_LENGTH_FACTOR = 1.0;

    private:

      // References to the NetworkSimplex class

      const IntVector  &_source;

      const IntVector  &_target;

      const CostVector &_cost;

      /// Constructor

      AlteringListPivotRule(NetworkSimplex &ns) :

        _cost(ns._cost), _state(ns._state), _pi(ns._pi),

        _next_arc(0), _cand_cost(ns._arc_num), _sort_func(_cand_cost)

      {

        // The main parameters of the pivot rule

        // Extend the list

        int cnt = _block_size;

        int limit = _head_length;

        for (int e = _next_arc; e < _arc_num; ++e) {

            (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);

          if (_cand_cost[e] < 0) {

            _candidates[_curr_length++] = e;

          }

          if (--cnt == 0) {

            if (_curr_length > limit) break;

              (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);

            if (_cand_cost[e] < 0) {

              _candidates[_curr_length++] = e;

            }

            if (--cnt == 0) {

              if (_curr_length > limit) break;

          }

        }

        if (_curr_length == 0) return false;

        // Make heap of the candidate list (approximating a partial sort)

        make_heap( _candidates.begin(), _candidates.begin() + _curr_length,

    ///

    /// General constructor (with lower bounds).

    ///

    /// \param lower The lower bounds of the arcs.

    /// \param capacity The capacities (upper bounds) of the arcs.

    /// \param cost The cost (length) values of the arcs.

    /// \param supply The supply values of the nodes (signed).

                    const LowerMap &lower,

                    const CapacityMap &capacity,

                    const CostMap &cost,

                    const SupplyMap &supply ) :

      _orig_cost(cost), _orig_supply(&supply),

      _local_flow(false), _local_potential(false),

    {}

    /// \brief General constructor (without lower bounds).

    ///

    /// General constructor (without lower bounds).

    ///

    /// \param capacity The capacities (upper bounds) of the arcs.

    /// \param cost The cost (length) values of the arcs.

    /// \param supply The supply values of the nodes (signed).

                    const CapacityMap &capacity,

                    const CostMap &cost,

                    const SupplyMap &supply ) :

      _orig_cost(cost), _orig_supply(&supply),

      _local_flow(false), _local_potential(false),

    {}

    /// \brief Simple constructor (with lower bounds).

    ///

    /// Simple constructor (with lower bounds).

    ///

    /// \param lower The lower bounds of the arcs.

    /// \param capacity The capacities (upper bounds) of the arcs.

    /// \param cost The cost (length) values of the arcs.

    /// \param t The target node.

    /// \param flow_value The required amount of flow from node \c s

    /// to node \c t (i.e. the supply of \c s and the demand of \c t).

                    const LowerMap &lower,

                    const CapacityMap &capacity,

                    const CostMap &cost,

                    Node s, Node t,

                    Capacity flow_value ) :

      _orig_cost(cost), _orig_supply(NULL),

      _orig_source(s), _orig_target(t), _orig_flow_value(flow_value),

      _local_flow(false), _local_potential(false),

    {}

    /// \brief Simple constructor (without lower bounds).

    ///

    /// Simple constructor (without lower bounds).

    ///

    /// \param capacity The capacities (upper bounds) of the arcs.

    /// \param cost The cost (length) values of the arcs.

    /// \param s The source node.

    /// \param t The target node.

    /// \param flow_value The required amount of flow from node \c s

    /// to node \c t (i.e. the supply of \c s and the demand of \c t).

                    const CapacityMap &capacity,

                    const CostMap &cost,

                    Node s, Node t,

                    Capacity flow_value ) :

      _orig_cost(cost), _orig_supply(NULL),

      _orig_source(s), _orig_target(t), _orig_flow_value(flow_value),

      _local_flow(false), _local_potential(false),

    {}

    /// Destructor.

    ~NetworkSimplex() {

    }

    /// \brief Set the flow map.

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

    NetworkSimplex& flowMap(FlowMap &map) {

      if (_local_flow) {

        _local_flow = false;

      }

      return *this;

    }

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

    NetworkSimplex& potentialMap(PotentialMap &map) {

      if (_local_potential) {

        _local_potential = false;

      }

      return *this;

    }

    ///

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

    const FlowMap& flowMap() const {

    }

    /// \brief Return a const reference to the potential map

    ///

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

    const PotentialMap& potentialMap() const {

    }

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

    ///

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

    Capacity flow(const Arc& arc) const {

    }

    /// \brief Return the potential of the given node.

    ///

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

    Cost potential(const Node& node) const {

    }

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

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

    Cost totalCost() const {

      Cost c = 0;

      return c;

    }

    // Initialize internal data structures

    bool init() {

      // Initialize result maps

        _local_flow = true;

      }

        _local_potential = true;

      }

      // Initialize vectors

      int all_node_num = _node_num + 1;

      _supply.resize(all_node_num);

      _pi.resize(all_node_num, 0);

      _depth.resize(all_node_num);

      _parent.resize(all_node_num);

      _pred.resize(all_node_num);

      _thread.resize(all_node_num);

      // Initialize node related data

      bool valid_supply = true;

      if (_orig_supply) {

        Supply sum = 0;

        int i = 0;

          _node_id[n] = i;

          _supply[i] = (*_orig_supply)[n];

          sum += _supply[i];

        valid_supply = (sum == 0);

      } else {

        int i = 0;

          _node_id[n] = i;

          _supply[i] = 0;

        }

      // Store the arcs in a mixed order

      int k = std::max(int(sqrt(_arc_num)), 10);

      int i = 0;

        if ((i += k) >= _arc_num) i = (i % k) + 1;

      }

      // Initialize arc maps

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

        _cost[i] = _orig_cost[e];

        _cap[i] = _orig_cap[e];

      }

      // Remove non-zero lower bounds

      if (_orig_lower) {

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

          if (c != 0) {

            _cap[i] -= c;

            _supply[_source[i]] -= c;

    // Find the join node

    void findJoinNode() {

      while (_depth[u] > _depth[v]) u = _parent[u];

      while (_depth[v] > _depth[u]) v = _parent[v];

      while (u != v) {

    bool findLeavingArc() {

      // Initialize first and second nodes according to the direction

      // of the cycle

      } else {

      }

      int result = 0;

      Capacity d;

      int e;

    void changeFlow(bool change) {

      // Augment along the cycle

      if (delta > 0) {

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

        }

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

        }

      }

      // Update the state of the entering and leaving arcs

      if (change) {

        _state[_pred[u_out]] =

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

      } else {

      }

    }

        _forward[u] = !_forward[v];

        u = v;

      }

    }

    // Update _depth and _potential vectors

        if (_flow[e] > 0) return false;

      }

      if (_orig_lower) {

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

        }

      } else {

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

        }

      }

      }

      return true;