# Changeset 878:4b1b378823dc in lemon for lemon

Ignore:
Timestamp:
11/12/09 23:49:05 (12 years ago)
Branch:
default
Phase:
public
Rebase:
30323866356537663935353430623930626534653939636630353730643832346265623131623731
Message:

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

Location:
lemon
Files:
3 edited

Unmodified
Removed
• ## lemon/capacity_scaling.h

 r877 /// Default traits class of CapacityScaling algorithm. /// \tparam GR Digraph type. /// \tparam V The value type used for flow amounts, capacity bounds /// \tparam V The number type used for flow amounts, capacity bounds /// and supply values. By default it is \c int. /// \tparam C The value type used for costs and potentials. /// \tparam C The number type used for costs and potentials. /// By default it is the same as \c V. template /// /// \tparam GR The digraph type the algorithm runs on. /// \tparam V The value type used for flow amounts, capacity bounds /// \tparam V The number type used for flow amounts, capacity bounds /// and supply values in the algorithm. By default it is \c int. /// \tparam C The value type used for costs and potentials in the /// \tparam C The number type used for costs and potentials in the /// algorithm. By default it is the same as \c V. /// /// \warning Both value types must be signed and all input data must /// \warning Both number types must be signed and all input data must /// be integer. /// \warning This algorithm does not support negative costs for such /// The digraph contains an arc of negative cost and infinite /// upper bound. It means that the objective function is unbounded /// on that arc, however note that it could actually be bounded /// on that arc, however, note that it could actually be bounded /// over the feasible flows, but this algroithm cannot handle /// these cases. std::numeric_limits::max()) { // Check the value types // Check the number types LEMON_ASSERT(std::numeric_limits::is_signed, "The flow type of CapacityScaling must be signed"); /// If it is not used before calling \ref run(), the upper bounds /// will be set to \ref INF on all arcs (i.e. the flow value will be /// unbounded from above on each arc). /// unbounded from above). /// /// \param map An arc map storing the upper bounds. /// \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 /// However, the underlying digraph must not be modified after this /// class have been constructed, since it copies and extends the graph. /// /// \n \c UNBOUNDED if the digraph contains an arc of negative cost /// and infinite upper bound. It means that the objective function /// is unbounded on that arc, however note that it could actually be /// is unbounded on that arc, however, note that it could actually be /// bounded over the feasible flows, but this algroithm cannot handle /// these cases.
• ## lemon/cost_scaling.h

 r876 /// Default traits class of CostScaling algorithm. /// \tparam GR Digraph type. /// \tparam V The value type used for flow amounts, capacity bounds /// \tparam V The number type used for flow amounts, capacity bounds /// and supply values. By default it is \c int. /// \tparam C The value type used for costs and potentials. /// \tparam C The number type used for costs and potentials. /// By default it is the same as \c V. #ifdef DOXYGEN /// /// \tparam GR The digraph type the algorithm runs on. /// \tparam V The value type used for flow amounts, capacity bounds /// \tparam V The number type used for flow amounts, capacity bounds /// and supply values in the algorithm. By default it is \c int. /// \tparam C The value type used for costs and potentials in the /// \tparam C The number type used for costs and potentials in the /// algorithm. By default it is the same as \c V. /// /// \warning Both value types must be signed and all input data must /// \warning Both number types must be signed and all input data must /// be integer. /// \warning This algorithm does not support negative costs for such /// The digraph contains an arc of negative cost and infinite /// upper bound. It means that the objective function is unbounded /// on that arc, however note that it could actually be bounded /// on that arc, however, note that it could actually be bounded /// over the feasible flows, but this algroithm cannot handle /// these cases. std::numeric_limits::max()) { // Check the value types // Check the number types LEMON_ASSERT(std::numeric_limits::is_signed, "The flow type of CostScaling must be signed"); /// If it is not used before calling \ref run(), the upper bounds /// will be set to \ref INF on all arcs (i.e. the flow value will be /// unbounded from above on each arc). /// unbounded from above). /// /// \param map An arc map storing the upper bounds. /// \n \c UNBOUNDED if the digraph contains an arc of negative cost /// and infinite upper bound. It means that the objective function /// is unbounded on that arc, however note that it could actually be /// is unbounded on that arc, however, note that it could actually be /// bounded over the feasible flows, but this algroithm cannot handle /// these cases. /// used, all the parameters given before are kept for the next /// \ref run() call. /// However the underlying digraph must not be modified after this /// However, the underlying digraph must not be modified after this /// class have been constructed, since it copies and extends the graph. ///
• ## lemon/network_simplex.h

 r877 /// \ref amo93networkflows, \ref dantzig63linearprog, /// \ref kellyoneill91netsimplex. /// This algorithm is a specialized version of the linear programming /// simplex method directly for the minimum cost flow problem. /// It is one of the most efficient solution methods. /// This algorithm is a highly efficient specialized version of the /// linear programming simplex method directly for the minimum cost /// flow problem. /// /// In general this class is the fastest implementation available /// in LEMON for the minimum cost flow problem. /// Moreover it supports both directions of the supply/demand inequality /// In general, %NetworkSimplex is the fastest implementation available /// in LEMON for this problem. /// Moreover, it supports both directions of the supply/demand inequality /// constraints. For more information, see \ref SupplyType. /// /// /// \tparam GR The digraph type the algorithm runs on. /// \tparam V The value type used for flow amounts, capacity bounds /// \tparam V The number type used for flow amounts, capacity bounds /// and supply values in the algorithm. By default, it is \c int. /// \tparam C The value type used for costs and potentials in the /// \tparam C The number type used for costs and potentials in the /// algorithm. By default, it is the same as \c V. /// /// \warning Both value types must be signed and all input data must /// \warning Both number types must be signed and all input data must /// be integer. /// /// By default, \ref BLOCK_SEARCH "Block Search" is used, which /// proved to be the most efficient and the most robust on various /// test inputs according to our benchmark tests. /// test inputs. /// However, another pivot rule can be selected using the \ref run() /// function with the proper parameter. std::numeric_limits::infinity() : MAX) { // Check the value types // Check the number types LEMON_ASSERT(std::numeric_limits::is_signed, "The flow type of NetworkSimplex must be signed"); /// If it is not used before calling \ref run(), the upper bounds /// will be set to \ref INF on all arcs (i.e. the flow value will be /// unbounded from above on each arc). /// unbounded from above). /// /// \param map An arc map storing the upper bounds.
Note: See TracChangeset for help on using the changeset viewer.