COIN-OR::LEMON - Graph Library

Changeset 2556:74c2c81055e1 in lemon-0.x for lemon/min_cost_flow.h


Ignore:
Timestamp:
01/13/08 11:32:14 (11 years ago)
Author:
Peter Kovacs
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3437
Message:

Cleanup in the minimum cost flow files.
The changes only affects the documentation and the look of the source codes.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/min_cost_flow.h

    r2553 r2556  
    3434  /// \brief An efficient algorithm for finding a minimum cost flow.
    3535  ///
    36   /// \ref lemon::MinCostFlow "MinCostFlow" implements an efficient
    37   /// algorithm for finding a minimum cost flow.
     36  /// \ref MinCostFlow provides an efficient algorithm for finding
     37  /// a minimum cost flow.
    3838  ///
    39   /// \note \ref lemon::MinCostFlow "MinCostFlow" is just an alias for
    40   /// \ref lemon::NetworkSimplex "NetworkSimplex", wich is the most
    41   /// efficient implementation for the minimum cost flow problem in the
    42   /// LEMON library according to our benchmark tests.
     39  /// \note \ref MinCostFlow is just an alias for \ref NetworkSimplex,
     40  /// which is the most efficient implementation for the minimum cost
     41  /// flow problem in the LEMON library according to our benchmark
     42  /// tests.
    4343  ///
    4444  /// \note There are three implementations for the minimum cost flow
    45   /// problem, that can be used in the same way.
    46   /// - \ref lemon::CapacityScaling "CapacityScaling"
    47   /// - \ref lemon::CycleCanceling "CycleCanceling"
    48   /// - \ref lemon::NetworkSimplex "NetworkSimplex"
     45  /// problem, that can be used exactly the same way.
     46  /// - \ref CapacityScaling
     47  /// - \ref CycleCanceling
     48  /// - \ref NetworkSimplex
     49  ///
     50  /// \note For the detailed documentation of this class see
     51  /// \ref NetworkSimplex.
    4952  ///
    5053  /// \param Graph The directed graph type the algorithm runs on.
     
    5558  ///
    5659  /// \warning
    57   /// - Edge capacities and costs should be nonnegative integers.
    58   ///   However \c CostMap::Value should be signed type.
     60  /// - Edge capacities and costs should be non-negative integers.
     61  ///   However \c CostMap::Value should be signed type.
    5962  /// - Supply values should be signed integers.
    6063  /// - \c LowerMap::Value must be convertible to
    61   ///   \c CapacityMap::Value and \c CapacityMap::Value must be
    62   ///   convertible to \c SupplyMap::Value.
     64  ///   \c CapacityMap::Value and \c CapacityMap::Value must be
     65  ///   convertible to \c SupplyMap::Value.
    6366  ///
    6467  /// \author Peter Kovacs
     
    7174                                  <typename CapacityMap::Value> >
    7275  class MinCostFlow :
    73     public NetworkSimplex< Graph,
    74                            LowerMap,
    75                            CapacityMap,
    76                            CostMap,
    77                            SupplyMap >
     76    public NetworkSimplex< Graph, LowerMap, CapacityMap,
     77                           CostMap, SupplyMap >
    7878  {
    7979    typedef NetworkSimplex< Graph, LowerMap, CapacityMap,
    80                             CostMap, SupplyMap >
    81       MinCostFlowImpl;
     80                            CostMap, SupplyMap > MinCostFlowImpl;
    8281    typedef typename Graph::Node Node;
    8382    typedef typename SupplyMap::Value Supply;
     
    8584  public:
    8685
    87     /// \brief General constructor of the class (with lower bounds).
    88     MinCostFlow( const Graph &_graph,
    89                  const LowerMap &_lower,
    90                  const CapacityMap &_capacity,
    91                  const CostMap &_cost,
    92                  const SupplyMap &_supply ) :
    93       MinCostFlowImpl(_graph, _lower, _capacity, _cost, _supply) {}
     86    /// General constructor of the class (with lower bounds).
     87    MinCostFlow( const Graph &graph,
     88                 const LowerMap &lower,
     89                 const CapacityMap &capacity,
     90                 const CostMap &cost,
     91                 const SupplyMap &supply ) :
     92      MinCostFlowImpl(graph, lower, capacity, cost, supply) {}
    9493
    95     /// \brief General constructor of the class (without lower bounds).
    96     MinCostFlow( const Graph &_graph,
    97                  const CapacityMap &_capacity,
    98                  const CostMap &_cost,
    99                  const SupplyMap &_supply ) :
    100       MinCostFlowImpl(_graph, _capacity, _cost, _supply) {}
     94    /// General constructor of the class (without lower bounds).
     95    MinCostFlow( const Graph &graph,
     96                 const CapacityMap &capacity,
     97                 const CostMap &_ost,
     98                 const SupplyMap &supply ) :
     99      MinCostFlowImpl(graph, capacity, cost, supply) {}
    101100
    102     /// \brief Simple constructor of the class (with lower bounds).
    103     MinCostFlow( const Graph &_graph,
    104                  const LowerMap &_lower,
    105                  const CapacityMap &_capacity,
    106                  const CostMap &_cost,
    107                  Node _s, Node _t,
    108                  Supply _flow_value ) :
    109       MinCostFlowImpl( _graph, _lower, _capacity, _cost,
    110                        _s, _t, _flow_value ) {}
     101    /// Simple constructor of the class (with lower bounds).
     102    MinCostFlow( const Graph &graph,
     103                 const LowerMap &lower,
     104                 const CapacityMap &capacity,
     105                 const CostMap &_ost,
     106                 Node s, Node t,
     107                 Supply flow_value ) :
     108      MinCostFlowImpl( graph, lower, capacity, cost,
     109                       s, t, flow_value ) {}
    111110
    112     /// \brief Simple constructor of the class (without lower bounds).
    113     MinCostFlow( const Graph &_graph,
    114                  const CapacityMap &_capacity,
    115                  const CostMap &_cost,
    116                  Node _s, Node _t,
    117                  Supply _flow_value ) :
    118       MinCostFlowImpl( _graph, _capacity, _cost,
    119                        _s, _t, _flow_value ) {}
     111    /// Simple constructor of the class (without lower bounds).
     112    MinCostFlow( const Graph &graph,
     113                 const CapacityMap &capacity,
     114                 const CostMap &cost,
     115                 Node s, Node t,
     116                 Supply flow_value ) :
     117      MinCostFlowImpl( graph, capacity, cost,
     118                       s, t, flow_value ) {}
    120119
    121120  }; //class MinCostFlow
Note: See TracChangeset for help on using the changeset viewer.