1.1 --- a/lemon/capacity_scaling.h Sun Oct 05 13:36:43 2008 +0000
1.2 +++ b/lemon/capacity_scaling.h Sun Oct 05 13:37:17 2008 +0000
1.3 @@ -52,7 +52,6 @@
1.4 /// - \c CostMap::Value must be signed type.
1.5 ///
1.6 /// \author Peter Kovacs
1.7 -
1.8 template < typename Graph,
1.9 typename LowerMap = typename Graph::template EdgeMap<int>,
1.10 typename CapacityMap = typename Graph::template EdgeMap<int>,
1.11 @@ -125,7 +124,7 @@
1.12 _pred(pred)
1.13 {}
1.14
1.15 - /// Runs the algorithm from the given source node.
1.16 + /// Run the algorithm from the given source node.
1.17 Node run(Node s, Capacity delta = 1) {
1.18 HeapCrossRef heap_cross_ref(_graph, Heap::PRE_HEAP);
1.19 Heap heap(heap_cross_ref);
1.20 @@ -371,9 +370,9 @@
1.21 delete _dijkstra;
1.22 }
1.23
1.24 - /// \brief Sets the flow map.
1.25 + /// \brief Set the flow map.
1.26 ///
1.27 - /// Sets the flow map.
1.28 + /// Set the flow map.
1.29 ///
1.30 /// \return \c (*this)
1.31 CapacityScaling& flowMap(FlowMap &map) {
1.32 @@ -385,9 +384,9 @@
1.33 return *this;
1.34 }
1.35
1.36 - /// \brief Sets the potential map.
1.37 + /// \brief Set the potential map.
1.38 ///
1.39 - /// Sets the potential map.
1.40 + /// Set the potential map.
1.41 ///
1.42 /// \return \c (*this)
1.43 CapacityScaling& potentialMap(PotentialMap &map) {
1.44 @@ -400,14 +399,12 @@
1.45 }
1.46
1.47 /// \name Execution control
1.48 - /// The only way to execute the algorithm is to call the run()
1.49 - /// function.
1.50
1.51 /// @{
1.52
1.53 - /// \brief Runs the algorithm.
1.54 + /// \brief Run the algorithm.
1.55 ///
1.56 - /// Runs the algorithm.
1.57 + /// This function runs the algorithm.
1.58 ///
1.59 /// \param scaling Enable or disable capacity scaling.
1.60 /// If the maximum edge capacity and/or the amount of total supply
1.61 @@ -422,26 +419,27 @@
1.62 /// @}
1.63
1.64 /// \name Query Functions
1.65 - /// The result of the algorithm can be obtained using these
1.66 - /// functions.
1.67 - /// \n run() must be called before using them.
1.68 + /// The results of the algorithm can be obtained using these
1.69 + /// functions.\n
1.70 + /// \ref lemon::CapacityScaling::run() "run()" must be called before
1.71 + /// using them.
1.72
1.73 /// @{
1.74
1.75 - /// \brief Returns a const reference to the edge map storing the
1.76 + /// \brief Return a const reference to the edge map storing the
1.77 /// found flow.
1.78 ///
1.79 - /// Returns a const reference to the edge map storing the found flow.
1.80 + /// Return a const reference to the edge map storing the found flow.
1.81 ///
1.82 /// \pre \ref run() must be called before using this function.
1.83 const FlowMap& flowMap() const {
1.84 return *_flow;
1.85 }
1.86
1.87 - /// \brief Returns a const reference to the node map storing the
1.88 + /// \brief Return a const reference to the node map storing the
1.89 /// found potentials (the dual solution).
1.90 ///
1.91 - /// Returns a const reference to the node map storing the found
1.92 + /// Return a const reference to the node map storing the found
1.93 /// potentials (the dual solution).
1.94 ///
1.95 /// \pre \ref run() must be called before using this function.
1.96 @@ -449,27 +447,27 @@
1.97 return *_potential;
1.98 }
1.99
1.100 - /// \brief Returns the flow on the given edge.
1.101 + /// \brief Return the flow on the given edge.
1.102 ///
1.103 - /// Returns the flow on the given edge.
1.104 + /// Return the flow on the given edge.
1.105 ///
1.106 /// \pre \ref run() must be called before using this function.
1.107 Capacity flow(const Edge& edge) const {
1.108 return (*_flow)[edge];
1.109 }
1.110
1.111 - /// \brief Returns the potential of the given node.
1.112 + /// \brief Return the potential of the given node.
1.113 ///
1.114 - /// Returns the potential of the given node.
1.115 + /// Return the potential of the given node.
1.116 ///
1.117 /// \pre \ref run() must be called before using this function.
1.118 Cost potential(const Node& node) const {
1.119 return (*_potential)[node];
1.120 }
1.121
1.122 - /// \brief Returns the total cost of the found flow.
1.123 + /// \brief Return the total cost of the found flow.
1.124 ///
1.125 - /// Returns the total cost of the found flow. The complexity of the
1.126 + /// Return the total cost of the found flow. The complexity of the
1.127 /// function is \f$ O(e) \f$.
1.128 ///
1.129 /// \pre \ref run() must be called before using this function.
1.130 @@ -484,7 +482,7 @@
1.131
1.132 private:
1.133
1.134 - /// Initializes the algorithm.
1.135 + /// Initialize the algorithm.
1.136 bool init(bool scaling) {
1.137 if (!_valid_supply) return false;
1.138
1.139 @@ -535,7 +533,7 @@
1.140 return startWithoutScaling();
1.141 }
1.142
1.143 - /// Executes the capacity scaling algorithm.
1.144 + /// Execute the capacity scaling algorithm.
1.145 bool startWithScaling() {
1.146 // Processing capacity scaling phases
1.147 Node s, t;
1.148 @@ -567,15 +565,16 @@
1.149 if (_excess[n] >= _delta) _excess_nodes.push_back(n);
1.150 if (_excess[n] <= -_delta) _deficit_nodes.push_back(n);
1.151 }
1.152 - int next_node = 0;
1.153 + int next_node = 0, next_def_node = 0;
1.154
1.155 // Finding augmenting shortest paths
1.156 while (next_node < int(_excess_nodes.size())) {
1.157 // Checking deficit nodes
1.158 if (_delta > 1) {
1.159 bool delta_deficit = false;
1.160 - for (int i = 0; i < int(_deficit_nodes.size()); ++i) {
1.161 - if (_excess[_deficit_nodes[i]] <= -_delta) {
1.162 + for ( ; next_def_node < int(_deficit_nodes.size());
1.163 + ++next_def_node ) {
1.164 + if (_excess[_deficit_nodes[next_def_node]] <= -_delta) {
1.165 delta_deficit = true;
1.166 break;
1.167 }
1.168 @@ -641,7 +640,7 @@
1.169 return true;
1.170 }
1.171
1.172 - /// Executes the successive shortest path algorithm.
1.173 + /// Execute the successive shortest path algorithm.
1.174 bool startWithoutScaling() {
1.175 // Finding excess nodes
1.176 for (NodeIt n(_graph); n != INVALID; ++n)
2.1 --- a/lemon/cost_scaling.h Sun Oct 05 13:36:43 2008 +0000
2.2 +++ b/lemon/cost_scaling.h Sun Oct 05 13:37:17 2008 +0000
2.3 @@ -64,7 +64,6 @@
2.4 /// <tt>long int</tt> in the inside computations.
2.5 ///
2.6 /// \author Peter Kovacs
2.7 -
2.8 template < typename Graph,
2.9 typename LowerMap = typename Graph::template EdgeMap<int>,
2.10 typename CapacityMap = typename Graph::template EdgeMap<int>,
2.11 @@ -102,8 +101,7 @@
2.12
2.13 /// \brief Map adaptor class for handling residual edge costs.
2.14 ///
2.15 - /// \ref ResidualCostMap is a map adaptor class for handling
2.16 - /// residual edge costs.
2.17 + /// Map adaptor class for handling residual edge costs.
2.18 template <typename Map>
2.19 class ResidualCostMap : public MapBase<ResEdge, typename Map::Value>
2.20 {
2.21 @@ -126,8 +124,7 @@
2.22
2.23 /// \brief Map adaptor class for handling reduced edge costs.
2.24 ///
2.25 - /// \ref ReducedCostMap is a map adaptor class for handling reduced
2.26 - /// edge costs.
2.27 + /// Map adaptor class for handling reduced edge costs.
2.28 class ReducedCostMap : public MapBase<Edge, LCost>
2.29 {
2.30 private:
2.31 @@ -326,9 +323,9 @@
2.32 delete _red_cost;
2.33 }
2.34
2.35 - /// \brief Sets the flow map.
2.36 + /// \brief Set the flow map.
2.37 ///
2.38 - /// Sets the flow map.
2.39 + /// Set the flow map.
2.40 ///
2.41 /// \return \c (*this)
2.42 CostScaling& flowMap(FlowMap &map) {
2.43 @@ -340,9 +337,9 @@
2.44 return *this;
2.45 }
2.46
2.47 - /// \brief Sets the potential map.
2.48 + /// \brief Set the potential map.
2.49 ///
2.50 - /// Sets the potential map.
2.51 + /// Set the potential map.
2.52 ///
2.53 /// \return \c (*this)
2.54 CostScaling& potentialMap(PotentialMap &map) {
2.55 @@ -355,14 +352,12 @@
2.56 }
2.57
2.58 /// \name Execution control
2.59 - /// The only way to execute the algorithm is to call the run()
2.60 - /// function.
2.61
2.62 /// @{
2.63
2.64 - /// \brief Runs the algorithm.
2.65 + /// \brief Run the algorithm.
2.66 ///
2.67 - /// Runs the algorithm.
2.68 + /// Run the algorithm.
2.69 ///
2.70 /// \return \c true if a feasible flow can be found.
2.71 bool run() {
2.72 @@ -373,25 +368,26 @@
2.73
2.74 /// \name Query Functions
2.75 /// The result of the algorithm can be obtained using these
2.76 - /// functions.
2.77 - /// \n run() must be called before using them.
2.78 + /// functions.\n
2.79 + /// \ref lemon::CostScaling::run() "run()" must be called before
2.80 + /// using them.
2.81
2.82 /// @{
2.83
2.84 - /// \brief Returns a const reference to the edge map storing the
2.85 + /// \brief Return a const reference to the edge map storing the
2.86 /// found flow.
2.87 ///
2.88 - /// Returns a const reference to the edge map storing the found flow.
2.89 + /// Return a const reference to the edge map storing the found flow.
2.90 ///
2.91 /// \pre \ref run() must be called before using this function.
2.92 const FlowMap& flowMap() const {
2.93 return *_flow;
2.94 }
2.95
2.96 - /// \brief Returns a const reference to the node map storing the
2.97 + /// \brief Return a const reference to the node map storing the
2.98 /// found potentials (the dual solution).
2.99 ///
2.100 - /// Returns a const reference to the node map storing the found
2.101 + /// Return a const reference to the node map storing the found
2.102 /// potentials (the dual solution).
2.103 ///
2.104 /// \pre \ref run() must be called before using this function.
2.105 @@ -399,27 +395,27 @@
2.106 return *_potential;
2.107 }
2.108
2.109 - /// \brief Returns the flow on the given edge.
2.110 + /// \brief Return the flow on the given edge.
2.111 ///
2.112 - /// Returns the flow on the given edge.
2.113 + /// Return the flow on the given edge.
2.114 ///
2.115 /// \pre \ref run() must be called before using this function.
2.116 Capacity flow(const Edge& edge) const {
2.117 return (*_flow)[edge];
2.118 }
2.119
2.120 - /// \brief Returns the potential of the given node.
2.121 + /// \brief Return the potential of the given node.
2.122 ///
2.123 - /// Returns the potential of the given node.
2.124 + /// Return the potential of the given node.
2.125 ///
2.126 /// \pre \ref run() must be called before using this function.
2.127 Cost potential(const Node& node) const {
2.128 return (*_potential)[node];
2.129 }
2.130
2.131 - /// \brief Returns the total cost of the found flow.
2.132 + /// \brief Return the total cost of the found flow.
2.133 ///
2.134 - /// Returns the total cost of the found flow. The complexity of the
2.135 + /// Return the total cost of the found flow. The complexity of the
2.136 /// function is \f$ O(e) \f$.
2.137 ///
2.138 /// \pre \ref run() must be called before using this function.
2.139 @@ -434,7 +430,7 @@
2.140
2.141 private:
2.142
2.143 - /// Initializes the algorithm.
2.144 + /// Initialize the algorithm.
2.145 bool init() {
2.146 if (!_valid_supply) return false;
2.147
2.148 @@ -469,7 +465,7 @@
2.149 }
2.150
2.151
2.152 - /// Executes the algorithm.
2.153 + /// Execute the algorithm.
2.154 bool start() {
2.155 std::deque<Node> active_nodes;
2.156 typename Graph::template NodeMap<bool> hyper(_graph, false);
3.1 --- a/lemon/cycle_canceling.h Sun Oct 05 13:36:43 2008 +0000
3.2 +++ b/lemon/cycle_canceling.h Sun Oct 05 13:37:17 2008 +0000
3.3 @@ -64,7 +64,6 @@
3.4 /// parameter.
3.5 ///
3.6 /// \author Peter Kovacs
3.7 -
3.8 template < typename Graph,
3.9 typename LowerMap = typename Graph::template EdgeMap<int>,
3.10 typename CapacityMap = typename Graph::template EdgeMap<int>,
3.11 @@ -98,8 +97,7 @@
3.12
3.13 /// \brief Map adaptor class for handling residual edge costs.
3.14 ///
3.15 - /// \ref ResidualCostMap is a map adaptor class for handling
3.16 - /// residual edge costs.
3.17 + /// Map adaptor class for handling residual edge costs.
3.18 class ResidualCostMap : public MapBase<ResEdge, Cost>
3.19 {
3.20 private:
3.21 @@ -278,9 +276,9 @@
3.22 delete _res_graph;
3.23 }
3.24
3.25 - /// \brief Sets the flow map.
3.26 + /// \brief Set the flow map.
3.27 ///
3.28 - /// Sets the flow map.
3.29 + /// Set the flow map.
3.30 ///
3.31 /// \return \c (*this)
3.32 CycleCanceling& flowMap(FlowMap &map) {
3.33 @@ -292,9 +290,9 @@
3.34 return *this;
3.35 }
3.36
3.37 - /// \brief Sets the potential map.
3.38 + /// \brief Set the potential map.
3.39 ///
3.40 - /// Sets the potential map.
3.41 + /// Set the potential map.
3.42 ///
3.43 /// \return \c (*this)
3.44 CycleCanceling& potentialMap(PotentialMap &map) {
3.45 @@ -307,14 +305,12 @@
3.46 }
3.47
3.48 /// \name Execution control
3.49 - /// The only way to execute the algorithm is to call the run()
3.50 - /// function.
3.51
3.52 /// @{
3.53
3.54 - /// \brief Runs the algorithm.
3.55 + /// \brief Run the algorithm.
3.56 ///
3.57 - /// Runs the algorithm.
3.58 + /// Run the algorithm.
3.59 ///
3.60 /// \param min_mean_cc Set this parameter to \c true to run the
3.61 /// "Minimum Mean Cycle-Canceling" algorithm, which is strongly
3.62 @@ -329,25 +325,26 @@
3.63
3.64 /// \name Query Functions
3.65 /// The result of the algorithm can be obtained using these
3.66 - /// functions.
3.67 - /// \n run() must be called before using them.
3.68 + /// functions.\n
3.69 + /// \ref lemon::CycleCanceling::run() "run()" must be called before
3.70 + /// using them.
3.71
3.72 /// @{
3.73
3.74 - /// \brief Returns a const reference to the edge map storing the
3.75 + /// \brief Return a const reference to the edge map storing the
3.76 /// found flow.
3.77 ///
3.78 - /// Returns a const reference to the edge map storing the found flow.
3.79 + /// Return a const reference to the edge map storing the found flow.
3.80 ///
3.81 /// \pre \ref run() must be called before using this function.
3.82 const FlowMap& flowMap() const {
3.83 return *_flow;
3.84 }
3.85
3.86 - /// \brief Returns a const reference to the node map storing the
3.87 + /// \brief Return a const reference to the node map storing the
3.88 /// found potentials (the dual solution).
3.89 ///
3.90 - /// Returns a const reference to the node map storing the found
3.91 + /// Return a const reference to the node map storing the found
3.92 /// potentials (the dual solution).
3.93 ///
3.94 /// \pre \ref run() must be called before using this function.
3.95 @@ -355,27 +352,27 @@
3.96 return *_potential;
3.97 }
3.98
3.99 - /// \brief Returns the flow on the given edge.
3.100 + /// \brief Return the flow on the given edge.
3.101 ///
3.102 - /// Returns the flow on the given edge.
3.103 + /// Return the flow on the given edge.
3.104 ///
3.105 /// \pre \ref run() must be called before using this function.
3.106 Capacity flow(const Edge& edge) const {
3.107 return (*_flow)[edge];
3.108 }
3.109
3.110 - /// \brief Returns the potential of the given node.
3.111 + /// \brief Return the potential of the given node.
3.112 ///
3.113 - /// Returns the potential of the given node.
3.114 + /// Return the potential of the given node.
3.115 ///
3.116 /// \pre \ref run() must be called before using this function.
3.117 Cost potential(const Node& node) const {
3.118 return (*_potential)[node];
3.119 }
3.120
3.121 - /// \brief Returns the total cost of the found flow.
3.122 + /// \brief Return the total cost of the found flow.
3.123 ///
3.124 - /// Returns the total cost of the found flow. The complexity of the
3.125 + /// Return the total cost of the found flow. The complexity of the
3.126 /// function is \f$ O(e) \f$.
3.127 ///
3.128 /// \pre \ref run() must be called before using this function.
3.129 @@ -390,7 +387,7 @@
3.130
3.131 private:
3.132
3.133 - /// Initializes the algorithm.
3.134 + /// Initialize the algorithm.
3.135 bool init() {
3.136 if (!_valid_supply) return false;
3.137
3.138 @@ -428,9 +425,9 @@
3.139 return true;
3.140 }
3.141
3.142 - /// \brief Executes the algorithm using \ref BellmanFord.
3.143 + /// \brief Execute the algorithm using \ref BellmanFord.
3.144 ///
3.145 - /// Executes the algorithm using the \ref BellmanFord
3.146 + /// Execute the algorithm using the \ref BellmanFord
3.147 /// "Bellman-Ford" algorithm for negative cycle detection with
3.148 /// successively larger limit for the number of iterations.
3.149 void start() {
3.150 @@ -506,9 +503,9 @@
3.151 }
3.152 }
3.153
3.154 - /// \brief Executes the algorithm using \ref MinMeanCycle.
3.155 + /// \brief Execute the algorithm using \ref MinMeanCycle.
3.156 ///
3.157 - /// Executes the algorithm using \ref MinMeanCycle for negative
3.158 + /// Execute the algorithm using \ref MinMeanCycle for negative
3.159 /// cycle detection.
3.160 void startMinMean() {
3.161 typedef Path<ResGraph> ResPath;
4.1 --- a/lemon/min_cost_flow.h Sun Oct 05 13:36:43 2008 +0000
4.2 +++ b/lemon/min_cost_flow.h Sun Oct 05 13:37:17 2008 +0000
4.3 @@ -62,7 +62,6 @@
4.4 /// - \c CostMap::Value must be signed type.
4.5 ///
4.6 /// \author Peter Kovacs
4.7 -
4.8 template < typename Graph,
4.9 typename LowerMap = typename Graph::template EdgeMap<int>,
4.10 typename CapacityMap = typename Graph::template EdgeMap<int>,
5.1 --- a/lemon/min_cost_max_flow.h Sun Oct 05 13:36:43 2008 +0000
5.2 +++ b/lemon/min_cost_max_flow.h Sun Oct 05 13:37:17 2008 +0000
5.3 @@ -58,7 +58,6 @@
5.4 /// - \c CostMap::Value must be signed type.
5.5 ///
5.6 /// \author Peter Kovacs
5.7 -
5.8 template < typename Graph,
5.9 typename CapacityMap = typename Graph::template EdgeMap<int>,
5.10 typename CostMap = typename Graph::template EdgeMap<int> >
5.11 @@ -127,9 +126,9 @@
5.12 if (_local_potential) delete _potential;
5.13 }
5.14
5.15 - /// \brief Sets the flow map.
5.16 + /// \brief Set the flow map.
5.17 ///
5.18 - /// Sets the flow map.
5.19 + /// Set the flow map.
5.20 ///
5.21 /// \return \c (*this)
5.22 MinCostMaxFlow& flowMap(FlowMap &map) {
5.23 @@ -141,9 +140,9 @@
5.24 return *this;
5.25 }
5.26
5.27 - /// \brief Sets the potential map.
5.28 + /// \brief Set the potential map.
5.29 ///
5.30 - /// Sets the potential map.
5.31 + /// Set the potential map.
5.32 ///
5.33 /// \return \c (*this)
5.34 MinCostMaxFlow& potentialMap(PotentialMap &map) {
5.35 @@ -156,14 +155,12 @@
5.36 }
5.37
5.38 /// \name Execution control
5.39 - /// The only way to execute the algorithm is to call the run()
5.40 - /// function.
5.41
5.42 /// @{
5.43
5.44 - /// \brief Runs the algorithm.
5.45 + /// \brief Run the algorithm.
5.46 ///
5.47 - /// Runs the algorithm.
5.48 + /// Run the algorithm.
5.49 void run() {
5.50 // Initializing maps
5.51 if (!_flow) {
5.52 @@ -186,26 +183,27 @@
5.53 /// @}
5.54
5.55 /// \name Query Functions
5.56 - /// The result of the algorithm can be obtained using these
5.57 - /// functions.
5.58 - /// \n run() must be called before using them.
5.59 + /// The results of the algorithm can be obtained using these
5.60 + /// functions.\n
5.61 + /// \ref lemon::MinCostMaxFlow::run() "run()" must be called before
5.62 + /// using them.
5.63
5.64 /// @{
5.65
5.66 - /// \brief Returns a const reference to the edge map storing the
5.67 + /// \brief Return a const reference to the edge map storing the
5.68 /// found flow.
5.69 ///
5.70 - /// Returns a const reference to the edge map storing the found flow.
5.71 + /// Return a const reference to the edge map storing the found flow.
5.72 ///
5.73 /// \pre \ref run() must be called before using this function.
5.74 const FlowMap& flowMap() const {
5.75 return *_flow;
5.76 }
5.77
5.78 - /// \brief Returns a const reference to the node map storing the
5.79 + /// \brief Return a const reference to the node map storing the
5.80 /// found potentials (the dual solution).
5.81 ///
5.82 - /// Returns a const reference to the node map storing the found
5.83 + /// Return a const reference to the node map storing the found
5.84 /// potentials (the dual solution).
5.85 ///
5.86 /// \pre \ref run() must be called before using this function.
5.87 @@ -213,27 +211,27 @@
5.88 return *_potential;
5.89 }
5.90
5.91 - /// \brief Returns the flow on the given edge.
5.92 + /// \brief Return the flow on the given edge.
5.93 ///
5.94 - /// Returns the flow on the given edge.
5.95 + /// Return the flow on the given edge.
5.96 ///
5.97 /// \pre \ref run() must be called before using this function.
5.98 Capacity flow(const Edge& edge) const {
5.99 return (*_flow)[edge];
5.100 }
5.101
5.102 - /// \brief Returns the potential of the given node.
5.103 + /// \brief Return the potential of the given node.
5.104 ///
5.105 - /// Returns the potential of the given node.
5.106 + /// Return the potential of the given node.
5.107 ///
5.108 /// \pre \ref run() must be called before using this function.
5.109 Cost potential(const Node& node) const {
5.110 return (*_potential)[node];
5.111 }
5.112
5.113 - /// \brief Returns the total cost of the found flow.
5.114 + /// \brief Return the total cost of the found flow.
5.115 ///
5.116 - /// Returns the total cost of the found flow. The complexity of the
5.117 + /// Return the total cost of the found flow. The complexity of the
5.118 /// function is \f$ O(e) \f$.
5.119 ///
5.120 /// \pre \ref run() must be called before using this function.
6.1 --- a/lemon/min_mean_cycle.h Sun Oct 05 13:36:43 2008 +0000
6.2 +++ b/lemon/min_mean_cycle.h Sun Oct 05 13:37:17 2008 +0000
6.3 @@ -232,7 +232,7 @@
6.4 }
6.5 return true;
6.6 }
6.7 -
6.8 +
6.9 /// @}
6.10
6.11 /// \name Query Functions
6.12 @@ -241,7 +241,7 @@
6.13 /// \n The algorithm should be executed before using them.
6.14
6.15 /// @{
6.16 -
6.17 +
6.18 /// \brief Returns the total length of the found cycle.
6.19 ///
6.20 /// Returns the total length of the found cycle.
6.21 @@ -291,9 +291,9 @@
6.22 const Path& cycle() const {
6.23 return *_cycle_path;
6.24 }
6.25 -
6.26 +
6.27 ///@}
6.28 -
6.29 +
6.30 private:
6.31
6.32 // Initializes the internal data structures for the current strongly