COIN-OR::LEMON - Graph Library

Changeset 812:4b1b378823dc in lemon-1.2


Ignore:
Timestamp:
11/12/09 23:49:05 (10 years ago)
Author:
Peter Kovacs <kpeter@…>
Branch:
default
Phase:
public
Rebase:
30323866356537663935353430623930626534653939636630353730643832346265623131623731
Message:

Small doc improvements + unifications in MCF classes (#180)

Location:
lemon
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • lemon/capacity_scaling.h

    r811 r812  
    3636  /// Default traits class of CapacityScaling algorithm.
    3737  /// \tparam GR Digraph type.
    38   /// \tparam V The value type used for flow amounts, capacity bounds
     38  /// \tparam V The number type used for flow amounts, capacity bounds
    3939  /// and supply values. By default it is \c int.
    40   /// \tparam C The value type used for costs and potentials.
     40  /// \tparam C The number type used for costs and potentials.
    4141  /// By default it is the same as \c V.
    4242  template <typename GR, typename V = int, typename C = V>
     
    7676  ///
    7777  /// \tparam GR The digraph type the algorithm runs on.
    78   /// \tparam V The value type used for flow amounts, capacity bounds
     78  /// \tparam V The number type used for flow amounts, capacity bounds
    7979  /// and supply values in the algorithm. By default it is \c int.
    80   /// \tparam C The value type used for costs and potentials in the
     80  /// \tparam C The number type used for costs and potentials in the
    8181  /// algorithm. By default it is the same as \c V.
    8282  ///
    83   /// \warning Both value types must be signed and all input data must
     83  /// \warning Both number types must be signed and all input data must
    8484  /// be integer.
    8585  /// \warning This algorithm does not support negative costs for such
     
    123123      /// The digraph contains an arc of negative cost and infinite
    124124      /// upper bound. It means that the objective function is unbounded
    125       /// on that arc, however note that it could actually be bounded
     125      /// on that arc, however, note that it could actually be bounded
    126126      /// over the feasible flows, but this algroithm cannot handle
    127127      /// these cases.
     
    308308          std::numeric_limits<Value>::max())
    309309    {
    310       // Check the value types
     310      // Check the number types
    311311      LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
    312312        "The flow type of CapacityScaling must be signed");
     
    412412    /// If it is not used before calling \ref run(), the upper bounds
    413413    /// will be set to \ref INF on all arcs (i.e. the flow value will be
    414     /// unbounded from above on each arc).
     414    /// unbounded from above).
    415415    ///
    416416    /// \param map An arc map storing the upper bounds.
     
    515515    /// \ref reset() is called, thus only the modified parameters
    516516    /// have to be set again. See \ref reset() for examples.
    517     /// However the underlying digraph must not be modified after this
     517    /// However, the underlying digraph must not be modified after this
    518518    /// class have been constructed, since it copies and extends the graph.
    519519    ///
     
    528528    /// \n \c UNBOUNDED if the digraph contains an arc of negative cost
    529529    /// and infinite upper bound. It means that the objective function
    530     /// is unbounded on that arc, however note that it could actually be
     530    /// is unbounded on that arc, however, note that it could actually be
    531531    /// bounded over the feasible flows, but this algroithm cannot handle
    532532    /// these cases.
  • lemon/cost_scaling.h

    r810 r812  
    4141  /// Default traits class of CostScaling algorithm.
    4242  /// \tparam GR Digraph type.
    43   /// \tparam V The value type used for flow amounts, capacity bounds
     43  /// \tparam V The number type used for flow amounts, capacity bounds
    4444  /// and supply values. By default it is \c int.
    45   /// \tparam C The value type used for costs and potentials.
     45  /// \tparam C The number type used for costs and potentials.
    4646  /// By default it is the same as \c V.
    4747#ifdef DOXYGEN
     
    102102  ///
    103103  /// \tparam GR The digraph type the algorithm runs on.
    104   /// \tparam V The value type used for flow amounts, capacity bounds
     104  /// \tparam V The number type used for flow amounts, capacity bounds
    105105  /// and supply values in the algorithm. By default it is \c int.
    106   /// \tparam C The value type used for costs and potentials in the
     106  /// \tparam C The number type used for costs and potentials in the
    107107  /// algorithm. By default it is the same as \c V.
    108108  ///
    109   /// \warning Both value types must be signed and all input data must
     109  /// \warning Both number types must be signed and all input data must
    110110  /// be integer.
    111111  /// \warning This algorithm does not support negative costs for such
     
    158158      /// The digraph contains an arc of negative cost and infinite
    159159      /// upper bound. It means that the objective function is unbounded
    160       /// on that arc, however note that it could actually be bounded
     160      /// on that arc, however, note that it could actually be bounded
    161161      /// over the feasible flows, but this algroithm cannot handle
    162162      /// these cases.
     
    326326          std::numeric_limits<Value>::max())
    327327    {
    328       // Check the value types
     328      // Check the number types
    329329      LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
    330330        "The flow type of CostScaling must be signed");
     
    434434    /// If it is not used before calling \ref run(), the upper bounds
    435435    /// will be set to \ref INF on all arcs (i.e. the flow value will be
    436     /// unbounded from above on each arc).
     436    /// unbounded from above).
    437437    ///
    438438    /// \param map An arc map storing the upper bounds.
     
    550550    /// \n \c UNBOUNDED if the digraph contains an arc of negative cost
    551551    /// and infinite upper bound. It means that the objective function
    552     /// is unbounded on that arc, however note that it could actually be
     552    /// is unbounded on that arc, however, note that it could actually be
    553553    /// bounded over the feasible flows, but this algroithm cannot handle
    554554    /// these cases.
     
    572572    /// used, all the parameters given before are kept for the next
    573573    /// \ref run() call.
    574     /// However the underlying digraph must not be modified after this
     574    /// However, the underlying digraph must not be modified after this
    575575    /// class have been constructed, since it copies and extends the graph.
    576576    ///
  • lemon/network_simplex.h

    r811 r812  
    4444  /// \ref amo93networkflows, \ref dantzig63linearprog,
    4545  /// \ref kellyoneill91netsimplex.
    46   /// This algorithm is a specialized version of the linear programming
    47   /// simplex method directly for the minimum cost flow problem.
    48   /// It is one of the most efficient solution methods.
     46  /// This algorithm is a highly efficient specialized version of the
     47  /// linear programming simplex method directly for the minimum cost
     48  /// flow problem.
    4949  ///
    50   /// In general this class is the fastest implementation available
    51   /// in LEMON for the minimum cost flow problem.
    52   /// Moreover it supports both directions of the supply/demand inequality
     50  /// In general, %NetworkSimplex is the fastest implementation available
     51  /// in LEMON for this problem.
     52  /// Moreover, it supports both directions of the supply/demand inequality
    5353  /// constraints. For more information, see \ref SupplyType.
    5454  ///
     
    5959  ///
    6060  /// \tparam GR The digraph type the algorithm runs on.
    61   /// \tparam V The value type used for flow amounts, capacity bounds
     61  /// \tparam V The number type used for flow amounts, capacity bounds
    6262  /// and supply values in the algorithm. By default, it is \c int.
    63   /// \tparam C The value type used for costs and potentials in the
     63  /// \tparam C The number type used for costs and potentials in the
    6464  /// algorithm. By default, it is the same as \c V.
    6565  ///
    66   /// \warning Both value types must be signed and all input data must
     66  /// \warning Both number types must be signed and all input data must
    6767  /// be integer.
    6868  ///
     
    127127    /// By default, \ref BLOCK_SEARCH "Block Search" is used, which
    128128    /// proved to be the most efficient and the most robust on various
    129     /// test inputs according to our benchmark tests.
     129    /// test inputs.
    130130    /// However, another pivot rule can be selected using the \ref run()
    131131    /// function with the proper parameter.
     
    638638          std::numeric_limits<Value>::infinity() : MAX)
    639639    {
    640       // Check the value types
     640      // Check the number types
    641641      LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
    642642        "The flow type of NetworkSimplex must be signed");
     
    730730    /// If it is not used before calling \ref run(), the upper bounds
    731731    /// will be set to \ref INF on all arcs (i.e. the flow value will be
    732     /// unbounded from above on each arc).
     732    /// unbounded from above).
    733733    ///
    734734    /// \param map An arc map storing the upper bounds.
Note: See TracChangeset for help on using the changeset viewer.