# Changeset 2620:8f41a3129746 in lemon-0.x

Ignore:
Timestamp:
10/05/08 15:37:17 (11 years ago)
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3505
Message:

Doc improvements

Location:
lemon
Files:
6 edited

Unmodified
Added
Removed
• ## lemon/capacity_scaling.h

 r2589 /// /// \author Peter Kovacs template < typename Graph, typename LowerMap = typename Graph::template EdgeMap, {} /// Runs the algorithm from the given source node. /// Run the algorithm from the given source node. Node run(Node s, Capacity delta = 1) { HeapCrossRef heap_cross_ref(_graph, Heap::PRE_HEAP); } /// \brief Sets the flow map. /// /// Sets the flow map. /// \brief Set the flow map. /// /// Set the flow map. /// /// \return \c (*this) } /// \brief Sets the potential map. /// /// Sets the potential map. /// \brief Set the potential map. /// /// Set the potential map. /// /// \return \c (*this) /// \name Execution control /// The only way to execute the algorithm is to call the run() /// function. /// @{ /// \brief Runs the algorithm. /// /// Runs the algorithm. /// \brief Run the algorithm. /// /// This function runs the algorithm. /// /// \param scaling Enable or disable capacity scaling. /// \name Query Functions /// The result of the algorithm can be obtained using these /// functions. /// \n run() must be called before using them. /// The results of the algorithm can be obtained using these /// functions.\n /// \ref lemon::CapacityScaling::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. } /// \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). /// } /// \brief Returns the flow on the given edge. /// /// Returns the flow on the given edge. /// \brief Return the flow on the given edge. /// /// Return the flow on the given edge. /// /// \pre \ref run() must be called before using this function. } /// \brief Returns the potential of the given node. /// /// Returns the potential of the given node. /// \brief Return the potential of the given node. /// /// Return the potential of the given node. /// /// \pre \ref run() must be called before using this function. } /// \brief Returns the total cost of the found flow. /// /// Returns the total cost of the found flow. The complexity of the /// \brief Return the total cost of the found flow. /// /// Return the total cost of the found flow. The complexity of the /// function is \f$O(e) \f$. /// private: /// Initializes the algorithm. /// Initialize the algorithm. bool init(bool scaling) { if (!_valid_supply) return false; } /// Executes the capacity scaling algorithm. /// Execute the capacity scaling algorithm. bool startWithScaling() { // Processing capacity scaling phases if (_excess[n] <= -_delta) _deficit_nodes.push_back(n); } int next_node = 0; int next_node = 0, next_def_node = 0; // Finding augmenting shortest paths if (_delta > 1) { bool delta_deficit = false; for (int i = 0; i < int(_deficit_nodes.size()); ++i) { if (_excess[_deficit_nodes[i]] <= -_delta) { for ( ; next_def_node < int(_deficit_nodes.size()); ++next_def_node ) { if (_excess[_deficit_nodes[next_def_node]] <= -_delta) { delta_deficit = true; break; } /// Executes the successive shortest path algorithm. /// Execute the successive shortest path algorithm. bool startWithoutScaling() { // Finding excess nodes
• ## lemon/cost_scaling.h

 r2588 /// /// \author Peter Kovacs template < typename Graph, typename LowerMap = typename Graph::template EdgeMap, /// \brief Map adaptor class for handling residual edge costs. /// /// \ref ResidualCostMap is a map adaptor class for handling /// residual edge costs. /// Map adaptor class for handling residual edge costs. template class ResidualCostMap : public MapBase /// \brief Map adaptor class for handling reduced edge costs. /// /// \ref ReducedCostMap is a map adaptor class for handling reduced /// edge costs. /// Map adaptor class for handling reduced edge costs. class ReducedCostMap : public MapBase { } /// \brief Sets the flow map. /// /// Sets the flow map. /// \brief Set the flow map. /// /// Set the flow map. /// /// \return \c (*this) } /// \brief Sets the potential map. /// /// Sets the potential map. /// \brief Set the potential map. /// /// Set the potential map. /// /// \return \c (*this) /// \name Execution control /// The only way to execute the algorithm is to call the run() /// function. /// @{ /// \brief Runs the algorithm. /// /// Runs the algorithm. /// \brief Run the algorithm. /// /// Run the algorithm. /// /// \return \c true if a feasible flow can be found. /// \name Query Functions /// The result of the algorithm can be obtained using these /// functions. /// \n run() must be called before using them. /// functions.\n /// \ref lemon::CostScaling::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. } /// \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). /// } /// \brief Returns the flow on the given edge. /// /// Returns the flow on the given edge. /// \brief Return the flow on the given edge. /// /// Return the flow on the given edge. /// /// \pre \ref run() must be called before using this function. } /// \brief Returns the potential of the given node. /// /// Returns the potential of the given node. /// \brief Return the potential of the given node. /// /// Return the potential of the given node. /// /// \pre \ref run() must be called before using this function. } /// \brief Returns the total cost of the found flow. /// /// Returns the total cost of the found flow. The complexity of the /// \brief Return the total cost of the found flow. /// /// Return the total cost of the found flow. The complexity of the /// function is \f$O(e) \f$. /// private: /// Initializes the algorithm. /// Initialize the algorithm. bool init() { if (!_valid_supply) return false; /// Executes the algorithm. /// Execute the algorithm. bool start() { std::deque active_nodes;
