lemon: comparison lemon/preflow.h

equal deleted inserted replaced

-:98068a26173e
+:8d3d731b597a
 /// \brief Default traits class of Preflow class.
 ///
 /// Default traits class of Preflow class.
 /// \tparam GR Digraph type.
-/// \tparam CM Capacity map type.
+/// \tparam CAP Capacity map type.
-template <typename GR, typename CM>
+template <typename GR, typename CAP>
 struct PreflowDefaultTraits {
 /// \brief The type of the digraph the algorithm runs on.
 typedef GR Digraph;
 /// \brief The type of the map that stores the arc capacities.
 ///
 /// The type of the map that stores the arc capacities.
 /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
-typedef CM CapacityMap;
+typedef CAP CapacityMap;
 /// \brief The type of the flow values.
 typedef typename CapacityMap::Value Value;
 /// \brief The type of the map that stores the flow values.
 /// \ingroup max_flow
 ///
 /// \brief %Preflow algorithm class.
 ///
 /// This class provides an implementation of Goldberg-Tarjan's \e preflow
-/// \e push-relabel algorithm producing a flow of maximum value in a
+/// \e push-relabel algorithm producing a \ref max_flow
-/// digraph. The preflow algorithms are the fastest known maximum
+/// "flow of maximum value" in a digraph.
+/// The preflow algorithms are the fastest known maximum
 /// flow algorithms. The current implementation use a mixture of the
 /// \e "highest label" and the \e "bound decrease" heuristics.
 /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$.
 ///
 /// The algorithm consists of two phases. After the first phase
 /// the maximum flow value and the minimum cut is obtained. The
 /// second phase constructs a feasible maximum flow on each arc.
 ///
 /// \tparam GR The type of the digraph the algorithm runs on.
-/// \tparam CM The type of the capacity map. The default map
+/// \tparam CAP The type of the capacity map. The default map
 /// type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
 #ifdef DOXYGEN
-template <typename GR, typename CM, typename TR>
+template <typename GR, typename CAP, typename TR>
 #else
 template <typename GR,
-typename CM = typename GR::template ArcMap<int>,
+typename CAP = typename GR::template ArcMap<int>,
-typename TR = PreflowDefaultTraits<GR, CM> >
+typename TR = PreflowDefaultTraits<GR, CAP> >
 #endif
 class Preflow {
 public:
 ///The \ref PreflowDefaultTraits "traits class" of the algorithm.
 ///\name Named Template Parameters
 ///@{
-template <typename _FlowMap>
+template <typename T>
 struct SetFlowMapTraits : public Traits {
-typedef _FlowMap FlowMap;
+typedef T FlowMap;
 static FlowMap *createFlowMap(const Digraph&) {
 LEMON_ASSERT(false, "FlowMap is not initialized");
 return 0; // ignore warnings
 }
 };
 /// \brief \ref named-templ-param "Named parameter" for setting
 /// FlowMap type
 ///
 /// \ref named-templ-param "Named parameter" for setting FlowMap
 /// type.
-template <typename _FlowMap>
+template <typename T>
 struct SetFlowMap
-: public Preflow<Digraph, CapacityMap, SetFlowMapTraits<_FlowMap> > {
+: public Preflow<Digraph, CapacityMap, SetFlowMapTraits<T> > {
 typedef Preflow<Digraph, CapacityMap,
-SetFlowMapTraits<_FlowMap> > Create;
+SetFlowMapTraits<T> > Create;
 };
-template <typename _Elevator>
+template <typename T>
 struct SetElevatorTraits : public Traits {
-typedef _Elevator Elevator;
+typedef T Elevator;
 static Elevator *createElevator(const Digraph&, int) {
 LEMON_ASSERT(false, "Elevator is not initialized");
 return 0; // ignore warnings
 }
 };
 /// type. If this named parameter is used, then an external
 /// elevator object must be passed to the algorithm using the
 /// \ref elevator(Elevator&) "elevator()" function before calling
 /// \ref run() or \ref init().
 /// \sa SetStandardElevator
-template <typename _Elevator>
+template <typename T>
 struct SetElevator
-: public Preflow<Digraph, CapacityMap, SetElevatorTraits<_Elevator> > {
+: public Preflow<Digraph, CapacityMap, SetElevatorTraits<T> > {
 typedef Preflow<Digraph, CapacityMap,
-SetElevatorTraits<_Elevator> > Create;
+SetElevatorTraits<T> > Create;
 };
-template <typename _Elevator>
+template <typename T>
 struct SetStandardElevatorTraits : public Traits {
-typedef _Elevator Elevator;
+typedef T Elevator;
 static Elevator *createElevator(const Digraph& digraph, int max_level) {
 return new Elevator(digraph, max_level);
 }
 };
 /// digraph and the maximum level should be passed to it).
 /// However an external elevator object could also be passed to the
 /// algorithm with the \ref elevator(Elevator&) "elevator()" function
 /// before calling \ref run() or \ref init().
 /// \sa SetElevator
-template <typename _Elevator>
+template <typename T>
 struct SetStandardElevator
 : public Preflow<Digraph, CapacityMap,
-SetStandardElevatorTraits<_Elevator> > {
+SetStandardElevatorTraits<T> > {
 typedef Preflow<Digraph, CapacityMap,
-SetStandardElevatorTraits<_Elevator> > Create;
+SetStandardElevatorTraits<T> > Create;
 };
 /// @}
 protected:
 /// This method can be called both after running \ref startFirstPhase()
 /// and \ref startSecondPhase(). The result after the second phase
 /// could be slightly different if inexact computation is used.
 ///
 /// \note This function calls \ref minCut() for each node, so it runs in
-/// \f$O(n)\f$ time.
+/// O(n) time.
 ///
 /// \pre Either \ref run() or \ref init() must be called before
 /// using this function.
 template <typename CutMap>
 void minCutMap(CutMap& cutMap) const {

changeset 606	c5fd2d996909
parent 525	9605e051942f
child 628	aa1804409f29