lemon-0.x: comparison lemon/cycle

equal deleted inserted replaced

-:115a3ce0e7f9
+:e27e8ec61013
 /// but rather slower in practice.
 /// To use this version of the algorithm, call \ref run() with \c true
 /// parameter.
 ///
 /// \author Peter Kovacs
 template < typename Graph,
 typename LowerMap = typename Graph::template EdgeMap<int>,
 typename CapacityMap = typename Graph::template EdgeMap<int>,
 typename CostMap = typename Graph::template EdgeMap<int>,
 typename SupplyMap = typename Graph::template NodeMap<int> >
 private:
 /// \brief Map adaptor class for handling residual edge costs.
 ///
-/// \ref ResidualCostMap is a map adaptor class for handling
+/// Map adaptor class for handling residual edge costs.
-/// residual edge costs.
 class ResidualCostMap : public MapBase<ResEdge, Cost>
 {
 private:
 const CostMap &_cost_map;
 if (_local_flow) delete _flow;
 if (_local_potential) delete _potential;
 delete _res_graph;
 }
-/// \brief Sets the flow map.
+/// \brief Set the flow map.
 ///
-/// Sets the flow map.
+/// Set the flow map.
 ///
 /// \return \c (*this)
 CycleCanceling& flowMap(FlowMap &map) {
 if (_local_flow) {
 delete _flow;
 }
 _flow = &map;
 return *this;
 }
-/// \brief Sets the potential map.
+/// \brief Set the potential map.
 ///
-/// Sets the potential map.
+/// Set the potential map.
 ///
 /// \return \c (*this)
 CycleCanceling& potentialMap(PotentialMap &map) {
 if (_local_potential) {
 delete _potential;
 _potential = &map;
 return *this;
 }
 /// \name Execution control
-/// The only way to execute the algorithm is to call the run()
-/// function.
 /// @{
-/// \brief Runs the algorithm.
+/// \brief Run the algorithm.
 ///
-/// Runs the algorithm.
+/// Run the algorithm.
 ///
 /// \param min_mean_cc Set this parameter to \c true to run the
 /// "Minimum Mean Cycle-Canceling" algorithm, which is strongly
 /// polynomial, but rather slower in practice.
 ///
 /// @}
 /// \name Query Functions
 /// The result of the algorithm can be obtained using these
-/// functions.
+/// functions.\n
-/// \n run() must be called before using them.
+/// \ref lemon::CycleCanceling::run() "run()" must be called before
+/// using them.
 /// @{
-/// \brief Returns a const reference to the edge map storing the
+/// \brief Return a const reference to the edge map storing the
 /// found flow.
 ///
-/// Returns a const reference to the edge map storing the found flow.
+/// Return a const reference to the edge map storing the found flow.
 ///
 /// \pre \ref run() must be called before using this function.
 const FlowMap& flowMap() const {
 return *_flow;
 }
-/// \brief Returns a const reference to the node map storing the
+/// \brief Return a const reference to the node map storing the
 /// found potentials (the dual solution).
 ///
-/// Returns a const reference to the node map storing the found
+/// Return a const reference to the node map storing the found
 /// potentials (the dual solution).
 ///
 /// \pre \ref run() must be called before using this function.
 const PotentialMap& potentialMap() const {
 return *_potential;
 }
-/// \brief Returns the flow on the given edge.
+/// \brief Return the flow on the given edge.
 ///
-/// Returns the flow on the given edge.
+/// Return the flow on the given edge.
 ///
 /// \pre \ref run() must be called before using this function.
 Capacity flow(const Edge& edge) const {
 return (*_flow)[edge];
 }
-/// \brief Returns the potential of the given node.
+/// \brief Return the potential of the given node.
 ///
-/// Returns the potential of the given node.
+/// Return the potential of the given node.
 ///
 /// \pre \ref run() must be called before using this function.
 Cost potential(const Node& node) const {
 return (*_potential)[node];
 }
-/// \brief Returns the total cost of the found flow.
+/// \brief Return the total cost of the found flow.
 ///
-/// Returns the total cost of the found flow. The complexity of the
+/// Return the total cost of the found flow. The complexity of the
 /// function is \f$ O(e) \f$.
 ///
 /// \pre \ref run() must be called before using this function.
 Cost totalCost() const {
 Cost c = 0;
 /// @}
 private:
-/// Initializes the algorithm.
+/// Initialize the algorithm.
 bool init() {
 if (!_valid_supply) return false;
 // Initializing flow and potential maps
 if (!_flow) {
 (*_flow)[e] += (*_lower)[e];
 }
 return true;
 }
-/// \brief Executes the algorithm using \ref BellmanFord.
+/// \brief Execute the algorithm using \ref BellmanFord.
 ///
-/// Executes the algorithm using the \ref BellmanFord
+/// Execute the algorithm using the \ref BellmanFord
 /// "Bellman-Ford" algorithm for negative cycle detection with
 /// successively larger limit for the number of iterations.
 void start() {
 typename BellmanFord<ResGraph, ResidualCostMap>::PredMap pred(*_res_graph);
 typename ResGraph::template NodeMap<int> visited(*_res_graph);
 length_bound = length_bound * BF_LIMIT_FACTOR / 100;
 }
 }
 }
-/// \brief Executes the algorithm using \ref MinMeanCycle.
+/// \brief Execute the algorithm using \ref MinMeanCycle.
 ///
-/// Executes the algorithm using \ref MinMeanCycle for negative
+/// Execute the algorithm using \ref MinMeanCycle for negative
 /// cycle detection.
 void startMinMean() {
 typedef Path<ResGraph> ResPath;
 MinMeanCycle<ResGraph, ResidualCostMap> mmc(*_res_graph, _res_cost);
 ResPath cycle;

changeset 2622	fa2877651022
parent 2593	8eed667ea23c
child 2623	90defb96ee61