• ## lemon/cycle_canceling.h

 r2593 /// /// \author Peter Kovacs template < typename Graph, typename LowerMap = typename Graph::template EdgeMap, /// \brief Map adaptor class for handling residual edge costs. /// /// \ref ResidualCostMap is a map adaptor class for handling /// residual edge costs. /// Map adaptor class for handling residual edge costs. class ResidualCostMap : public MapBase { } /// \brief Sets the flow map. /// /// Sets the flow map. /// \brief Set the flow map. /// /// Set the flow map. /// /// \return \c (*this) } /// \brief Sets the potential map. /// /// Sets the potential map. /// \brief Set the potential map. /// /// Set the potential map. /// /// \return \c (*this) /// \name Execution control /// The only way to execute the algorithm is to call the run() /// function. /// @{ /// \brief Runs the algorithm. /// /// Runs the algorithm. /// \brief Run the algorithm. /// /// Run the algorithm. /// /// \param min_mean_cc Set this parameter to \c true to run the /// \name Query Functions /// The result of the algorithm can be obtained using these /// functions. /// \n run() must be called before using them. /// functions.\n /// \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. } /// \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). /// } /// \brief Returns the flow on the given edge. /// /// Returns the flow on the given edge. /// \brief Return the flow on the given edge. /// /// Return the flow on the given edge. /// /// \pre \ref run() must be called before using this function. } /// \brief Returns the potential of the given node. /// /// Returns the potential of the given node. /// \brief Return the potential of the given node. /// /// Return the potential of the given node. /// /// \pre \ref run() must be called before using this function. } /// \brief Returns the total cost of the found flow. /// /// Returns the total cost of the found flow. The complexity of the /// \brief Return the total cost of the found flow. /// /// Return the total cost of the found flow. The complexity of the /// function is \f$O(e) \f$. /// private: /// Initializes the algorithm. /// Initialize the algorithm. bool init() { if (!_valid_supply) return false; } /// \brief Executes the algorithm using \ref BellmanFord. /// /// Executes the algorithm using the \ref BellmanFord /// \brief Execute the algorithm using \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. } /// \brief Executes the algorithm using \ref MinMeanCycle. /// /// Executes the algorithm using \ref MinMeanCycle for negative /// \brief Execute the algorithm using \ref MinMeanCycle. /// /// Execute the algorithm using \ref MinMeanCycle for negative /// cycle detection. void startMinMean() {
• ## lemon/min_cost_flow.h

 r2588 /// /// \author Peter Kovacs template < typename Graph, typename LowerMap = typename Graph::template EdgeMap,
• ## lemon/min_cost_max_flow.h

 r2587 /// /// \author Peter Kovacs template < typename Graph, typename CapacityMap = typename Graph::template EdgeMap, } /// \brief Sets the flow map. /// /// Sets the flow map. /// \brief Set the flow map. /// /// Set the flow map. /// /// \return \c (*this) } /// \brief Sets the potential map. /// /// Sets the potential map. /// \brief Set the potential map. /// /// Set the potential map. /// /// \return \c (*this) /// \name Execution control /// The only way to execute the algorithm is to call the run() /// function. /// @{ /// \brief Runs the algorithm. /// /// Runs the algorithm. /// \brief Run the algorithm. /// /// Run the algorithm. void run() { // Initializing maps /// \name Query Functions /// The result of the algorithm can be obtained using these /// functions. /// \n run() must be called before using them. /// The results of the algorithm can be obtained using these /// functions.\n /// \ref lemon::MinCostMaxFlow::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. } /// \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). /// } /// \brief Returns the flow on the given edge. /// /// Returns the flow on the given edge. /// \brief Return the flow on the given edge. /// /// Return the flow on the given edge. /// /// \pre \ref run() must be called before using this function. } /// \brief Returns the potential of the given node. /// /// Returns the potential of the given node. /// \brief Return the potential of the given node. /// /// Return the potential of the given node. /// /// \pre \ref run() must be called before using this function. } /// \brief Returns the total cost of the found flow. /// /// Returns the total cost of the found flow. The complexity of the /// \brief Return the total cost of the found flow. /// /// Return the total cost of the found flow. The complexity of the /// function is \f$O(e) \f$. ///
• ## lemon/min_mean_cycle.h

 r2618 return true; } /// @} /// @{ /// \brief Returns the total length of the found cycle. /// return *_cycle_path; } ///@} private:
Note: See TracChangeset for help on using the changeset viewer.