0
73
18
1 |
%%%%% Defining LEMON %%%%% |
|
2 |
|
|
3 |
@misc{lemon, |
|
4 |
key = {LEMON}, |
|
5 |
title = {{LEMON} -- {L}ibrary for {E}fficient {M}odeling and |
|
6 |
{O}ptimization in {N}etworks}, |
|
7 |
howpublished = {\url{http://lemon.cs.elte.hu/}}, |
|
8 |
year = 2009 |
|
9 |
} |
|
10 |
|
|
11 |
@misc{egres, |
|
12 |
key = {EGRES}, |
|
13 |
title = {{EGRES} -- {E}gerv{\'a}ry {R}esearch {G}roup on |
|
14 |
{C}ombinatorial {O}ptimization}, |
|
15 |
url = {http://www.cs.elte.hu/egres/} |
|
16 |
} |
|
17 |
|
|
18 |
@misc{coinor, |
|
19 |
key = {COIN-OR}, |
|
20 |
title = {{COIN-OR} -- {C}omputational {I}nfrastructure for |
|
21 |
{O}perations {R}esearch}, |
|
22 |
url = {http://www.coin-or.org/} |
|
23 |
} |
|
24 |
|
|
25 |
|
|
26 |
%%%%% Other libraries %%%%%% |
|
27 |
|
|
28 |
@misc{boost, |
|
29 |
key = {Boost}, |
|
30 |
title = {{B}oost {C++} {L}ibraries}, |
|
31 |
url = {http://www.boost.org/} |
|
32 |
} |
|
33 |
|
|
34 |
@book{bglbook, |
|
35 |
author = {Jeremy G. Siek and Lee-Quan Lee and Andrew |
|
36 |
Lumsdaine}, |
|
37 |
title = {The Boost Graph Library: User Guide and Reference |
|
38 |
Manual}, |
|
39 |
publisher = {Addison-Wesley}, |
|
40 |
year = 2002 |
|
41 |
} |
|
42 |
|
|
43 |
@misc{leda, |
|
44 |
key = {LEDA}, |
|
45 |
title = {{LEDA} -- {L}ibrary of {E}fficient {D}ata {T}ypes and |
|
46 |
{A}lgorithms}, |
|
47 |
url = {http://www.algorithmic-solutions.com/} |
|
48 |
} |
|
49 |
|
|
50 |
@book{ledabook, |
|
51 |
author = {Kurt Mehlhorn and Stefan N{\"a}her}, |
|
52 |
title = {{LEDA}: {A} platform for combinatorial and geometric |
|
53 |
computing}, |
|
54 |
isbn = {0-521-56329-1}, |
|
55 |
publisher = {Cambridge University Press}, |
|
56 |
address = {New York, NY, USA}, |
|
57 |
year = 1999 |
|
58 |
} |
|
59 |
|
|
60 |
|
|
61 |
%%%%% Tools that LEMON depends on %%%%% |
|
62 |
|
|
63 |
@misc{cmake, |
|
64 |
key = {CMake}, |
|
65 |
title = {{CMake} -- {C}ross {P}latform {M}ake}, |
|
66 |
url = {http://www.cmake.org/} |
|
67 |
} |
|
68 |
|
|
69 |
@misc{doxygen, |
|
70 |
key = {Doxygen}, |
|
71 |
title = {{Doxygen} -- {S}ource code documentation generator |
|
72 |
tool}, |
|
73 |
url = {http://www.doxygen.org/} |
|
74 |
} |
|
75 |
|
|
76 |
|
|
77 |
%%%%% LP/MIP libraries %%%%% |
|
78 |
|
|
79 |
@misc{glpk, |
|
80 |
key = {GLPK}, |
|
81 |
title = {{GLPK} -- {GNU} {L}inear {P}rogramming {K}it}, |
|
82 |
url = {http://www.gnu.org/software/glpk/} |
|
83 |
} |
|
84 |
|
|
85 |
@misc{clp, |
|
86 |
key = {Clp}, |
|
87 |
title = {{Clp} -- {Coin-Or} {L}inear {P}rogramming}, |
|
88 |
url = {http://projects.coin-or.org/Clp/} |
|
89 |
} |
|
90 |
|
|
91 |
@misc{cbc, |
|
92 |
key = {Cbc}, |
|
93 |
title = {{Cbc} -- {Coin-Or} {B}ranch and {C}ut}, |
|
94 |
url = {http://projects.coin-or.org/Cbc/} |
|
95 |
} |
|
96 |
|
|
97 |
@misc{cplex, |
|
98 |
key = {CPLEX}, |
|
99 |
title = {{ILOG} {CPLEX}}, |
|
100 |
url = {http://www.ilog.com/} |
|
101 |
} |
|
102 |
|
|
103 |
@misc{soplex, |
|
104 |
key = {SoPlex}, |
|
105 |
title = {{SoPlex} -- {T}he {S}equential {O}bject-{O}riented |
|
106 |
{S}implex}, |
|
107 |
url = {http://soplex.zib.de/} |
|
108 |
} |
|
109 |
|
|
110 |
|
|
111 |
%%%%% General books %%%%% |
|
112 |
|
|
113 |
@book{amo93networkflows, |
|
114 |
author = {Ravindra K. Ahuja and Thomas L. Magnanti and James |
|
115 |
B. Orlin}, |
|
116 |
title = {Network Flows: Theory, Algorithms, and Applications}, |
|
117 |
publisher = {Prentice-Hall, Inc.}, |
|
118 |
year = 1993, |
|
119 |
month = feb, |
|
120 |
isbn = {978-0136175490} |
|
121 |
} |
|
122 |
|
|
123 |
@book{schrijver03combinatorial, |
|
124 |
author = {Alexander Schrijver}, |
|
125 |
title = {Combinatorial Optimization: Polyhedra and Efficiency}, |
|
126 |
publisher = {Springer-Verlag}, |
|
127 |
year = 2003, |
|
128 |
isbn = {978-3540443896} |
|
129 |
} |
|
130 |
|
|
131 |
@book{clrs01algorithms, |
|
132 |
author = {Thomas H. Cormen and Charles E. Leiserson and Ronald |
|
133 |
L. Rivest and Clifford Stein}, |
|
134 |
title = {Introduction to Algorithms}, |
|
135 |
publisher = {The MIT Press}, |
|
136 |
year = 2001, |
|
137 |
edition = {2nd} |
|
138 |
} |
|
139 |
|
|
140 |
@book{stroustrup00cpp, |
|
141 |
author = {Bjarne Stroustrup}, |
|
142 |
title = {The C++ Programming Language}, |
|
143 |
edition = {3rd}, |
|
144 |
publisher = {Addison-Wesley Professional}, |
|
145 |
isbn = 0201700735, |
|
146 |
month = {February}, |
|
147 |
year = 2000 |
|
148 |
} |
|
149 |
|
|
150 |
|
|
151 |
%%%%% Maximum flow algorithms %%%%% |
|
152 |
|
|
153 |
@article{edmondskarp72theoretical, |
|
154 |
author = {Jack Edmonds and Richard M. Karp}, |
|
155 |
title = {Theoretical improvements in algorithmic efficiency |
|
156 |
for network flow problems}, |
|
157 |
journal = {Journal of the ACM}, |
|
158 |
year = 1972, |
|
159 |
volume = 19, |
|
160 |
number = 2, |
|
161 |
pages = {248-264} |
|
162 |
} |
|
163 |
|
|
164 |
@article{goldberg88newapproach, |
|
165 |
author = {Andrew V. Goldberg and Robert E. Tarjan}, |
|
166 |
title = {A new approach to the maximum flow problem}, |
|
167 |
journal = {Journal of the ACM}, |
|
168 |
year = 1988, |
|
169 |
volume = 35, |
|
170 |
number = 4, |
|
171 |
pages = {921-940} |
|
172 |
} |
|
173 |
|
|
174 |
@article{dinic70algorithm, |
|
175 |
author = {E. A. Dinic}, |
|
176 |
title = {Algorithm for solution of a problem of maximum flow |
|
177 |
in a network with power estimation}, |
|
178 |
journal = {Soviet Math. Doklady}, |
|
179 |
year = 1970, |
|
180 |
volume = 11, |
|
181 |
pages = {1277-1280} |
|
182 |
} |
|
183 |
|
|
184 |
@article{goldberg08partial, |
|
185 |
author = {Andrew V. Goldberg}, |
|
186 |
title = {The Partial Augment-Relabel Algorithm for the |
|
187 |
Maximum Flow Problem}, |
|
188 |
journal = {16th Annual European Symposium on Algorithms}, |
|
189 |
year = 2008, |
|
190 |
pages = {466-477} |
|
191 |
} |
|
192 |
|
|
193 |
@article{sleator83dynamic, |
|
194 |
author = {Daniel D. Sleator and Robert E. Tarjan}, |
|
195 |
title = {A data structure for dynamic trees}, |
|
196 |
journal = {Journal of Computer and System Sciences}, |
|
197 |
year = 1983, |
|
198 |
volume = 26, |
|
199 |
number = 3, |
|
200 |
pages = {362-391} |
|
201 |
} |
|
202 |
|
|
203 |
|
|
204 |
%%%%% Minimum mean cycle algorithms %%%%% |
|
205 |
|
|
206 |
@article{karp78characterization, |
|
207 |
author = {Richard M. Karp}, |
|
208 |
title = {A characterization of the minimum cycle mean in a |
|
209 |
digraph}, |
|
210 |
journal = {Discrete Math.}, |
|
211 |
year = 1978, |
|
212 |
volume = 23, |
|
213 |
pages = {309-311} |
|
214 |
} |
|
215 |
|
|
216 |
@article{dasdan98minmeancycle, |
|
217 |
author = {Ali Dasdan and Rajesh K. Gupta}, |
|
218 |
title = {Faster Maximum and Minimum Mean Cycle Alogrithms for |
|
219 |
System Performance Analysis}, |
|
220 |
journal = {IEEE Transactions on Computer-Aided Design of |
|
221 |
Integrated Circuits and Systems}, |
|
222 |
year = 1998, |
|
223 |
volume = 17, |
|
224 |
number = 10, |
|
225 |
pages = {889-899} |
|
226 |
} |
|
227 |
|
|
228 |
|
|
229 |
%%%%% Minimum cost flow algorithms %%%%% |
|
230 |
|
|
231 |
@article{klein67primal, |
|
232 |
author = {Morton Klein}, |
|
233 |
title = {A primal method for minimal cost flows with |
|
234 |
applications to the assignment and transportation |
|
235 |
problems}, |
|
236 |
journal = {Management Science}, |
|
237 |
year = 1967, |
|
238 |
volume = 14, |
|
239 |
pages = {205-220} |
|
240 |
} |
|
241 |
|
|
242 |
@article{goldberg89cyclecanceling, |
|
243 |
author = {Andrew V. Goldberg and Robert E. Tarjan}, |
|
244 |
title = {Finding minimum-cost circulations by canceling |
|
245 |
negative cycles}, |
|
246 |
journal = {Journal of the ACM}, |
|
247 |
year = 1989, |
|
248 |
volume = 36, |
|
249 |
number = 4, |
|
250 |
pages = {873-886} |
|
251 |
} |
|
252 |
|
|
253 |
@article{goldberg90approximation, |
|
254 |
author = {Andrew V. Goldberg and Robert E. Tarjan}, |
|
255 |
title = {Finding Minimum-Cost Circulations by Successive |
|
256 |
Approximation}, |
|
257 |
journal = {Mathematics of Operations Research}, |
|
258 |
year = 1990, |
|
259 |
volume = 15, |
|
260 |
number = 3, |
|
261 |
pages = {430-466} |
|
262 |
} |
|
263 |
|
|
264 |
@article{goldberg97efficient, |
|
265 |
author = {Andrew V. Goldberg}, |
|
266 |
title = {An Efficient Implementation of a Scaling |
|
267 |
Minimum-Cost Flow Algorithm}, |
|
268 |
journal = {Journal of Algorithms}, |
|
269 |
year = 1997, |
|
270 |
volume = 22, |
|
271 |
number = 1, |
|
272 |
pages = {1-29} |
|
273 |
} |
|
274 |
|
|
275 |
@article{bunnagel98efficient, |
|
276 |
author = {Ursula B{\"u}nnagel and Bernhard Korte and Jens |
|
277 |
Vygen}, |
|
278 |
title = {Efficient implementation of the {G}oldberg-{T}arjan |
|
279 |
minimum-cost flow algorithm}, |
|
280 |
journal = {Optimization Methods and Software}, |
|
281 |
year = 1998, |
|
282 |
volume = 10, |
|
283 |
pages = {157-174} |
|
284 |
} |
|
285 |
|
|
286 |
@book{dantzig63linearprog, |
|
287 |
author = {George B. Dantzig}, |
|
288 |
title = {Linear Programming and Extensions}, |
|
289 |
publisher = {Princeton University Press}, |
|
290 |
year = 1963 |
|
291 |
} |
|
292 |
|
|
293 |
@mastersthesis{kellyoneill91netsimplex, |
|
294 |
author = {Damian J. Kelly and Garrett M. O'Neill}, |
|
295 |
title = {The Minimum Cost Flow Problem and The Network |
|
296 |
Simplex Method}, |
|
297 |
school = {University College}, |
|
298 |
address = {Dublin, Ireland}, |
|
299 |
year = 1991, |
|
300 |
month = sep, |
|
301 |
} |
1 |
/* -*- C++ -*- |
|
2 |
* |
|
3 |
* This file is a part of LEMON, a generic C++ optimization library |
|
4 |
* |
|
5 |
* Copyright (C) 2003-2008 |
|
6 |
* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport |
|
7 |
* (Egervary Research Group on Combinatorial Optimization, EGRES). |
|
8 |
* |
|
9 |
* Permission to use, modify and distribute this software is granted |
|
10 |
* provided that this copyright notice appears in all copies. For |
|
11 |
* precise terms see the accompanying LICENSE file. |
|
12 |
* |
|
13 |
* This software is provided "AS IS" with no warranty of any kind, |
|
14 |
* express or implied, and with no claim as to its suitability for any |
|
15 |
* purpose. |
|
16 |
* |
|
17 |
*/ |
|
18 |
|
|
19 |
#ifndef LEMON_BELLMAN_FORD_H |
|
20 |
#define LEMON_BELLMAN_FORD_H |
|
21 |
|
|
22 |
/// \ingroup shortest_path |
|
23 |
/// \file |
|
24 |
/// \brief Bellman-Ford algorithm. |
|
25 |
|
|
26 |
#include <lemon/list_graph.h> |
|
27 |
#include <lemon/bits/path_dump.h> |
|
28 |
#include <lemon/core.h> |
|
29 |
#include <lemon/error.h> |
|
30 |
#include <lemon/maps.h> |
|
31 |
#include <lemon/path.h> |
|
32 |
|
|
33 |
#include <limits> |
|
34 |
|
|
35 |
namespace lemon { |
|
36 |
|
|
37 |
/// \brief Default OperationTraits for the BellmanFord algorithm class. |
|
38 |
/// |
|
39 |
/// This operation traits class defines all computational operations |
|
40 |
/// and constants that are used in the Bellman-Ford algorithm. |
|
41 |
/// The default implementation is based on the \c numeric_limits class. |
|
42 |
/// If the numeric type does not have infinity value, then the maximum |
|
43 |
/// value is used as extremal infinity value. |
|
44 |
template < |
|
45 |
typename V, |
|
46 |
bool has_inf = std::numeric_limits<V>::has_infinity> |
|
47 |
struct BellmanFordDefaultOperationTraits { |
|
48 |
/// \e |
|
49 |
typedef V Value; |
|
50 |
/// \brief Gives back the zero value of the type. |
|
51 |
static Value zero() { |
|
52 |
return static_cast<Value>(0); |
|
53 |
} |
|
54 |
/// \brief Gives back the positive infinity value of the type. |
|
55 |
static Value infinity() { |
|
56 |
return std::numeric_limits<Value>::infinity(); |
|
57 |
} |
|
58 |
/// \brief Gives back the sum of the given two elements. |
|
59 |
static Value plus(const Value& left, const Value& right) { |
|
60 |
return left + right; |
|
61 |
} |
|
62 |
/// \brief Gives back \c true only if the first value is less than |
|
63 |
/// the second. |
|
64 |
static bool less(const Value& left, const Value& right) { |
|
65 |
return left < right; |
|
66 |
} |
|
67 |
}; |
|
68 |
|
|
69 |
template <typename V> |
|
70 |
struct BellmanFordDefaultOperationTraits<V, false> { |
|
71 |
typedef V Value; |
|
72 |
static Value zero() { |
|
73 |
return static_cast<Value>(0); |
|
74 |
} |
|
75 |
static Value infinity() { |
|
76 |
return std::numeric_limits<Value>::max(); |
|
77 |
} |
|
78 |
static Value plus(const Value& left, const Value& right) { |
|
79 |
if (left == infinity() || right == infinity()) return infinity(); |
|
80 |
return left + right; |
|
81 |
} |
|
82 |
static bool less(const Value& left, const Value& right) { |
|
83 |
return left < right; |
|
84 |
} |
|
85 |
}; |
|
86 |
|
|
87 |
/// \brief Default traits class of BellmanFord class. |
|
88 |
/// |
|
89 |
/// Default traits class of BellmanFord class. |
|
90 |
/// \param GR The type of the digraph. |
|
91 |
/// \param LEN The type of the length map. |
|
92 |
template<typename GR, typename LEN> |
|
93 |
struct BellmanFordDefaultTraits { |
|
94 |
/// The type of the digraph the algorithm runs on. |
|
95 |
typedef GR Digraph; |
|
96 |
|
|
97 |
/// \brief The type of the map that stores the arc lengths. |
|
98 |
/// |
|
99 |
/// The type of the map that stores the arc lengths. |
|
100 |
/// It must conform to the \ref concepts::ReadMap "ReadMap" concept. |
|
101 |
typedef LEN LengthMap; |
|
102 |
|
|
103 |
/// The type of the arc lengths. |
|
104 |
typedef typename LEN::Value Value; |
|
105 |
|
|
106 |
/// \brief Operation traits for Bellman-Ford algorithm. |
|
107 |
/// |
|
108 |
/// It defines the used operations and the infinity value for the |
|
109 |
/// given \c Value type. |
|
110 |
/// \see BellmanFordDefaultOperationTraits |
|
111 |
typedef BellmanFordDefaultOperationTraits<Value> OperationTraits; |
|
112 |
|
|
113 |
/// \brief The type of the map that stores the last arcs of the |
|
114 |
/// shortest paths. |
|
115 |
/// |
|
116 |
/// The type of the map that stores the last |
|
117 |
/// arcs of the shortest paths. |
|
118 |
/// It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
119 |
typedef typename GR::template NodeMap<typename GR::Arc> PredMap; |
|
120 |
|
|
121 |
/// \brief Instantiates a \c PredMap. |
|
122 |
/// |
|
123 |
/// This function instantiates a \ref PredMap. |
|
124 |
/// \param g is the digraph to which we would like to define the |
|
125 |
/// \ref PredMap. |
|
126 |
static PredMap *createPredMap(const GR& g) { |
|
127 |
return new PredMap(g); |
|
128 |
} |
|
129 |
|
|
130 |
/// \brief The type of the map that stores the distances of the nodes. |
|
131 |
/// |
|
132 |
/// The type of the map that stores the distances of the nodes. |
|
133 |
/// It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
134 |
typedef typename GR::template NodeMap<typename LEN::Value> DistMap; |
|
135 |
|
|
136 |
/// \brief Instantiates a \c DistMap. |
|
137 |
/// |
|
138 |
/// This function instantiates a \ref DistMap. |
|
139 |
/// \param g is the digraph to which we would like to define the |
|
140 |
/// \ref DistMap. |
|
141 |
static DistMap *createDistMap(const GR& g) { |
|
142 |
return new DistMap(g); |
|
143 |
} |
|
144 |
|
|
145 |
}; |
|
146 |
|
|
147 |
/// \brief %BellmanFord algorithm class. |
|
148 |
/// |
|
149 |
/// \ingroup shortest_path |
|
150 |
/// This class provides an efficient implementation of the Bellman-Ford |
|
151 |
/// algorithm. The maximum time complexity of the algorithm is |
|
152 |
/// <tt>O(ne)</tt>. |
|
153 |
/// |
|
154 |
/// The Bellman-Ford algorithm solves the single-source shortest path |
|
155 |
/// problem when the arcs can have negative lengths, but the digraph |
|
156 |
/// should not contain directed cycles with negative total length. |
|
157 |
/// If all arc costs are non-negative, consider to use the Dijkstra |
|
158 |
/// algorithm instead, since it is more efficient. |
|
159 |
/// |
|
160 |
/// The arc lengths are passed to the algorithm using a |
|
161 |
/// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any |
|
162 |
/// kind of length. The type of the length values is determined by the |
|
163 |
/// \ref concepts::ReadMap::Value "Value" type of the length map. |
|
164 |
/// |
|
165 |
/// There is also a \ref bellmanFord() "function-type interface" for the |
|
166 |
/// Bellman-Ford algorithm, which is convenient in the simplier cases and |
|
167 |
/// it can be used easier. |
|
168 |
/// |
|
169 |
/// \tparam GR The type of the digraph the algorithm runs on. |
|
170 |
/// The default type is \ref ListDigraph. |
|
171 |
/// \tparam LEN A \ref concepts::ReadMap "readable" arc map that specifies |
|
172 |
/// the lengths of the arcs. The default map type is |
|
173 |
/// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>". |
|
174 |
#ifdef DOXYGEN |
|
175 |
template <typename GR, typename LEN, typename TR> |
|
176 |
#else |
|
177 |
template <typename GR=ListDigraph, |
|
178 |
typename LEN=typename GR::template ArcMap<int>, |
|
179 |
typename TR=BellmanFordDefaultTraits<GR,LEN> > |
|
180 |
#endif |
|
181 |
class BellmanFord { |
|
182 |
public: |
|
183 |
|
|
184 |
///The type of the underlying digraph. |
|
185 |
typedef typename TR::Digraph Digraph; |
|
186 |
|
|
187 |
/// \brief The type of the arc lengths. |
|
188 |
typedef typename TR::LengthMap::Value Value; |
|
189 |
/// \brief The type of the map that stores the arc lengths. |
|
190 |
typedef typename TR::LengthMap LengthMap; |
|
191 |
/// \brief The type of the map that stores the last |
|
192 |
/// arcs of the shortest paths. |
|
193 |
typedef typename TR::PredMap PredMap; |
|
194 |
/// \brief The type of the map that stores the distances of the nodes. |
|
195 |
typedef typename TR::DistMap DistMap; |
|
196 |
/// The type of the paths. |
|
197 |
typedef PredMapPath<Digraph, PredMap> Path; |
|
198 |
///\brief The \ref BellmanFordDefaultOperationTraits |
|
199 |
/// "operation traits class" of the algorithm. |
|
200 |
typedef typename TR::OperationTraits OperationTraits; |
|
201 |
|
|
202 |
///The \ref BellmanFordDefaultTraits "traits class" of the algorithm. |
|
203 |
typedef TR Traits; |
|
204 |
|
|
205 |
private: |
|
206 |
|
|
207 |
typedef typename Digraph::Node Node; |
|
208 |
typedef typename Digraph::NodeIt NodeIt; |
|
209 |
typedef typename Digraph::Arc Arc; |
|
210 |
typedef typename Digraph::OutArcIt OutArcIt; |
|
211 |
|
|
212 |
// Pointer to the underlying digraph. |
|
213 |
const Digraph *_gr; |
|
214 |
// Pointer to the length map |
|
215 |
const LengthMap *_length; |
|
216 |
// Pointer to the map of predecessors arcs. |
|
217 |
PredMap *_pred; |
|
218 |
// Indicates if _pred is locally allocated (true) or not. |
|
219 |
bool _local_pred; |
|
220 |
// Pointer to the map of distances. |
|
221 |
DistMap *_dist; |
|
222 |
// Indicates if _dist is locally allocated (true) or not. |
|
223 |
bool _local_dist; |
|
224 |
|
|
225 |
typedef typename Digraph::template NodeMap<bool> MaskMap; |
|
226 |
MaskMap *_mask; |
|
227 |
|
|
228 |
std::vector<Node> _process; |
|
229 |
|
|
230 |
// Creates the maps if necessary. |
|
231 |
void create_maps() { |
|
232 |
if(!_pred) { |
|
233 |
_local_pred = true; |
|
234 |
_pred = Traits::createPredMap(*_gr); |
|
235 |
} |
|
236 |
if(!_dist) { |
|
237 |
_local_dist = true; |
|
238 |
_dist = Traits::createDistMap(*_gr); |
|
239 |
} |
|
240 |
_mask = new MaskMap(*_gr, false); |
|
241 |
} |
|
242 |
|
|
243 |
public : |
|
244 |
|
|
245 |
typedef BellmanFord Create; |
|
246 |
|
|
247 |
/// \name Named Template Parameters |
|
248 |
|
|
249 |
///@{ |
|
250 |
|
|
251 |
template <class T> |
|
252 |
struct SetPredMapTraits : public Traits { |
|
253 |
typedef T PredMap; |
|
254 |
static PredMap *createPredMap(const Digraph&) { |
|
255 |
LEMON_ASSERT(false, "PredMap is not initialized"); |
|
256 |
return 0; // ignore warnings |
|
257 |
} |
|
258 |
}; |
|
259 |
|
|
260 |
/// \brief \ref named-templ-param "Named parameter" for setting |
|
261 |
/// \c PredMap type. |
|
262 |
/// |
|
263 |
/// \ref named-templ-param "Named parameter" for setting |
|
264 |
/// \c PredMap type. |
|
265 |
/// It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
266 |
template <class T> |
|
267 |
struct SetPredMap |
|
268 |
: public BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > { |
|
269 |
typedef BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > Create; |
|
270 |
}; |
|
271 |
|
|
272 |
template <class T> |
|
273 |
struct SetDistMapTraits : public Traits { |
|
274 |
typedef T DistMap; |
|
275 |
static DistMap *createDistMap(const Digraph&) { |
|
276 |
LEMON_ASSERT(false, "DistMap is not initialized"); |
|
277 |
return 0; // ignore warnings |
|
278 |
} |
|
279 |
}; |
|
280 |
|
|
281 |
/// \brief \ref named-templ-param "Named parameter" for setting |
|
282 |
/// \c DistMap type. |
|
283 |
/// |
|
284 |
/// \ref named-templ-param "Named parameter" for setting |
|
285 |
/// \c DistMap type. |
|
286 |
/// It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
287 |
template <class T> |
|
288 |
struct SetDistMap |
|
289 |
: public BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > { |
|
290 |
typedef BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > Create; |
|
291 |
}; |
|
292 |
|
|
293 |
template <class T> |
|
294 |
struct SetOperationTraitsTraits : public Traits { |
|
295 |
typedef T OperationTraits; |
|
296 |
}; |
|
297 |
|
|
298 |
/// \brief \ref named-templ-param "Named parameter" for setting |
|
299 |
/// \c OperationTraits type. |
|
300 |
/// |
|
301 |
/// \ref named-templ-param "Named parameter" for setting |
|
302 |
/// \c OperationTraits type. |
|
303 |
/// For more information, see \ref BellmanFordDefaultOperationTraits. |
|
304 |
template <class T> |
|
305 |
struct SetOperationTraits |
|
306 |
: public BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> > { |
|
307 |
typedef BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> > |
|
308 |
Create; |
|
309 |
}; |
|
310 |
|
|
311 |
///@} |
|
312 |
|
|
313 |
protected: |
|
314 |
|
|
315 |
BellmanFord() {} |
|
316 |
|
|
317 |
public: |
|
318 |
|
|
319 |
/// \brief Constructor. |
|
320 |
/// |
|
321 |
/// Constructor. |
|
322 |
/// \param g The digraph the algorithm runs on. |
|
323 |
/// \param length The length map used by the algorithm. |
|
324 |
BellmanFord(const Digraph& g, const LengthMap& length) : |
|
325 |
_gr(&g), _length(&length), |
|
326 |
_pred(0), _local_pred(false), |
|
327 |
_dist(0), _local_dist(false), _mask(0) {} |
|
328 |
|
|
329 |
///Destructor. |
|
330 |
~BellmanFord() { |
|
331 |
if(_local_pred) delete _pred; |
|
332 |
if(_local_dist) delete _dist; |
|
333 |
if(_mask) delete _mask; |
|
334 |
} |
|
335 |
|
|
336 |
/// \brief Sets the length map. |
|
337 |
/// |
|
338 |
/// Sets the length map. |
|
339 |
/// \return <tt>(*this)</tt> |
|
340 |
BellmanFord &lengthMap(const LengthMap &map) { |
|
341 |
_length = ↦ |
|
342 |
return *this; |
|
343 |
} |
|
344 |
|
|
345 |
/// \brief Sets the map that stores the predecessor arcs. |
|
346 |
/// |
|
347 |
/// Sets the map that stores the predecessor arcs. |
|
348 |
/// If you don't use this function before calling \ref run() |
|
349 |
/// or \ref init(), an instance will be allocated automatically. |
|
350 |
/// The destructor deallocates this automatically allocated map, |
|
351 |
/// of course. |
|
352 |
/// \return <tt>(*this)</tt> |
|
353 |
BellmanFord &predMap(PredMap &map) { |
|
354 |
if(_local_pred) { |
|
355 |
delete _pred; |
|
356 |
_local_pred=false; |
|
357 |
} |
|
358 |
_pred = ↦ |
|
359 |
return *this; |
|
360 |
} |
|
361 |
|
|
362 |
/// \brief Sets the map that stores the distances of the nodes. |
|
363 |
/// |
|
364 |
/// Sets the map that stores the distances of the nodes calculated |
|
365 |
/// by the algorithm. |
|
366 |
/// If you don't use this function before calling \ref run() |
|
367 |
/// or \ref init(), an instance will be allocated automatically. |
|
368 |
/// The destructor deallocates this automatically allocated map, |
|
369 |
/// of course. |
|
370 |
/// \return <tt>(*this)</tt> |
|
371 |
BellmanFord &distMap(DistMap &map) { |
|
372 |
if(_local_dist) { |
|
373 |
delete _dist; |
|
374 |
_local_dist=false; |
|
375 |
} |
|
376 |
_dist = ↦ |
|
377 |
return *this; |
|
378 |
} |
|
379 |
|
|
380 |
/// \name Execution Control |
|
381 |
/// The simplest way to execute the Bellman-Ford algorithm is to use |
|
382 |
/// one of the member functions called \ref run().\n |
|
383 |
/// If you need better control on the execution, you have to call |
|
384 |
/// \ref init() first, then you can add several source nodes |
|
385 |
/// with \ref addSource(). Finally the actual path computation can be |
|
386 |
/// performed with \ref start(), \ref checkedStart() or |
|
387 |
/// \ref limitedStart(). |
|
388 |
|
|
389 |
///@{ |
|
390 |
|
|
391 |
/// \brief Initializes the internal data structures. |
|
392 |
/// |
|
393 |
/// Initializes the internal data structures. The optional parameter |
|
394 |
/// is the initial distance of each node. |
|
395 |
void init(const Value value = OperationTraits::infinity()) { |
|
396 |
create_maps(); |
|
397 |
for (NodeIt it(*_gr); it != INVALID; ++it) { |
|
398 |
_pred->set(it, INVALID); |
|
399 |
_dist->set(it, value); |
|
400 |
} |
|
401 |
_process.clear(); |
|
402 |
if (OperationTraits::less(value, OperationTraits::infinity())) { |
|
403 |
for (NodeIt it(*_gr); it != INVALID; ++it) { |
|
404 |
_process.push_back(it); |
|
405 |
_mask->set(it, true); |
|
406 |
} |
|
407 |
} |
|
408 |
} |
|
409 |
|
|
410 |
/// \brief Adds a new source node. |
|
411 |
/// |
|
412 |
/// This function adds a new source node. The optional second parameter |
|
413 |
/// is the initial distance of the node. |
|
414 |
void addSource(Node source, Value dst = OperationTraits::zero()) { |
|
415 |
_dist->set(source, dst); |
|
416 |
if (!(*_mask)[source]) { |
|
417 |
_process.push_back(source); |
|
418 |
_mask->set(source, true); |
|
419 |
} |
|
420 |
} |
|
421 |
|
|
422 |
/// \brief Executes one round from the Bellman-Ford algorithm. |
|
423 |
/// |
|
424 |
/// If the algoritm calculated the distances in the previous round |
|
425 |
/// exactly for the paths of at most \c k arcs, then this function |
|
426 |
/// will calculate the distances exactly for the paths of at most |
|
427 |
/// <tt>k+1</tt> arcs. Performing \c k iterations using this function |
|
428 |
/// calculates the shortest path distances exactly for the paths |
|
429 |
/// consisting of at most \c k arcs. |
|
430 |
/// |
|
431 |
/// \warning The paths with limited arc number cannot be retrieved |
|
432 |
/// easily with \ref path() or \ref predArc() functions. If you also |
|
433 |
/// need the shortest paths and not only the distances, you should |
|
434 |
/// store the \ref predMap() "predecessor map" after each iteration |
|
435 |
/// and build the path manually. |
|
436 |
/// |
|
437 |
/// \return \c true when the algorithm have not found more shorter |
|
438 |
/// paths. |
|
439 |
/// |
|
440 |
/// \see ActiveIt |
|
441 |
bool processNextRound() { |
|
442 |
for (int i = 0; i < int(_process.size()); ++i) { |
|
443 |
_mask->set(_process[i], false); |
|
444 |
} |
|
445 |
std::vector<Node> nextProcess; |
|
446 |
std::vector<Value> values(_process.size()); |
|
447 |
for (int i = 0; i < int(_process.size()); ++i) { |
|
448 |
values[i] = (*_dist)[_process[i]]; |
|
449 |
} |
|
450 |
for (int i = 0; i < int(_process.size()); ++i) { |
|
451 |
for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) { |
|
452 |
Node target = _gr->target(it); |
|
453 |
Value relaxed = OperationTraits::plus(values[i], (*_length)[it]); |
|
454 |
if (OperationTraits::less(relaxed, (*_dist)[target])) { |
|
455 |
_pred->set(target, it); |
|
456 |
_dist->set(target, relaxed); |
|
457 |
if (!(*_mask)[target]) { |
|
458 |
_mask->set(target, true); |
|
459 |
nextProcess.push_back(target); |
|
460 |
} |
|
461 |
} |
|
462 |
} |
|
463 |
} |
|
464 |
_process.swap(nextProcess); |
|
465 |
return _process.empty(); |
|
466 |
} |
|
467 |
|
|
468 |
/// \brief Executes one weak round from the Bellman-Ford algorithm. |
|
469 |
/// |
|
470 |
/// If the algorithm calculated the distances in the previous round |
|
471 |
/// at least for the paths of at most \c k arcs, then this function |
|
472 |
/// will calculate the distances at least for the paths of at most |
|
473 |
/// <tt>k+1</tt> arcs. |
|
474 |
/// This function does not make it possible to calculate the shortest |
|
475 |
/// path distances exactly for paths consisting of at most \c k arcs, |
|
476 |
/// this is why it is called weak round. |
|
477 |
/// |
|
478 |
/// \return \c true when the algorithm have not found more shorter |
|
479 |
/// paths. |
|
480 |
/// |
|
481 |
/// \see ActiveIt |
|
482 |
bool processNextWeakRound() { |
|
483 |
for (int i = 0; i < int(_process.size()); ++i) { |
|
484 |
_mask->set(_process[i], false); |
|
485 |
} |
|
486 |
std::vector<Node> nextProcess; |
|
487 |
for (int i = 0; i < int(_process.size()); ++i) { |
|
488 |
for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) { |
|
489 |
Node target = _gr->target(it); |
|
490 |
Value relaxed = |
|
491 |
OperationTraits::plus((*_dist)[_process[i]], (*_length)[it]); |
|
492 |
if (OperationTraits::less(relaxed, (*_dist)[target])) { |
|
493 |
_pred->set(target, it); |
|
494 |
_dist->set(target, relaxed); |
|
495 |
if (!(*_mask)[target]) { |
|
496 |
_mask->set(target, true); |
|
497 |
nextProcess.push_back(target); |
|
498 |
} |
|
499 |
} |
|
500 |
} |
|
501 |
} |
|
502 |
_process.swap(nextProcess); |
|
503 |
return _process.empty(); |
|
504 |
} |
|
505 |
|
|
506 |
/// \brief Executes the algorithm. |
|
507 |
/// |
|
508 |
/// Executes the algorithm. |
|
509 |
/// |
|
510 |
/// This method runs the Bellman-Ford algorithm from the root node(s) |
|
511 |
/// in order to compute the shortest path to each node. |
|
512 |
/// |
|
513 |
/// The algorithm computes |
|
514 |
/// - the shortest path tree (forest), |
|
515 |
/// - the distance of each node from the root(s). |
|
516 |
/// |
|
517 |
/// \pre init() must be called and at least one root node should be |
|
518 |
/// added with addSource() before using this function. |
|
519 |
void start() { |
|
520 |
int num = countNodes(*_gr) - 1; |
|
521 |
for (int i = 0; i < num; ++i) { |
|
522 |
if (processNextWeakRound()) break; |
|
523 |
} |
|
524 |
} |
|
525 |
|
|
526 |
/// \brief Executes the algorithm and checks the negative cycles. |
|
527 |
/// |
|
528 |
/// Executes the algorithm and checks the negative cycles. |
|
529 |
/// |
|
530 |
/// This method runs the Bellman-Ford algorithm from the root node(s) |
|
531 |
/// in order to compute the shortest path to each node and also checks |
|
532 |
/// if the digraph contains cycles with negative total length. |
|
533 |
/// |
|
534 |
/// The algorithm computes |
|
535 |
/// - the shortest path tree (forest), |
|
536 |
/// - the distance of each node from the root(s). |
|
537 |
/// |
|
538 |
/// \return \c false if there is a negative cycle in the digraph. |
|
539 |
/// |
|
540 |
/// \pre init() must be called and at least one root node should be |
|
541 |
/// added with addSource() before using this function. |
|
542 |
bool checkedStart() { |
|
543 |
int num = countNodes(*_gr); |
|
544 |
for (int i = 0; i < num; ++i) { |
|
545 |
if (processNextWeakRound()) return true; |
|
546 |
} |
|
547 |
return _process.empty(); |
|
548 |
} |
|
549 |
|
|
550 |
/// \brief Executes the algorithm with arc number limit. |
|
551 |
/// |
|
552 |
/// Executes the algorithm with arc number limit. |
|
553 |
/// |
|
554 |
/// This method runs the Bellman-Ford algorithm from the root node(s) |
|
555 |
/// in order to compute the shortest path distance for each node |
|
556 |
/// using only the paths consisting of at most \c num arcs. |
|
557 |
/// |
|
558 |
/// The algorithm computes |
|
559 |
/// - the limited distance of each node from the root(s), |
|
560 |
/// - the predecessor arc for each node. |
|
561 |
/// |
|
562 |
/// \warning The paths with limited arc number cannot be retrieved |
|
563 |
/// easily with \ref path() or \ref predArc() functions. If you also |
|
564 |
/// need the shortest paths and not only the distances, you should |
|
565 |
/// store the \ref predMap() "predecessor map" after each iteration |
|
566 |
/// and build the path manually. |
|
567 |
/// |
|
568 |
/// \pre init() must be called and at least one root node should be |
|
569 |
/// added with addSource() before using this function. |
|
570 |
void limitedStart(int num) { |
|
571 |
for (int i = 0; i < num; ++i) { |
|
572 |
if (processNextRound()) break; |
|
573 |
} |
|
574 |
} |
|
575 |
|
|
576 |
/// \brief Runs the algorithm from the given root node. |
|
577 |
/// |
|
578 |
/// This method runs the Bellman-Ford algorithm from the given root |
|
579 |
/// node \c s in order to compute the shortest path to each node. |
|
580 |
/// |
|
581 |
/// The algorithm computes |
|
582 |
/// - the shortest path tree (forest), |
|
583 |
/// - the distance of each node from the root(s). |
|
584 |
/// |
|
585 |
/// \note bf.run(s) is just a shortcut of the following code. |
|
586 |
/// \code |
|
587 |
/// bf.init(); |
|
588 |
/// bf.addSource(s); |
|
589 |
/// bf.start(); |
|
590 |
/// \endcode |
|
591 |
void run(Node s) { |
|
592 |
init(); |
|
593 |
addSource(s); |
|
594 |
start(); |
|
595 |
} |
|
596 |
|
|
597 |
/// \brief Runs the algorithm from the given root node with arc |
|
598 |
/// number limit. |
|
599 |
/// |
|
600 |
/// This method runs the Bellman-Ford algorithm from the given root |
|
601 |
/// node \c s in order to compute the shortest path distance for each |
|
602 |
/// node using only the paths consisting of at most \c num arcs. |
|
603 |
/// |
|
604 |
/// The algorithm computes |
|
605 |
/// - the limited distance of each node from the root(s), |
|
606 |
/// - the predecessor arc for each node. |
|
607 |
/// |
|
608 |
/// \warning The paths with limited arc number cannot be retrieved |
|
609 |
/// easily with \ref path() or \ref predArc() functions. If you also |
|
610 |
/// need the shortest paths and not only the distances, you should |
|
611 |
/// store the \ref predMap() "predecessor map" after each iteration |
|
612 |
/// and build the path manually. |
|
613 |
/// |
|
614 |
/// \note bf.run(s, num) is just a shortcut of the following code. |
|
615 |
/// \code |
|
616 |
/// bf.init(); |
|
617 |
/// bf.addSource(s); |
|
618 |
/// bf.limitedStart(num); |
|
619 |
/// \endcode |
|
620 |
void run(Node s, int num) { |
|
621 |
init(); |
|
622 |
addSource(s); |
|
623 |
limitedStart(num); |
|
624 |
} |
|
625 |
|
|
626 |
///@} |
|
627 |
|
|
628 |
/// \brief LEMON iterator for getting the active nodes. |
|
629 |
/// |
|
630 |
/// This class provides a common style LEMON iterator that traverses |
|
631 |
/// the active nodes of the Bellman-Ford algorithm after the last |
|
632 |
/// phase. These nodes should be checked in the next phase to |
|
633 |
/// find augmenting arcs outgoing from them. |
|
634 |
class ActiveIt { |
|
635 |
public: |
|
636 |
|
|
637 |
/// \brief Constructor. |
|
638 |
/// |
|
639 |
/// Constructor for getting the active nodes of the given BellmanFord |
|
640 |
/// instance. |
|
641 |
ActiveIt(const BellmanFord& algorithm) : _algorithm(&algorithm) |
|
642 |
{ |
|
643 |
_index = _algorithm->_process.size() - 1; |
|
644 |
} |
|
645 |
|
|
646 |
/// \brief Invalid constructor. |
|
647 |
/// |
|
648 |
/// Invalid constructor. |
|
649 |
ActiveIt(Invalid) : _algorithm(0), _index(-1) {} |
|
650 |
|
|
651 |
/// \brief Conversion to \c Node. |
|
652 |
/// |
|
653 |
/// Conversion to \c Node. |
|
654 |
operator Node() const { |
|
655 |
return _index >= 0 ? _algorithm->_process[_index] : INVALID; |
|
656 |
} |
|
657 |
|
|
658 |
/// \brief Increment operator. |
|
659 |
/// |
|
660 |
/// Increment operator. |
|
661 |
ActiveIt& operator++() { |
|
662 |
--_index; |
|
663 |
return *this; |
|
664 |
} |
|
665 |
|
|
666 |
bool operator==(const ActiveIt& it) const { |
|
667 |
return static_cast<Node>(*this) == static_cast<Node>(it); |
|
668 |
} |
|
669 |
bool operator!=(const ActiveIt& it) const { |
|
670 |
return static_cast<Node>(*this) != static_cast<Node>(it); |
|
671 |
} |
|
672 |
bool operator<(const ActiveIt& it) const { |
|
673 |
return static_cast<Node>(*this) < static_cast<Node>(it); |
|
674 |
} |
|
675 |
|
|
676 |
private: |
|
677 |
const BellmanFord* _algorithm; |
|
678 |
int _index; |
|
679 |
}; |
|
680 |
|
|
681 |
/// \name Query Functions |
|
682 |
/// The result of the Bellman-Ford algorithm can be obtained using these |
|
683 |
/// functions.\n |
|
684 |
/// Either \ref run() or \ref init() should be called before using them. |
|
685 |
|
|
686 |
///@{ |
|
687 |
|
|
688 |
/// \brief The shortest path to the given node. |
|
689 |
/// |
|
690 |
/// Gives back the shortest path to the given node from the root(s). |
|
691 |
/// |
|
692 |
/// \warning \c t should be reached from the root(s). |
|
693 |
/// |
|
694 |
/// \pre Either \ref run() or \ref init() must be called before |
|
695 |
/// using this function. |
|
696 |
Path path(Node t) const |
|
697 |
{ |
|
698 |
return Path(*_gr, *_pred, t); |
|
699 |
} |
|
700 |
|
|
701 |
/// \brief The distance of the given node from the root(s). |
|
702 |
/// |
|
703 |
/// Returns the distance of the given node from the root(s). |
|
704 |
/// |
|
705 |
/// \warning If node \c v is not reached from the root(s), then |
|
706 |
/// the return value of this function is undefined. |
|
707 |
/// |
|
708 |
/// \pre Either \ref run() or \ref init() must be called before |
|
709 |
/// using this function. |
|
710 |
Value dist(Node v) const { return (*_dist)[v]; } |
|
711 |
|
|
712 |
/// \brief Returns the 'previous arc' of the shortest path tree for |
|
713 |
/// the given node. |
|
714 |
/// |
|
715 |
/// This function returns the 'previous arc' of the shortest path |
|
716 |
/// tree for node \c v, i.e. it returns the last arc of a |
|
717 |
/// shortest path from a root to \c v. It is \c INVALID if \c v |
|
718 |
/// is not reached from the root(s) or if \c v is a root. |
|
719 |
/// |
|
720 |
/// The shortest path tree used here is equal to the shortest path |
|
721 |
/// tree used in \ref predNode() and \ref predMap(). |
|
722 |
/// |
|
723 |
/// \pre Either \ref run() or \ref init() must be called before |
|
724 |
/// using this function. |
|
725 |
Arc predArc(Node v) const { return (*_pred)[v]; } |
|
726 |
|
|
727 |
/// \brief Returns the 'previous node' of the shortest path tree for |
|
728 |
/// the given node. |
|
729 |
/// |
|
730 |
/// This function returns the 'previous node' of the shortest path |
|
731 |
/// tree for node \c v, i.e. it returns the last but one node of |
|
732 |
/// a shortest path from a root to \c v. It is \c INVALID if \c v |
|
733 |
/// is not reached from the root(s) or if \c v is a root. |
|
734 |
/// |
|
735 |
/// The shortest path tree used here is equal to the shortest path |
|
736 |
/// tree used in \ref predArc() and \ref predMap(). |
|
737 |
/// |
|
738 |
/// \pre Either \ref run() or \ref init() must be called before |
|
739 |
/// using this function. |
|
740 |
Node predNode(Node v) const { |
|
741 |
return (*_pred)[v] == INVALID ? INVALID : _gr->source((*_pred)[v]); |
|
742 |
} |
|
743 |
|
|
744 |
/// \brief Returns a const reference to the node map that stores the |
|
745 |
/// distances of the nodes. |
|
746 |
/// |
|
747 |
/// Returns a const reference to the node map that stores the distances |
|
748 |
/// of the nodes calculated by the algorithm. |
|
749 |
/// |
|
750 |
/// \pre Either \ref run() or \ref init() must be called before |
|
751 |
/// using this function. |
|
752 |
const DistMap &distMap() const { return *_dist;} |
|
753 |
|
|
754 |
/// \brief Returns a const reference to the node map that stores the |
|
755 |
/// predecessor arcs. |
|
756 |
/// |
|
757 |
/// Returns a const reference to the node map that stores the predecessor |
|
758 |
/// arcs, which form the shortest path tree (forest). |
|
759 |
/// |
|
760 |
/// \pre Either \ref run() or \ref init() must be called before |
|
761 |
/// using this function. |
|
762 |
const PredMap &predMap() const { return *_pred; } |
|
763 |
|
|
764 |
/// \brief Checks if a node is reached from the root(s). |
|
765 |
/// |
|
766 |
/// Returns \c true if \c v is reached from the root(s). |
|
767 |
/// |
|
768 |
/// \pre Either \ref run() or \ref init() must be called before |
|
769 |
/// using this function. |
|
770 |
bool reached(Node v) const { |
|
771 |
return (*_dist)[v] != OperationTraits::infinity(); |
|
772 |
} |
|
773 |
|
|
774 |
/// \brief Gives back a negative cycle. |
|
775 |
/// |
|
776 |
/// This function gives back a directed cycle with negative total |
|
777 |
/// length if the algorithm has already found one. |
|
778 |
/// Otherwise it gives back an empty path. |
|
779 |
lemon::Path<Digraph> negativeCycle() const { |
|
780 |
typename Digraph::template NodeMap<int> state(*_gr, -1); |
|
781 |
lemon::Path<Digraph> cycle; |
|
782 |
for (int i = 0; i < int(_process.size()); ++i) { |
|
783 |
if (state[_process[i]] != -1) continue; |
|
784 |
for (Node v = _process[i]; (*_pred)[v] != INVALID; |
|
785 |
v = _gr->source((*_pred)[v])) { |
|
786 |
if (state[v] == i) { |
|
787 |
cycle.addFront((*_pred)[v]); |
|
788 |
for (Node u = _gr->source((*_pred)[v]); u != v; |
|
789 |
u = _gr->source((*_pred)[u])) { |
|
790 |
cycle.addFront((*_pred)[u]); |
|
791 |
} |
|
792 |
return cycle; |
|
793 |
} |
|
794 |
else if (state[v] >= 0) { |
|
795 |
break; |
|
796 |
} |
|
797 |
state[v] = i; |
|
798 |
} |
|
799 |
} |
|
800 |
return cycle; |
|
801 |
} |
|
802 |
|
|
803 |
///@} |
|
804 |
}; |
|
805 |
|
|
806 |
/// \brief Default traits class of bellmanFord() function. |
|
807 |
/// |
|
808 |
/// Default traits class of bellmanFord() function. |
|
809 |
/// \tparam GR The type of the digraph. |
|
810 |
/// \tparam LEN The type of the length map. |
|
811 |
template <typename GR, typename LEN> |
|
812 |
struct BellmanFordWizardDefaultTraits { |
|
813 |
/// The type of the digraph the algorithm runs on. |
|
814 |
typedef GR Digraph; |
|
815 |
|
|
816 |
/// \brief The type of the map that stores the arc lengths. |
|
817 |
/// |
|
818 |
/// The type of the map that stores the arc lengths. |
|
819 |
/// It must meet the \ref concepts::ReadMap "ReadMap" concept. |
|
820 |
typedef LEN LengthMap; |
|
821 |
|
|
822 |
/// The type of the arc lengths. |
|
823 |
typedef typename LEN::Value Value; |
|
824 |
|
|
825 |
/// \brief Operation traits for Bellman-Ford algorithm. |
|
826 |
/// |
|
827 |
/// It defines the used operations and the infinity value for the |
|
828 |
/// given \c Value type. |
|
829 |
/// \see BellmanFordDefaultOperationTraits |
|
830 |
typedef BellmanFordDefaultOperationTraits<Value> OperationTraits; |
|
831 |
|
|
832 |
/// \brief The type of the map that stores the last |
|
833 |
/// arcs of the shortest paths. |
|
834 |
/// |
|
835 |
/// The type of the map that stores the last arcs of the shortest paths. |
|
836 |
/// It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
837 |
typedef typename GR::template NodeMap<typename GR::Arc> PredMap; |
|
838 |
|
|
839 |
/// \brief Instantiates a \c PredMap. |
|
840 |
/// |
|
841 |
/// This function instantiates a \ref PredMap. |
|
842 |
/// \param g is the digraph to which we would like to define the |
|
843 |
/// \ref PredMap. |
|
844 |
static PredMap *createPredMap(const GR &g) { |
|
845 |
return new PredMap(g); |
|
846 |
} |
|
847 |
|
|
848 |
/// \brief The type of the map that stores the distances of the nodes. |
|
849 |
/// |
|
850 |
/// The type of the map that stores the distances of the nodes. |
|
851 |
/// It must conform to the \ref concepts::WriteMap "WriteMap" concept. |
|
852 |
typedef typename GR::template NodeMap<Value> DistMap; |
|
853 |
|
|
854 |
/// \brief Instantiates a \c DistMap. |
|
855 |
/// |
|
856 |
/// This function instantiates a \ref DistMap. |
|
857 |
/// \param g is the digraph to which we would like to define the |
|
858 |
/// \ref DistMap. |
|
859 |
static DistMap *createDistMap(const GR &g) { |
|
860 |
return new DistMap(g); |
|
861 |
} |
|
862 |
|
|
863 |
///The type of the shortest paths. |
|
864 |
|
|
865 |
///The type of the shortest paths. |
|
866 |
///It must meet the \ref concepts::Path "Path" concept. |
|
867 |
typedef lemon::Path<Digraph> Path; |
|
868 |
}; |
|
869 |
|
|
870 |
/// \brief Default traits class used by BellmanFordWizard. |
|
871 |
/// |
|
872 |
/// Default traits class used by BellmanFordWizard. |
|
873 |
/// \tparam GR The type of the digraph. |
|
874 |
/// \tparam LEN The type of the length map. |
|
875 |
template <typename GR, typename LEN> |
|
876 |
class BellmanFordWizardBase |
|
877 |
: public BellmanFordWizardDefaultTraits<GR, LEN> { |
|
878 |
|
|
879 |
typedef BellmanFordWizardDefaultTraits<GR, LEN> Base; |
|
880 |
protected: |
|
881 |
// Type of the nodes in the digraph. |
|
882 |
typedef typename Base::Digraph::Node Node; |
|
883 |
|
|
884 |
// Pointer to the underlying digraph. |
|
885 |
void *_graph; |
|
886 |
// Pointer to the length map |
|
887 |
void *_length; |
|
888 |
// Pointer to the map of predecessors arcs. |
|
889 |
void *_pred; |
|
890 |
// Pointer to the map of distances. |
|
891 |
void *_dist; |
|
892 |
//Pointer to the shortest path to the target node. |
|
893 |
void *_path; |
|
894 |
//Pointer to the distance of the target node. |
|
895 |
void *_di; |
|
896 |
|
|
897 |
public: |
|
898 |
/// Constructor. |
|
899 |
|
|
900 |
/// This constructor does not require parameters, it initiates |
|
901 |
/// all of the attributes to default values \c 0. |
|
902 |
BellmanFordWizardBase() : |
|
903 |
_graph(0), _length(0), _pred(0), _dist(0), _path(0), _di(0) {} |
|
904 |
|
|
905 |
/// Constructor. |
|
906 |
|
|
907 |
/// This constructor requires two parameters, |
|
908 |
/// others are initiated to \c 0. |
|
909 |
/// \param gr The digraph the algorithm runs on. |
|
910 |
/// \param len The length map. |
|
911 |
BellmanFordWizardBase(const GR& gr, |
|
912 |
const LEN& len) : |
|
913 |
_graph(reinterpret_cast<void*>(const_cast<GR*>(&gr))), |
|
914 |
_length(reinterpret_cast<void*>(const_cast<LEN*>(&len))), |
|
915 |
_pred(0), _dist(0), _path(0), _di(0) {} |
|
916 |
|
|
917 |
}; |
|
918 |
|
|
919 |
/// \brief Auxiliary class for the function-type interface of the |
|
920 |
/// \ref BellmanFord "Bellman-Ford" algorithm. |
|
921 |
/// |
|
922 |
/// This auxiliary class is created to implement the |
|
923 |
/// \ref bellmanFord() "function-type interface" of the |
|
924 |
/// \ref BellmanFord "Bellman-Ford" algorithm. |
|
925 |
/// It does not have own \ref run() method, it uses the |
|
926 |
/// functions and features of the plain \ref BellmanFord. |
|
927 |
/// |
|
928 |
/// This class should only be used through the \ref bellmanFord() |
|
929 |
/// function, which makes it easier to use the algorithm. |
|
930 |
template<class TR> |
|
931 |
class BellmanFordWizard : public TR { |
|
932 |
typedef TR Base; |
|
933 |
|
|
934 |
typedef typename TR::Digraph Digraph; |
|
935 |
|
|
936 |
typedef typename Digraph::Node Node; |
|
937 |
typedef typename Digraph::NodeIt NodeIt; |
|
938 |
typedef typename Digraph::Arc Arc; |
|
939 |
typedef typename Digraph::OutArcIt ArcIt; |
|
940 |
|
|
941 |
typedef typename TR::LengthMap LengthMap; |
|
942 |
typedef typename LengthMap::Value Value; |
|
943 |
typedef typename TR::PredMap PredMap; |
|
944 |
typedef typename TR::DistMap DistMap; |
|
945 |
typedef typename TR::Path Path; |
|
946 |
|
|
947 |
public: |
|
948 |
/// Constructor. |
|
949 |
BellmanFordWizard() : TR() {} |
|
950 |
|
|
951 |
/// \brief Constructor that requires parameters. |
|
952 |
/// |
|
953 |
/// Constructor that requires parameters. |
|
954 |
/// These parameters will be the default values for the traits class. |
|
955 |
/// \param gr The digraph the algorithm runs on. |
|
956 |
/// \param len The length map. |
|
957 |
BellmanFordWizard(const Digraph& gr, const LengthMap& len) |
|
958 |
: TR(gr, len) {} |
|
959 |
|
|
960 |
/// \brief Copy constructor |
|
961 |
BellmanFordWizard(const TR &b) : TR(b) {} |
|
962 |
|
|
963 |
~BellmanFordWizard() {} |
|
964 |
|
|
965 |
/// \brief Runs the Bellman-Ford algorithm from the given source node. |
|
966 |
/// |
|
967 |
/// This method runs the Bellman-Ford algorithm from the given source |
|
968 |
/// node in order to compute the shortest path to each node. |
|
969 |
void run(Node s) { |
|
970 |
BellmanFord<Digraph,LengthMap,TR> |
|
971 |
bf(*reinterpret_cast<const Digraph*>(Base::_graph), |
|
972 |
*reinterpret_cast<const LengthMap*>(Base::_length)); |
|
973 |
if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred)); |
|
974 |
if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(Base::_dist)); |
|
975 |
bf.run(s); |
|
976 |
} |
|
977 |
|
|
978 |
/// \brief Runs the Bellman-Ford algorithm to find the shortest path |
|
979 |
/// between \c s and \c t. |
|
980 |
/// |
|
981 |
/// This method runs the Bellman-Ford algorithm from node \c s |
|
982 |
/// in order to compute the shortest path to node \c t. |
|
983 |
/// Actually, it computes the shortest path to each node, but using |
|
984 |
/// this function you can retrieve the distance and the shortest path |
|
985 |
/// for a single target node easier. |
|
986 |
/// |
|
987 |
/// \return \c true if \c t is reachable form \c s. |
|
988 |
bool run(Node s, Node t) { |
|
989 |
BellmanFord<Digraph,LengthMap,TR> |
|
990 |
bf(*reinterpret_cast<const Digraph*>(Base::_graph), |
|
991 |
*reinterpret_cast<const LengthMap*>(Base::_length)); |
|
992 |
if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred)); |
|
993 |
if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(Base::_dist)); |
|
994 |
bf.run(s); |
|
995 |
if (Base::_path) *reinterpret_cast<Path*>(Base::_path) = bf.path(t); |
|
996 |
if (Base::_di) *reinterpret_cast<Value*>(Base::_di) = bf.dist(t); |
|
997 |
return bf.reached(t); |
|
998 |
} |
|
999 |
|
|
1000 |
template<class T> |
|
1001 |
struct SetPredMapBase : public Base { |
|
1002 |
typedef T PredMap; |
|
1003 |
static PredMap *createPredMap(const Digraph &) { return 0; }; |
|
1004 |
SetPredMapBase(const TR &b) : TR(b) {} |
|
1005 |
}; |
|
1006 |
|
|
1007 |
/// \brief \ref named-templ-param "Named parameter" for setting |
|
1008 |
/// the predecessor map. |
|
1009 |
/// |
|
1010 |
/// \ref named-templ-param "Named parameter" for setting |
|
1011 |
/// the map that stores the predecessor arcs of the nodes. |
|
1012 |
template<class T> |
|
1013 |
BellmanFordWizard<SetPredMapBase<T> > predMap(const T &t) { |
|
1014 |
Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t)); |
|
1015 |
return BellmanFordWizard<SetPredMapBase<T> >(*this); |
|
1016 |
} |
|
1017 |
|
|
1018 |
template<class T> |
|
1019 |
struct SetDistMapBase : public Base { |
|
1020 |
typedef T DistMap; |
|
1021 |
static DistMap *createDistMap(const Digraph &) { return 0; }; |
|
1022 |
SetDistMapBase(const TR &b) : TR(b) {} |
|
1023 |
}; |
|
1024 |
|
|
1025 |
/// \brief \ref named-templ-param "Named parameter" for setting |
|
1026 |
/// the distance map. |
|
1027 |
/// |
|
1028 |
/// \ref named-templ-param "Named parameter" for setting |
|
1029 |
/// the map that stores the distances of the nodes calculated |
|
1030 |
/// by the algorithm. |
|
1031 |
template<class T> |
|
1032 |
BellmanFordWizard<SetDistMapBase<T> > distMap(const T &t) { |
|
1033 |
Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t)); |
|
1034 |
return BellmanFordWizard<SetDistMapBase<T> >(*this); |
|
1035 |
} |
|
1036 |
|
|
1037 |
template<class T> |
|
1038 |
struct SetPathBase : public Base { |
|
1039 |
typedef T Path; |
|
1040 |
SetPathBase(const TR &b) : TR(b) {} |
|
1041 |
}; |
|
1042 |
|
|
1043 |
/// \brief \ref named-func-param "Named parameter" for getting |
|
1044 |
/// the shortest path to the target node. |
|
1045 |
/// |
|
1046 |
/// \ref named-func-param "Named parameter" for getting |
|
1047 |
/// the shortest path to the target node. |
|
1048 |
template<class T> |
|
1049 |
BellmanFordWizard<SetPathBase<T> > path(const T &t) |
|
1050 |
{ |
|
1051 |
Base::_path=reinterpret_cast<void*>(const_cast<T*>(&t)); |
|
1052 |
return BellmanFordWizard<SetPathBase<T> >(*this); |
|
1053 |
} |
|
1054 |
|
|
1055 |
/// \brief \ref named-func-param "Named parameter" for getting |
|
1056 |
/// the distance of the target node. |
|
1057 |
/// |
|
1058 |
/// \ref named-func-param "Named parameter" for getting |
|
1059 |
/// the distance of the target node. |
|
1060 |
BellmanFordWizard dist(const Value &d) |
|
1061 |
{ |
|
1062 |
Base::_di=reinterpret_cast<void*>(const_cast<Value*>(&d)); |
|
1063 |
return *this; |
|
1064 |
} |
|
1065 |
|
|
1066 |
}; |
|
1067 |
|
|
1068 |
/// \brief Function type interface for the \ref BellmanFord "Bellman-Ford" |
|
1069 |
/// algorithm. |
|
1070 |
/// |
|
1071 |
/// \ingroup shortest_path |
|
1072 |
/// Function type interface for the \ref BellmanFord "Bellman-Ford" |
|
1073 |
/// algorithm. |
|
1074 |
/// |
|
1075 |
/// This function also has several \ref named-templ-func-param |
|
1076 |
/// "named parameters", they are declared as the members of class |
|
1077 |
/// \ref BellmanFordWizard. |
|
1078 |
/// The following examples show how to use these parameters. |
|
1079 |
/// \code |
|
1080 |
/// // Compute shortest path from node s to each node |
|
1081 |
/// bellmanFord(g,length).predMap(preds).distMap(dists).run(s); |
|
1082 |
/// |
|
1083 |
/// // Compute shortest path from s to t |
|
1084 |
/// bool reached = bellmanFord(g,length).path(p).dist(d).run(s,t); |
|
1085 |
/// \endcode |
|
1086 |
/// \warning Don't forget to put the \ref BellmanFordWizard::run() "run()" |
|
1087 |
/// to the end of the parameter list. |
|
1088 |
/// \sa BellmanFordWizard |
|
1089 |
/// \sa BellmanFord |
|
1090 |
template<typename GR, typename LEN> |
|
1091 |
BellmanFordWizard<BellmanFordWizardBase<GR,LEN> > |
|
1092 |
bellmanFord(const GR& digraph, |
|
1093 |
const LEN& length) |
|
1094 |
{ |
|
1095 |
return BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >(digraph, length); |
|
1096 |
} |
|
1097 |
|
|
1098 |
} //END OF NAMESPACE LEMON |
|
1099 |
|
|
1100 |
#endif |
|
1101 |
1 | 1 |
CMAKE_MINIMUM_REQUIRED(VERSION 2.6) |
2 | 2 |
|
3 | 3 |
SET(PROJECT_NAME "LEMON") |
4 | 4 |
PROJECT(${PROJECT_NAME}) |
5 | 5 |
|
6 | 6 |
IF(EXISTS ${PROJECT_SOURCE_DIR}/cmake/version.cmake) |
7 | 7 |
INCLUDE(${PROJECT_SOURCE_DIR}/cmake/version.cmake) |
8 | 8 |
ELSEIF(DEFINED ENV{LEMON_VERSION}) |
9 | 9 |
SET(LEMON_VERSION $ENV{LEMON_VERSION} CACHE STRING "LEMON version string.") |
10 | 10 |
ELSE() |
11 | 11 |
EXECUTE_PROCESS( |
12 | 12 |
COMMAND hg id -i |
13 | 13 |
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} |
14 | 14 |
OUTPUT_VARIABLE HG_REVISION |
15 | 15 |
ERROR_QUIET |
16 | 16 |
OUTPUT_STRIP_TRAILING_WHITESPACE |
17 | 17 |
) |
18 | 18 |
IF(HG_REVISION STREQUAL "") |
19 | 19 |
SET(HG_REVISION "hg-tip") |
20 | 20 |
ENDIF() |
21 | 21 |
SET(LEMON_VERSION ${HG_REVISION} CACHE STRING "LEMON version string.") |
22 | 22 |
ENDIF() |
23 | 23 |
|
24 | 24 |
SET(PROJECT_VERSION ${LEMON_VERSION}) |
25 | 25 |
|
26 | 26 |
SET(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) |
27 | 27 |
|
28 | 28 |
FIND_PACKAGE(Doxygen) |
29 | 29 |
FIND_PACKAGE(Ghostscript) |
30 | 30 |
FIND_PACKAGE(GLPK 4.33) |
31 | 31 |
FIND_PACKAGE(CPLEX) |
32 | 32 |
FIND_PACKAGE(COIN) |
33 | 33 |
|
34 | 34 |
INCLUDE(CheckTypeSize) |
35 | 35 |
CHECK_TYPE_SIZE("long long" LONG_LONG) |
36 | 36 |
SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG}) |
37 | 37 |
|
38 |
INCLUDE(FindPythonInterp) |
|
39 |
|
|
38 | 40 |
ENABLE_TESTING() |
39 | 41 |
|
40 | 42 |
ADD_SUBDIRECTORY(lemon) |
41 | 43 |
IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR}) |
42 | 44 |
ADD_SUBDIRECTORY(demo) |
43 | 45 |
ADD_SUBDIRECTORY(tools) |
44 | 46 |
ADD_SUBDIRECTORY(doc) |
45 | 47 |
ADD_SUBDIRECTORY(test) |
46 | 48 |
ENDIF() |
47 | 49 |
|
48 | 50 |
CONFIGURE_FILE( |
49 | 51 |
${PROJECT_SOURCE_DIR}/cmake/LEMONConfig.cmake.in |
50 | 52 |
${PROJECT_BINARY_DIR}/cmake/LEMONConfig.cmake |
51 | 53 |
@ONLY |
52 | 54 |
) |
53 | 55 |
IF(UNIX) |
54 | 56 |
INSTALL( |
55 | 57 |
FILES ${PROJECT_BINARY_DIR}/cmake/LEMONConfig.cmake |
56 | 58 |
DESTINATION share/lemon/cmake |
57 | 59 |
) |
58 | 60 |
ELSEIF(WIN32) |
59 | 61 |
INSTALL( |
60 | 62 |
FILES ${PROJECT_BINARY_DIR}/cmake/LEMONConfig.cmake |
61 | 63 |
DESTINATION cmake |
62 | 64 |
) |
63 | 65 |
ENDIF() |
64 | 66 |
|
65 | 67 |
IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR} AND WIN32) |
66 | 68 |
SET(CPACK_PACKAGE_NAME ${PROJECT_NAME}) |
67 | 69 |
SET(CPACK_PACKAGE_VENDOR "EGRES") |
68 | 70 |
SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY |
69 | 71 |
"LEMON - Library for Efficient Modeling and Optimization in Networks") |
70 | 72 |
SET(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE") |
71 | 73 |
|
72 | 74 |
SET(CPACK_PACKAGE_VERSION ${PROJECT_VERSION}) |
73 | 75 |
|
74 | 76 |
SET(CPACK_PACKAGE_INSTALL_DIRECTORY |
75 | 77 |
"${PROJECT_NAME} ${PROJECT_VERSION}") |
76 | 78 |
SET(CPACK_PACKAGE_INSTALL_REGISTRY_KEY |
77 | 79 |
"${PROJECT_NAME} ${PROJECT_VERSION}") |
78 | 80 |
|
79 | 81 |
SET(CPACK_COMPONENTS_ALL headers library html_documentation bin) |
80 | 82 |
|
81 | 83 |
SET(CPACK_COMPONENT_HEADERS_DISPLAY_NAME "C++ headers") |
82 | 84 |
SET(CPACK_COMPONENT_LIBRARY_DISPLAY_NAME "Dynamic-link library") |
83 | 85 |
SET(CPACK_COMPONENT_BIN_DISPLAY_NAME "Command line utilities") |
84 | 86 |
SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DISPLAY_NAME "HTML documentation") |
85 | 87 |
|
86 | 88 |
SET(CPACK_COMPONENT_HEADERS_DESCRIPTION |
87 | 89 |
"C++ header files") |
88 | 90 |
SET(CPACK_COMPONENT_LIBRARY_DESCRIPTION |
89 | 91 |
"DLL and import library") |
90 | 92 |
SET(CPACK_COMPONENT_BIN_DESCRIPTION |
91 | 93 |
"Command line utilities") |
92 | 94 |
SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DESCRIPTION |
93 | 95 |
"Doxygen generated documentation") |
94 | 96 |
|
95 | 97 |
SET(CPACK_COMPONENT_HEADERS_DEPENDS library) |
96 | 98 |
|
97 | 99 |
SET(CPACK_COMPONENT_HEADERS_GROUP "Development") |
98 | 100 |
SET(CPACK_COMPONENT_LIBRARY_GROUP "Development") |
99 | 101 |
SET(CPACK_COMPONENT_HTML_DOCUMENTATION_GROUP "Documentation") |
100 | 102 |
|
101 | 103 |
SET(CPACK_COMPONENT_GROUP_DEVELOPMENT_DESCRIPTION |
102 | 104 |
"Components needed to develop software using LEMON") |
103 | 105 |
SET(CPACK_COMPONENT_GROUP_DOCUMENTATION_DESCRIPTION |
104 | 106 |
"Documentation of LEMON") |
105 | 107 |
|
106 | 108 |
SET(CPACK_ALL_INSTALL_TYPES Full Developer) |
107 | 109 |
|
108 | 110 |
SET(CPACK_COMPONENT_HEADERS_INSTALL_TYPES Developer Full) |
109 | 111 |
SET(CPACK_COMPONENT_LIBRARY_INSTALL_TYPES Developer Full) |
110 | 112 |
SET(CPACK_COMPONENT_HTML_DOCUMENTATION_INSTALL_TYPES Full) |
111 | 113 |
|
112 | 114 |
SET(CPACK_GENERATOR "NSIS") |
113 | 115 |
SET(CPACK_NSIS_MUI_ICON "${PROJECT_SOURCE_DIR}/cmake/nsis/lemon.ico") |
114 | 116 |
SET(CPACK_NSIS_MUI_UNIICON "${PROJECT_SOURCE_DIR}/cmake/nsis/uninstall.ico") |
115 | 117 |
#SET(CPACK_PACKAGE_ICON "${PROJECT_SOURCE_DIR}/cmake/nsis\\\\installer.bmp") |
116 | 118 |
SET(CPACK_NSIS_INSTALLED_ICON_NAME "bin\\\\lemon.ico") |
117 | 119 |
SET(CPACK_NSIS_DISPLAY_NAME "${CPACK_PACKAGE_INSTALL_DIRECTORY} ${PROJECT_NAME}") |
118 | 120 |
SET(CPACK_NSIS_HELP_LINK "http:\\\\\\\\lemon.cs.elte.hu") |
119 | 121 |
SET(CPACK_NSIS_URL_INFO_ABOUT "http:\\\\\\\\lemon.cs.elte.hu") |
120 | 122 |
SET(CPACK_NSIS_CONTACT "lemon-user@lemon.cs.elte.hu") |
121 | 123 |
SET(CPACK_NSIS_CREATE_ICONS_EXTRA " |
122 | 124 |
CreateShortCut \\\"$SMPROGRAMS\\\\$STARTMENU_FOLDER\\\\Documentation.lnk\\\" \\\"$INSTDIR\\\\share\\\\doc\\\\index.html\\\" |
123 | 125 |
") |
124 | 126 |
SET(CPACK_NSIS_DELETE_ICONS_EXTRA " |
125 | 127 |
!insertmacro MUI_STARTMENU_GETFOLDER Application $MUI_TEMP |
126 | 128 |
Delete \\\"$SMPROGRAMS\\\\$MUI_TEMP\\\\Documentation.lnk\\\" |
127 | 129 |
") |
128 | 130 |
|
129 | 131 |
INCLUDE(CPack) |
130 | 132 |
ENDIF() |
1 | 1 |
ACLOCAL_AMFLAGS = -I m4 |
2 | 2 |
|
3 | 3 |
AM_CXXFLAGS = $(WARNINGCXXFLAGS) |
4 | 4 |
|
5 | 5 |
AM_CPPFLAGS = -I$(top_srcdir) -I$(top_builddir) |
6 | 6 |
LDADD = $(top_builddir)/lemon/libemon.la |
7 | 7 |
|
8 | 8 |
EXTRA_DIST = \ |
9 | 9 |
AUTHORS \ |
10 | 10 |
LICENSE \ |
11 | 11 |
m4/lx_check_cplex.m4 \ |
12 | 12 |
m4/lx_check_glpk.m4 \ |
13 | 13 |
m4/lx_check_soplex.m4 \ |
14 | 14 |
m4/lx_check_coin.m4 \ |
15 | 15 |
CMakeLists.txt \ |
16 | 16 |
cmake/FindGhostscript.cmake \ |
17 | 17 |
cmake/FindCPLEX.cmake \ |
18 | 18 |
cmake/FindGLPK.cmake \ |
19 | 19 |
cmake/FindCOIN.cmake \ |
20 |
cmake/LEMONConfig.cmake.in \ |
|
20 | 21 |
cmake/version.cmake.in \ |
21 | 22 |
cmake/version.cmake \ |
22 | 23 |
cmake/nsis/lemon.ico \ |
23 | 24 |
cmake/nsis/uninstall.ico |
24 | 25 |
|
25 | 26 |
pkgconfigdir = $(libdir)/pkgconfig |
26 | 27 |
lemondir = $(pkgincludedir) |
27 | 28 |
bitsdir = $(lemondir)/bits |
28 | 29 |
conceptdir = $(lemondir)/concepts |
29 | 30 |
pkgconfig_DATA = |
30 | 31 |
lib_LTLIBRARIES = |
31 | 32 |
lemon_HEADERS = |
32 | 33 |
bits_HEADERS = |
33 | 34 |
concept_HEADERS = |
34 | 35 |
noinst_HEADERS = |
35 | 36 |
noinst_PROGRAMS = |
36 | 37 |
bin_PROGRAMS = |
37 | 38 |
check_PROGRAMS = |
38 | 39 |
dist_bin_SCRIPTS = |
39 | 40 |
TESTS = |
40 | 41 |
XFAIL_TESTS = |
41 | 42 |
|
42 | 43 |
include lemon/Makefile.am |
43 | 44 |
include test/Makefile.am |
44 | 45 |
include doc/Makefile.am |
45 | 46 |
include tools/Makefile.am |
47 |
include scripts/Makefile.am |
|
46 | 48 |
|
47 | 49 |
DIST_SUBDIRS = demo |
48 | 50 |
|
49 | 51 |
demo: |
50 | 52 |
$(MAKE) $(AM_MAKEFLAGS) -C demo |
51 | 53 |
|
52 | 54 |
MRPROPERFILES = \ |
53 | 55 |
aclocal.m4 \ |
54 | 56 |
config.h.in \ |
55 | 57 |
config.h.in~ \ |
56 | 58 |
configure \ |
57 | 59 |
Makefile.in \ |
58 | 60 |
build-aux/config.guess \ |
59 | 61 |
build-aux/config.sub \ |
60 | 62 |
build-aux/depcomp \ |
61 | 63 |
build-aux/install-sh \ |
62 | 64 |
build-aux/ltmain.sh \ |
63 | 65 |
build-aux/missing \ |
64 | 66 |
doc/doxygen.log |
65 | 67 |
|
66 | 68 |
mrproper: |
67 | 69 |
$(MAKE) $(AM_MAKEFLAGS) maintainer-clean |
68 | 70 |
-rm -f $(MRPROPERFILES) |
69 | 71 |
|
70 | 72 |
dist-bz2: dist |
71 | 73 |
zcat $(PACKAGE)-$(VERSION).tar.gz | \ |
72 | 74 |
bzip2 --best -c > $(PACKAGE)-$(VERSION).tar.bz2 |
73 | 75 |
|
74 | 76 |
distcheck-bz2: distcheck |
75 | 77 |
zcat $(PACKAGE)-$(VERSION).tar.gz | \ |
76 | 78 |
bzip2 --best -c > $(PACKAGE)-$(VERSION).tar.bz2 |
77 | 79 |
|
78 | 80 |
.PHONY: demo mrproper dist-bz2 distcheck-bz2 |
1 | 1 |
dnl Process this file with autoconf to produce a configure script. |
2 | 2 |
|
3 | 3 |
dnl Version information. |
4 | 4 |
m4_define([lemon_version_number], |
5 | 5 |
[m4_normalize(esyscmd([echo ${LEMON_VERSION}]))]) |
6 | 6 |
dnl m4_define([lemon_version_number], []) |
7 | 7 |
m4_define([lemon_hg_path], [m4_normalize(esyscmd([./scripts/chg-len.py]))]) |
8 | 8 |
m4_define([lemon_hg_revision], [m4_normalize(esyscmd([hg id -i 2> /dev/null]))]) |
9 | 9 |
m4_define([lemon_version], [ifelse(lemon_version_number(), |
10 | 10 |
[], |
11 | 11 |
[ifelse(lemon_hg_revision(), |
12 | 12 |
[], |
13 | 13 |
[hg-tip], |
14 | 14 |
[lemon_hg_path().lemon_hg_revision()])], |
15 | 15 |
[lemon_version_number()])]) |
16 | 16 |
|
17 | 17 |
AC_PREREQ([2.59]) |
18 | 18 |
AC_INIT([LEMON], [lemon_version()], [lemon-user@lemon.cs.elte.hu], [lemon]) |
19 | 19 |
AC_CONFIG_AUX_DIR([build-aux]) |
20 | 20 |
AC_CONFIG_MACRO_DIR([m4]) |
21 | 21 |
AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects nostdinc]) |
22 | 22 |
AC_CONFIG_SRCDIR([lemon/list_graph.h]) |
23 | 23 |
AC_CONFIG_HEADERS([config.h lemon/config.h]) |
24 | 24 |
|
25 | 25 |
AC_DEFINE([LEMON_VERSION], [lemon_version()], [The version string]) |
26 | 26 |
|
27 | 27 |
dnl Do compilation tests using the C++ compiler. |
28 | 28 |
AC_LANG([C++]) |
29 | 29 |
|
30 | 30 |
dnl Check the existence of long long type. |
31 | 31 |
AC_CHECK_TYPE(long long, [long_long_found=yes], [long_long_found=no]) |
32 | 32 |
if test x"$long_long_found" = x"yes"; then |
33 | 33 |
AC_DEFINE([LEMON_HAVE_LONG_LONG], [1], [Define to 1 if you have long long.]) |
34 | 34 |
fi |
35 | 35 |
|
36 | 36 |
dnl Checks for programs. |
37 | 37 |
AC_PROG_CXX |
38 | 38 |
AC_PROG_CXXCPP |
39 | 39 |
AC_PROG_INSTALL |
40 | 40 |
AC_DISABLE_SHARED |
41 | 41 |
AC_PROG_LIBTOOL |
42 | 42 |
|
43 | 43 |
AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no]) |
44 |
AC_CHECK_PROG([python_found],[python],[yes],[no]) |
|
44 | 45 |
AC_CHECK_PROG([gs_found],[gs],[yes],[no]) |
45 | 46 |
|
46 | 47 |
dnl Detect Intel compiler. |
47 | 48 |
AC_MSG_CHECKING([whether we are using the Intel C++ compiler]) |
48 | 49 |
AC_COMPILE_IFELSE([#ifndef __INTEL_COMPILER |
49 | 50 |
choke me |
50 | 51 |
#endif], [ICC=[yes]], [ICC=[no]]) |
51 | 52 |
if test x"$ICC" = x"yes"; then |
52 | 53 |
AC_MSG_RESULT([yes]) |
53 | 54 |
else |
54 | 55 |
AC_MSG_RESULT([no]) |
55 | 56 |
fi |
56 | 57 |
|
57 | 58 |
dnl Set custom compiler flags when using g++. |
58 | 59 |
if test "$GXX" = yes -a "$ICC" = no; then |
59 | 60 |
WARNINGCXXFLAGS="-Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas" |
60 | 61 |
fi |
61 | 62 |
AC_SUBST([WARNINGCXXFLAGS]) |
62 | 63 |
|
63 | 64 |
dnl Checks for libraries. |
64 | 65 |
LX_CHECK_GLPK |
65 | 66 |
LX_CHECK_CPLEX |
66 | 67 |
LX_CHECK_SOPLEX |
67 | 68 |
LX_CHECK_COIN |
68 | 69 |
|
69 | 70 |
AM_CONDITIONAL([HAVE_LP], [test x"$lx_lp_found" = x"yes"]) |
70 | 71 |
AM_CONDITIONAL([HAVE_MIP], [test x"$lx_mip_found" = x"yes"]) |
71 | 72 |
|
72 | 73 |
dnl Disable/enable building the binary tools. |
73 | 74 |
AC_ARG_ENABLE([tools], |
74 | 75 |
AS_HELP_STRING([--enable-tools], [build additional tools @<:@default@:>@]) |
75 | 76 |
AS_HELP_STRING([--disable-tools], [do not build additional tools]), |
76 | 77 |
[], [enable_tools=yes]) |
77 | 78 |
AC_MSG_CHECKING([whether to build the additional tools]) |
78 | 79 |
if test x"$enable_tools" != x"no"; then |
79 | 80 |
AC_MSG_RESULT([yes]) |
80 | 81 |
else |
81 | 82 |
AC_MSG_RESULT([no]) |
82 | 83 |
fi |
83 | 84 |
AM_CONDITIONAL([WANT_TOOLS], [test x"$enable_tools" != x"no"]) |
84 | 85 |
|
86 |
dnl Support for running test cases using valgrind. |
|
87 |
use_valgrind=no |
|
88 |
AC_ARG_ENABLE([valgrind], |
|
89 |
AS_HELP_STRING([--enable-valgrind], [use valgrind when running tests]), |
|
90 |
[use_valgrind=yes]) |
|
91 |
|
|
92 |
if [[ "$use_valgrind" = "yes" ]]; then |
|
93 |
AC_CHECK_PROG(HAVE_VALGRIND, valgrind, yes, no) |
|
94 |
|
|
95 |
if [[ "$HAVE_VALGRIND" = "no" ]]; then |
|
96 |
AC_MSG_ERROR([Valgrind not found in PATH.]) |
|
97 |
fi |
|
98 |
fi |
|
99 |
AM_CONDITIONAL(USE_VALGRIND, [test "$use_valgrind" = "yes"]) |
|
100 |
|
|
85 | 101 |
dnl Checks for header files. |
86 | 102 |
AC_CHECK_HEADERS(limits.h sys/time.h sys/times.h unistd.h) |
87 | 103 |
|
88 | 104 |
dnl Checks for typedefs, structures, and compiler characteristics. |
89 | 105 |
AC_C_CONST |
90 | 106 |
AC_C_INLINE |
91 | 107 |
AC_TYPE_SIZE_T |
92 | 108 |
AC_HEADER_TIME |
93 | 109 |
AC_STRUCT_TM |
94 | 110 |
|
95 | 111 |
dnl Checks for library functions. |
96 | 112 |
AC_HEADER_STDC |
97 | 113 |
AC_CHECK_FUNCS(gettimeofday times ctime_r) |
98 | 114 |
|
99 | 115 |
dnl Add dependencies on files generated by configure. |
100 | 116 |
AC_SUBST([CONFIG_STATUS_DEPENDENCIES], |
101 | 117 |
['$(top_srcdir)/doc/Doxyfile.in $(top_srcdir)/lemon/lemon.pc.in $(top_srcdir)/cmake/version.cmake.in']) |
102 | 118 |
|
103 | 119 |
AC_CONFIG_FILES([ |
104 | 120 |
Makefile |
105 | 121 |
demo/Makefile |
106 | 122 |
cmake/version.cmake |
107 | 123 |
doc/Doxyfile |
108 | 124 |
lemon/lemon.pc |
109 | 125 |
]) |
110 | 126 |
|
111 | 127 |
AC_OUTPUT |
112 | 128 |
|
113 | 129 |
echo |
114 | 130 |
echo '****************************** SUMMARY ******************************' |
115 | 131 |
echo |
116 | 132 |
echo Package version............... : $PACKAGE-$VERSION |
117 | 133 |
echo |
118 | 134 |
echo C++ compiler.................. : $CXX |
119 | 135 |
echo C++ compiles flags............ : $WARNINGCXXFLAGS $CXXFLAGS |
120 | 136 |
echo |
121 | 137 |
echo Compiler supports long long... : $long_long_found |
122 | 138 |
echo |
123 | 139 |
echo GLPK support.................. : $lx_glpk_found |
124 | 140 |
echo CPLEX support................. : $lx_cplex_found |
125 | 141 |
echo SOPLEX support................ : $lx_soplex_found |
126 | 142 |
echo CLP support................... : $lx_clp_found |
127 | 143 |
echo CBC support................... : $lx_cbc_found |
128 | 144 |
echo |
129 | 145 |
echo Build additional tools........ : $enable_tools |
146 |
echo Use valgrind for tests........ : $use_valgrind |
|
130 | 147 |
echo |
131 | 148 |
echo The packace will be installed in |
132 | 149 |
echo -n ' ' |
133 | 150 |
echo $prefix. |
134 | 151 |
echo |
135 | 152 |
echo '*********************************************************************' |
136 | 153 |
|
137 | 154 |
echo |
138 | 155 |
echo Configure complete, now type \'make\' and then \'make install\'. |
139 | 156 |
echo |
1 | 1 |
SET(PACKAGE_NAME ${PROJECT_NAME}) |
2 | 2 |
SET(PACKAGE_VERSION ${PROJECT_VERSION}) |
3 | 3 |
SET(abs_top_srcdir ${PROJECT_SOURCE_DIR}) |
4 | 4 |
SET(abs_top_builddir ${PROJECT_BINARY_DIR}) |
5 | 5 |
|
6 | 6 |
CONFIGURE_FILE( |
7 | 7 |
${PROJECT_SOURCE_DIR}/doc/Doxyfile.in |
8 | 8 |
${PROJECT_BINARY_DIR}/doc/Doxyfile |
9 | 9 |
@ONLY |
10 | 10 |
) |
11 | 11 |
|
12 |
IF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE) |
|
12 |
IF(DOXYGEN_EXECUTABLE AND PYTHONINTERP_FOUND AND GHOSTSCRIPT_EXECUTABLE) |
|
13 | 13 |
FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/) |
14 | 14 |
SET(GHOSTSCRIPT_OPTIONS -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha) |
15 | 15 |
ADD_CUSTOM_TARGET(html |
16 | 16 |
COMMAND ${CMAKE_COMMAND} -E remove_directory gen-images |
17 | 17 |
COMMAND ${CMAKE_COMMAND} -E make_directory gen-images |
18 | 18 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/bipartite_matching.png ${CMAKE_CURRENT_SOURCE_DIR}/images/bipartite_matching.eps |
19 | 19 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/bipartite_partitions.png ${CMAKE_CURRENT_SOURCE_DIR}/images/bipartite_partitions.eps |
20 | 20 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/connected_components.eps |
21 | 21 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/edge_biconnected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/edge_biconnected_components.eps |
22 | 22 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/grid_graph.png ${CMAKE_CURRENT_SOURCE_DIR}/images/grid_graph.eps |
23 | 23 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/node_biconnected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/node_biconnected_components.eps |
24 | 24 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_0.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_0.eps |
25 | 25 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_1.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_1.eps |
26 | 26 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_2.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_2.eps |
27 | 27 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps |
28 | 28 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps |
29 | 29 |
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/strongly_connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/strongly_connected_components.eps |
30 | 30 |
COMMAND ${CMAKE_COMMAND} -E remove_directory html |
31 |
COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/scripts/bib2dox.py ${CMAKE_CURRENT_SOURCE_DIR}/references.bib >references.dox |
|
31 | 32 |
COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile |
32 | 33 |
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} |
33 | 34 |
) |
34 | 35 |
|
35 | 36 |
SET_TARGET_PROPERTIES(html PROPERTIES PROJECT_LABEL BUILD_DOC) |
36 | 37 |
|
37 | 38 |
IF(UNIX) |
38 | 39 |
INSTALL( |
39 | 40 |
DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/ |
40 | 41 |
DESTINATION share/doc/lemon/html |
41 | 42 |
COMPONENT html_documentation |
42 | 43 |
) |
43 | 44 |
ELSEIF(WIN32) |
44 | 45 |
INSTALL( |
45 | 46 |
DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/ |
46 | 47 |
DESTINATION doc |
47 | 48 |
COMPONENT html_documentation |
48 | 49 |
) |
49 | 50 |
ENDIF() |
50 | 51 |
|
51 | 52 |
ENDIF() |
1 |
# Doxyfile 1.5. |
|
1 |
# Doxyfile 1.5.9 |
|
2 | 2 |
|
3 | 3 |
#--------------------------------------------------------------------------- |
4 | 4 |
# Project related configuration options |
5 | 5 |
#--------------------------------------------------------------------------- |
6 | 6 |
DOXYFILE_ENCODING = UTF-8 |
7 | 7 |
PROJECT_NAME = @PACKAGE_NAME@ |
8 | 8 |
PROJECT_NUMBER = @PACKAGE_VERSION@ |
9 | 9 |
OUTPUT_DIRECTORY = |
10 | 10 |
CREATE_SUBDIRS = NO |
11 | 11 |
OUTPUT_LANGUAGE = English |
12 | 12 |
BRIEF_MEMBER_DESC = YES |
13 | 13 |
REPEAT_BRIEF = NO |
14 | 14 |
ABBREVIATE_BRIEF = |
15 | 15 |
ALWAYS_DETAILED_SEC = NO |
16 | 16 |
INLINE_INHERITED_MEMB = NO |
17 | 17 |
FULL_PATH_NAMES = YES |
18 | 18 |
STRIP_FROM_PATH = "@abs_top_srcdir@" |
19 | 19 |
STRIP_FROM_INC_PATH = "@abs_top_srcdir@" |
20 | 20 |
SHORT_NAMES = YES |
21 | 21 |
JAVADOC_AUTOBRIEF = NO |
22 | 22 |
QT_AUTOBRIEF = NO |
23 | 23 |
MULTILINE_CPP_IS_BRIEF = NO |
24 |
DETAILS_AT_TOP = YES |
|
25 | 24 |
INHERIT_DOCS = NO |
26 | 25 |
SEPARATE_MEMBER_PAGES = NO |
27 | 26 |
TAB_SIZE = 8 |
28 | 27 |
ALIASES = |
29 | 28 |
OPTIMIZE_OUTPUT_FOR_C = NO |
30 | 29 |
OPTIMIZE_OUTPUT_JAVA = NO |
31 | 30 |
OPTIMIZE_FOR_FORTRAN = NO |
32 | 31 |
OPTIMIZE_OUTPUT_VHDL = NO |
33 | 32 |
BUILTIN_STL_SUPPORT = YES |
34 | 33 |
CPP_CLI_SUPPORT = NO |
35 | 34 |
SIP_SUPPORT = NO |
36 | 35 |
IDL_PROPERTY_SUPPORT = YES |
37 | 36 |
DISTRIBUTE_GROUP_DOC = NO |
38 | 37 |
SUBGROUPING = YES |
39 | 38 |
TYPEDEF_HIDES_STRUCT = NO |
40 | 39 |
SYMBOL_CACHE_SIZE = 0 |
41 | 40 |
#--------------------------------------------------------------------------- |
42 | 41 |
# Build related configuration options |
43 | 42 |
#--------------------------------------------------------------------------- |
44 | 43 |
EXTRACT_ALL = NO |
45 | 44 |
EXTRACT_PRIVATE = YES |
46 | 45 |
EXTRACT_STATIC = YES |
47 | 46 |
EXTRACT_LOCAL_CLASSES = NO |
48 | 47 |
EXTRACT_LOCAL_METHODS = NO |
49 | 48 |
EXTRACT_ANON_NSPACES = NO |
50 | 49 |
HIDE_UNDOC_MEMBERS = YES |
51 | 50 |
HIDE_UNDOC_CLASSES = YES |
52 | 51 |
HIDE_FRIEND_COMPOUNDS = NO |
53 | 52 |
HIDE_IN_BODY_DOCS = NO |
54 | 53 |
INTERNAL_DOCS = NO |
55 | 54 |
CASE_SENSE_NAMES = YES |
56 | 55 |
HIDE_SCOPE_NAMES = YES |
57 | 56 |
SHOW_INCLUDE_FILES = YES |
58 | 57 |
INLINE_INFO = YES |
59 | 58 |
SORT_MEMBER_DOCS = NO |
60 | 59 |
SORT_BRIEF_DOCS = NO |
61 | 60 |
SORT_GROUP_NAMES = NO |
62 | 61 |
SORT_BY_SCOPE_NAME = NO |
63 | 62 |
GENERATE_TODOLIST = YES |
64 | 63 |
GENERATE_TESTLIST = YES |
65 | 64 |
GENERATE_BUGLIST = YES |
66 | 65 |
GENERATE_DEPRECATEDLIST= YES |
67 | 66 |
ENABLED_SECTIONS = |
68 | 67 |
MAX_INITIALIZER_LINES = 5 |
69 | 68 |
SHOW_USED_FILES = NO |
70 | 69 |
SHOW_DIRECTORIES = YES |
71 | 70 |
SHOW_FILES = YES |
72 | 71 |
SHOW_NAMESPACES = YES |
73 | 72 |
FILE_VERSION_FILTER = |
74 | 73 |
LAYOUT_FILE = DoxygenLayout.xml |
75 | 74 |
#--------------------------------------------------------------------------- |
76 | 75 |
# configuration options related to warning and progress messages |
77 | 76 |
#--------------------------------------------------------------------------- |
78 | 77 |
QUIET = NO |
79 | 78 |
WARNINGS = YES |
80 | 79 |
WARN_IF_UNDOCUMENTED = YES |
81 | 80 |
WARN_IF_DOC_ERROR = YES |
82 | 81 |
WARN_NO_PARAMDOC = NO |
83 | 82 |
WARN_FORMAT = "$file:$line: $text" |
84 | 83 |
WARN_LOGFILE = doxygen.log |
85 | 84 |
#--------------------------------------------------------------------------- |
86 | 85 |
# configuration options related to the input files |
87 | 86 |
#--------------------------------------------------------------------------- |
88 | 87 |
INPUT = "@abs_top_srcdir@/doc" \ |
89 | 88 |
"@abs_top_srcdir@/lemon" \ |
90 | 89 |
"@abs_top_srcdir@/lemon/bits" \ |
91 | 90 |
"@abs_top_srcdir@/lemon/concepts" \ |
92 | 91 |
"@abs_top_srcdir@/demo" \ |
93 | 92 |
"@abs_top_srcdir@/tools" \ |
94 |
"@abs_top_srcdir@/test/test_tools.h" |
|
93 |
"@abs_top_srcdir@/test/test_tools.h" \ |
|
94 |
"@abs_top_builddir@/doc/references.dox" |
|
95 | 95 |
INPUT_ENCODING = UTF-8 |
96 | 96 |
FILE_PATTERNS = *.h \ |
97 | 97 |
*.cc \ |
98 | 98 |
*.dox |
99 | 99 |
RECURSIVE = NO |
100 | 100 |
EXCLUDE = |
101 | 101 |
EXCLUDE_SYMLINKS = NO |
102 | 102 |
EXCLUDE_PATTERNS = |
103 | 103 |
EXCLUDE_SYMBOLS = |
104 | 104 |
EXAMPLE_PATH = "@abs_top_srcdir@/demo" \ |
105 | 105 |
"@abs_top_srcdir@/LICENSE" \ |
106 | 106 |
"@abs_top_srcdir@/doc" |
107 | 107 |
EXAMPLE_PATTERNS = |
108 | 108 |
EXAMPLE_RECURSIVE = NO |
109 | 109 |
IMAGE_PATH = "@abs_top_srcdir@/doc/images" \ |
110 | 110 |
"@abs_top_builddir@/doc/gen-images" |
111 | 111 |
INPUT_FILTER = |
112 | 112 |
FILTER_PATTERNS = |
113 | 113 |
FILTER_SOURCE_FILES = NO |
114 | 114 |
#--------------------------------------------------------------------------- |
115 | 115 |
# configuration options related to source browsing |
116 | 116 |
#--------------------------------------------------------------------------- |
117 | 117 |
SOURCE_BROWSER = NO |
118 | 118 |
INLINE_SOURCES = NO |
119 | 119 |
STRIP_CODE_COMMENTS = YES |
120 | 120 |
REFERENCED_BY_RELATION = NO |
121 | 121 |
REFERENCES_RELATION = NO |
122 | 122 |
REFERENCES_LINK_SOURCE = YES |
123 | 123 |
USE_HTAGS = NO |
124 | 124 |
VERBATIM_HEADERS = NO |
125 | 125 |
#--------------------------------------------------------------------------- |
126 | 126 |
# configuration options related to the alphabetical class index |
127 | 127 |
#--------------------------------------------------------------------------- |
128 | 128 |
ALPHABETICAL_INDEX = YES |
129 | 129 |
COLS_IN_ALPHA_INDEX = 2 |
130 | 130 |
IGNORE_PREFIX = |
131 | 131 |
#--------------------------------------------------------------------------- |
132 | 132 |
# configuration options related to the HTML output |
133 | 133 |
#--------------------------------------------------------------------------- |
134 | 134 |
GENERATE_HTML = YES |
135 | 135 |
HTML_OUTPUT = html |
136 | 136 |
HTML_FILE_EXTENSION = .html |
137 | 137 |
HTML_HEADER = |
138 | 138 |
HTML_FOOTER = |
139 | 139 |
HTML_STYLESHEET = |
140 | 140 |
HTML_ALIGN_MEMBERS = YES |
141 | 141 |
HTML_DYNAMIC_SECTIONS = NO |
142 | 142 |
GENERATE_DOCSET = NO |
143 | 143 |
DOCSET_FEEDNAME = "Doxygen generated docs" |
144 | 144 |
DOCSET_BUNDLE_ID = org.doxygen.Project |
145 | 145 |
GENERATE_HTMLHELP = NO |
146 | 146 |
CHM_FILE = |
147 | 147 |
HHC_LOCATION = |
148 | 148 |
GENERATE_CHI = NO |
149 | 149 |
CHM_INDEX_ENCODING = |
150 | 150 |
BINARY_TOC = NO |
151 | 151 |
TOC_EXPAND = NO |
152 | 152 |
GENERATE_QHP = NO |
153 | 153 |
QCH_FILE = |
154 | 154 |
QHP_NAMESPACE = org.doxygen.Project |
155 | 155 |
QHP_VIRTUAL_FOLDER = doc |
156 | 156 |
QHG_LOCATION = |
157 | 157 |
DISABLE_INDEX = NO |
158 | 158 |
ENUM_VALUES_PER_LINE = 4 |
159 | 159 |
GENERATE_TREEVIEW = NO |
160 | 160 |
TREEVIEW_WIDTH = 250 |
161 | 161 |
FORMULA_FONTSIZE = 10 |
162 | 162 |
#--------------------------------------------------------------------------- |
163 | 163 |
# configuration options related to the LaTeX output |
164 | 164 |
#--------------------------------------------------------------------------- |
165 | 165 |
GENERATE_LATEX = NO |
166 | 166 |
LATEX_OUTPUT = latex |
167 | 167 |
LATEX_CMD_NAME = latex |
168 | 168 |
MAKEINDEX_CMD_NAME = makeindex |
169 | 169 |
COMPACT_LATEX = YES |
170 | 170 |
PAPER_TYPE = a4wide |
171 | 171 |
EXTRA_PACKAGES = amsmath \ |
172 | 172 |
amssymb |
173 | 173 |
LATEX_HEADER = |
174 | 174 |
PDF_HYPERLINKS = YES |
175 | 175 |
USE_PDFLATEX = YES |
176 | 176 |
LATEX_BATCHMODE = NO |
177 | 177 |
LATEX_HIDE_INDICES = NO |
178 | 178 |
#--------------------------------------------------------------------------- |
179 | 179 |
# configuration options related to the RTF output |
180 | 180 |
#--------------------------------------------------------------------------- |
181 | 181 |
GENERATE_RTF = NO |
182 | 182 |
RTF_OUTPUT = rtf |
183 | 183 |
COMPACT_RTF = NO |
184 | 184 |
RTF_HYPERLINKS = NO |
185 | 185 |
RTF_STYLESHEET_FILE = |
186 | 186 |
RTF_EXTENSIONS_FILE = |
187 | 187 |
#--------------------------------------------------------------------------- |
188 | 188 |
# configuration options related to the man page output |
189 | 189 |
#--------------------------------------------------------------------------- |
190 | 190 |
GENERATE_MAN = NO |
191 | 191 |
MAN_OUTPUT = man |
192 | 192 |
MAN_EXTENSION = .3 |
193 | 193 |
MAN_LINKS = NO |
194 | 194 |
#--------------------------------------------------------------------------- |
195 | 195 |
# configuration options related to the XML output |
196 | 196 |
#--------------------------------------------------------------------------- |
197 | 197 |
GENERATE_XML = NO |
198 | 198 |
XML_OUTPUT = xml |
199 | 199 |
XML_SCHEMA = |
200 | 200 |
XML_DTD = |
201 | 201 |
XML_PROGRAMLISTING = YES |
202 | 202 |
#--------------------------------------------------------------------------- |
203 | 203 |
# configuration options for the AutoGen Definitions output |
204 | 204 |
#--------------------------------------------------------------------------- |
205 | 205 |
GENERATE_AUTOGEN_DEF = NO |
206 | 206 |
#--------------------------------------------------------------------------- |
207 | 207 |
# configuration options related to the Perl module output |
208 | 208 |
#--------------------------------------------------------------------------- |
209 | 209 |
GENERATE_PERLMOD = NO |
210 | 210 |
PERLMOD_LATEX = NO |
211 | 211 |
PERLMOD_PRETTY = YES |
212 | 212 |
PERLMOD_MAKEVAR_PREFIX = |
213 | 213 |
#--------------------------------------------------------------------------- |
214 | 214 |
# Configuration options related to the preprocessor |
215 | 215 |
#--------------------------------------------------------------------------- |
216 | 216 |
ENABLE_PREPROCESSING = YES |
217 | 217 |
MACRO_EXPANSION = NO |
218 | 218 |
EXPAND_ONLY_PREDEF = NO |
219 | 219 |
SEARCH_INCLUDES = YES |
220 | 220 |
INCLUDE_PATH = |
221 | 221 |
INCLUDE_FILE_PATTERNS = |
222 | 222 |
PREDEFINED = DOXYGEN |
223 | 223 |
EXPAND_AS_DEFINED = |
224 | 224 |
SKIP_FUNCTION_MACROS = YES |
225 | 225 |
#--------------------------------------------------------------------------- |
226 |
# |
|
226 |
# Options related to the search engine |
|
227 | 227 |
#--------------------------------------------------------------------------- |
228 | 228 |
TAGFILES = "@abs_top_srcdir@/doc/libstdc++.tag = http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/ " |
229 | 229 |
GENERATE_TAGFILE = html/lemon.tag |
230 | 230 |
ALLEXTERNALS = NO |
231 | 231 |
EXTERNAL_GROUPS = NO |
232 | 232 |
PERL_PATH = /usr/bin/perl |
233 | 233 |
#--------------------------------------------------------------------------- |
234 | 234 |
# Configuration options related to the dot tool |
235 | 235 |
#--------------------------------------------------------------------------- |
236 | 236 |
CLASS_DIAGRAMS = YES |
237 | 237 |
MSCGEN_PATH = |
238 | 238 |
HIDE_UNDOC_RELATIONS = YES |
239 | 239 |
HAVE_DOT = YES |
240 | 240 |
DOT_FONTNAME = FreeSans |
241 | 241 |
DOT_FONTSIZE = 10 |
242 | 242 |
DOT_FONTPATH = |
243 | 243 |
CLASS_GRAPH = YES |
244 | 244 |
COLLABORATION_GRAPH = NO |
245 | 245 |
GROUP_GRAPHS = NO |
246 | 246 |
UML_LOOK = NO |
247 | 247 |
TEMPLATE_RELATIONS = NO |
248 | 248 |
INCLUDE_GRAPH = NO |
249 | 249 |
INCLUDED_BY_GRAPH = NO |
250 | 250 |
CALL_GRAPH = NO |
251 | 251 |
CALLER_GRAPH = NO |
252 | 252 |
GRAPHICAL_HIERARCHY = NO |
253 | 253 |
DIRECTORY_GRAPH = NO |
254 | 254 |
DOT_IMAGE_FORMAT = png |
255 | 255 |
DOT_PATH = |
256 | 256 |
DOTFILE_DIRS = |
257 | 257 |
DOT_GRAPH_MAX_NODES = 50 |
258 | 258 |
MAX_DOT_GRAPH_DEPTH = 0 |
259 | 259 |
DOT_TRANSPARENT = NO |
260 | 260 |
DOT_MULTI_TARGETS = NO |
261 | 261 |
GENERATE_LEGEND = YES |
262 | 262 |
DOT_CLEANUP = YES |
263 | 263 |
#--------------------------------------------------------------------------- |
264 | 264 |
# Configuration::additions related to the search engine |
265 | 265 |
#--------------------------------------------------------------------------- |
266 | 266 |
SEARCHENGINE = NO |
1 | 1 |
EXTRA_DIST += \ |
2 | 2 |
doc/Doxyfile.in \ |
3 | 3 |
doc/DoxygenLayout.xml \ |
4 | 4 |
doc/coding_style.dox \ |
5 | 5 |
doc/dirs.dox \ |
6 | 6 |
doc/groups.dox \ |
7 | 7 |
doc/lgf.dox \ |
8 | 8 |
doc/license.dox \ |
9 | 9 |
doc/mainpage.dox \ |
10 | 10 |
doc/migration.dox \ |
11 | 11 |
doc/min_cost_flow.dox \ |
12 | 12 |
doc/named-param.dox \ |
13 | 13 |
doc/namespaces.dox \ |
14 | 14 |
doc/html \ |
15 | 15 |
doc/CMakeLists.txt |
16 | 16 |
|
17 | 17 |
DOC_EPS_IMAGES18 = \ |
18 | 18 |
grid_graph.eps \ |
19 | 19 |
nodeshape_0.eps \ |
20 | 20 |
nodeshape_1.eps \ |
21 | 21 |
nodeshape_2.eps \ |
22 | 22 |
nodeshape_3.eps \ |
23 | 23 |
nodeshape_4.eps |
24 | 24 |
|
25 | 25 |
DOC_EPS_IMAGES27 = \ |
26 | 26 |
bipartite_matching.eps \ |
27 | 27 |
bipartite_partitions.eps \ |
28 | 28 |
connected_components.eps \ |
29 | 29 |
edge_biconnected_components.eps \ |
30 | 30 |
node_biconnected_components.eps \ |
31 | 31 |
strongly_connected_components.eps |
32 | 32 |
|
33 | 33 |
DOC_EPS_IMAGES = \ |
34 | 34 |
$(DOC_EPS_IMAGES18) \ |
35 | 35 |
$(DOC_EPS_IMAGES27) |
36 | 36 |
|
37 | 37 |
DOC_PNG_IMAGES = \ |
38 | 38 |
$(DOC_EPS_IMAGES:%.eps=doc/gen-images/%.png) |
39 | 39 |
|
40 | 40 |
EXTRA_DIST += $(DOC_EPS_IMAGES:%=doc/images/%) |
41 | 41 |
|
42 | 42 |
doc/html: |
43 | 43 |
$(MAKE) $(AM_MAKEFLAGS) html |
44 | 44 |
|
45 | 45 |
GS_COMMAND=gs -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 |
46 | 46 |
|
47 | 47 |
$(DOC_EPS_IMAGES18:%.eps=doc/gen-images/%.png): doc/gen-images/%.png: doc/images/%.eps |
48 | 48 |
-mkdir doc/gen-images |
49 | 49 |
if test ${gs_found} = yes; then \ |
50 | 50 |
$(GS_COMMAND) -sDEVICE=pngalpha -r18 -sOutputFile=$@ $<; \ |
51 | 51 |
else \ |
52 | 52 |
echo; \ |
53 | 53 |
echo "Ghostscript not found."; \ |
54 | 54 |
echo; \ |
55 | 55 |
exit 1; \ |
56 | 56 |
fi |
57 | 57 |
|
58 | 58 |
$(DOC_EPS_IMAGES27:%.eps=doc/gen-images/%.png): doc/gen-images/%.png: doc/images/%.eps |
59 | 59 |
-mkdir doc/gen-images |
60 | 60 |
if test ${gs_found} = yes; then \ |
61 | 61 |
$(GS_COMMAND) -sDEVICE=pngalpha -r27 -sOutputFile=$@ $<; \ |
62 | 62 |
else \ |
63 | 63 |
echo; \ |
64 | 64 |
echo "Ghostscript not found."; \ |
65 | 65 |
echo; \ |
66 | 66 |
exit 1; \ |
67 | 67 |
fi |
68 | 68 |
|
69 |
|
|
69 |
references.dox: doc/references.bib |
|
70 |
if test ${python_found} = yes; then \ |
|
71 |
cd doc; \ |
|
72 |
python @abs_top_srcdir@/scripts/bib2dox.py @abs_top_builddir@/$< >$@; \ |
|
73 |
cd ..; \ |
|
74 |
else \ |
|
75 |
echo; \ |
|
76 |
echo "Python not found."; \ |
|
77 |
echo; \ |
|
78 |
exit 1; \ |
|
79 |
fi |
|
80 |
|
|
81 |
html-local: $(DOC_PNG_IMAGES) references.dox |
|
70 | 82 |
if test ${doxygen_found} = yes; then \ |
71 | 83 |
cd doc; \ |
72 | 84 |
doxygen Doxyfile; \ |
73 | 85 |
cd ..; \ |
74 | 86 |
else \ |
75 | 87 |
echo; \ |
76 | 88 |
echo "Doxygen not found."; \ |
77 | 89 |
echo; \ |
78 | 90 |
exit 1; \ |
79 | 91 |
fi |
80 | 92 |
|
81 | 93 |
clean-local: |
82 | 94 |
-rm -rf doc/html |
83 | 95 |
-rm -f doc/doxygen.log |
84 | 96 |
-rm -f $(DOC_PNG_IMAGES) |
85 | 97 |
-rm -rf doc/gen-images |
86 | 98 |
|
87 | 99 |
update-external-tags: |
88 | 100 |
wget -O doc/libstdc++.tag.tmp http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/libstdc++.tag && \ |
89 | 101 |
mv doc/libstdc++.tag.tmp doc/libstdc++.tag || \ |
90 | 102 |
rm doc/libstdc++.tag.tmp |
91 | 103 |
|
92 | 104 |
install-html-local: doc/html |
93 | 105 |
@$(NORMAL_INSTALL) |
94 | 106 |
$(mkinstalldirs) $(DESTDIR)$(htmldir)/html |
95 | 107 |
for p in doc/html/*.{html,css,png,map,gif,tag} ; do \ |
96 | 108 |
f="`echo $$p | sed -e 's|^.*/||'`"; \ |
97 | 109 |
echo " $(INSTALL_DATA) $$p $(DESTDIR)$(htmldir)/html/$$f"; \ |
98 | 110 |
$(INSTALL_DATA) $$p $(DESTDIR)$(htmldir)/html/$$f; \ |
99 | 111 |
done |
100 | 112 |
|
101 | 113 |
uninstall-local: |
102 | 114 |
@$(NORMAL_UNINSTALL) |
103 | 115 |
for p in doc/html/*.{html,css,png,map,gif,tag} ; do \ |
104 | 116 |
f="`echo $$p | sed -e 's|^.*/||'`"; \ |
105 | 117 |
echo " rm -f $(DESTDIR)$(htmldir)/html/$$f"; \ |
106 | 118 |
rm -f $(DESTDIR)$(htmldir)/html/$$f; \ |
107 | 119 |
done |
108 | 120 |
|
109 | 121 |
.PHONY: update-external-tags |
... | ... |
@@ -37,636 +37,729 @@ |
37 | 37 |
usage of different physical graph implementations. These differences |
38 | 38 |
appear in the size of graph we require to handle, memory or time usage |
39 | 39 |
limitations or in the set of operations through which the graph can be |
40 | 40 |
accessed. LEMON provides several physical graph structures to meet |
41 | 41 |
the diverging requirements of the possible users. In order to save on |
42 | 42 |
running time or on memory usage, some structures may fail to provide |
43 | 43 |
some graph features like arc/edge or node deletion. |
44 | 44 |
|
45 | 45 |
Alteration of standard containers need a very limited number of |
46 | 46 |
operations, these together satisfy the everyday requirements. |
47 | 47 |
In the case of graph structures, different operations are needed which do |
48 | 48 |
not alter the physical graph, but gives another view. If some nodes or |
49 | 49 |
arcs have to be hidden or the reverse oriented graph have to be used, then |
50 | 50 |
this is the case. It also may happen that in a flow implementation |
51 | 51 |
the residual graph can be accessed by another algorithm, or a node-set |
52 | 52 |
is to be shrunk for another algorithm. |
53 | 53 |
LEMON also provides a variety of graphs for these requirements called |
54 | 54 |
\ref graph_adaptors "graph adaptors". Adaptors cannot be used alone but only |
55 | 55 |
in conjunction with other graph representations. |
56 | 56 |
|
57 | 57 |
You are free to use the graph structure that fit your requirements |
58 | 58 |
the best, most graph algorithms and auxiliary data structures can be used |
59 | 59 |
with any graph structure. |
60 | 60 |
|
61 | 61 |
<b>See also:</b> \ref graph_concepts "Graph Structure Concepts". |
62 | 62 |
*/ |
63 | 63 |
|
64 | 64 |
/** |
65 | 65 |
@defgroup graph_adaptors Adaptor Classes for Graphs |
66 | 66 |
@ingroup graphs |
67 | 67 |
\brief Adaptor classes for digraphs and graphs |
68 | 68 |
|
69 | 69 |
This group contains several useful adaptor classes for digraphs and graphs. |
70 | 70 |
|
71 | 71 |
The main parts of LEMON are the different graph structures, generic |
72 | 72 |
graph algorithms, graph concepts, which couple them, and graph |
73 | 73 |
adaptors. While the previous notions are more or less clear, the |
74 | 74 |
latter one needs further explanation. Graph adaptors are graph classes |
75 | 75 |
which serve for considering graph structures in different ways. |
76 | 76 |
|
77 | 77 |
A short example makes this much clearer. Suppose that we have an |
78 | 78 |
instance \c g of a directed graph type, say ListDigraph and an algorithm |
79 | 79 |
\code |
80 | 80 |
template <typename Digraph> |
81 | 81 |
int algorithm(const Digraph&); |
82 | 82 |
\endcode |
83 | 83 |
is needed to run on the reverse oriented graph. It may be expensive |
84 | 84 |
(in time or in memory usage) to copy \c g with the reversed |
85 | 85 |
arcs. In this case, an adaptor class is used, which (according |
86 | 86 |
to LEMON \ref concepts::Digraph "digraph concepts") works as a digraph. |
87 | 87 |
The adaptor uses the original digraph structure and digraph operations when |
88 | 88 |
methods of the reversed oriented graph are called. This means that the adaptor |
89 | 89 |
have minor memory usage, and do not perform sophisticated algorithmic |
90 | 90 |
actions. The purpose of it is to give a tool for the cases when a |
91 | 91 |
graph have to be used in a specific alteration. If this alteration is |
92 | 92 |
obtained by a usual construction like filtering the node or the arc set or |
93 | 93 |
considering a new orientation, then an adaptor is worthwhile to use. |
94 | 94 |
To come back to the reverse oriented graph, in this situation |
95 | 95 |
\code |
96 | 96 |
template<typename Digraph> class ReverseDigraph; |
97 | 97 |
\endcode |
98 | 98 |
template class can be used. The code looks as follows |
99 | 99 |
\code |
100 | 100 |
ListDigraph g; |
101 | 101 |
ReverseDigraph<ListDigraph> rg(g); |
102 | 102 |
int result = algorithm(rg); |
103 | 103 |
\endcode |
104 | 104 |
During running the algorithm, the original digraph \c g is untouched. |
105 | 105 |
This techniques give rise to an elegant code, and based on stable |
106 | 106 |
graph adaptors, complex algorithms can be implemented easily. |
107 | 107 |
|
108 | 108 |
In flow, circulation and matching problems, the residual |
109 | 109 |
graph is of particular importance. Combining an adaptor implementing |
110 | 110 |
this with shortest path algorithms or minimum mean cycle algorithms, |
111 | 111 |
a range of weighted and cardinality optimization algorithms can be |
112 | 112 |
obtained. For other examples, the interested user is referred to the |
113 | 113 |
detailed documentation of particular adaptors. |
114 | 114 |
|
115 | 115 |
The behavior of graph adaptors can be very different. Some of them keep |
116 | 116 |
capabilities of the original graph while in other cases this would be |
117 | 117 |
meaningless. This means that the concepts that they meet depend |
118 | 118 |
on the graph adaptor, and the wrapped graph. |
119 | 119 |
For example, if an arc of a reversed digraph is deleted, this is carried |
120 | 120 |
out by deleting the corresponding arc of the original digraph, thus the |
121 | 121 |
adaptor modifies the original digraph. |
122 | 122 |
However in case of a residual digraph, this operation has no sense. |
123 | 123 |
|
124 | 124 |
Let us stand one more example here to simplify your work. |
125 | 125 |
ReverseDigraph has constructor |
126 | 126 |
\code |
127 | 127 |
ReverseDigraph(Digraph& digraph); |
128 | 128 |
\endcode |
129 | 129 |
This means that in a situation, when a <tt>const %ListDigraph&</tt> |
130 | 130 |
reference to a graph is given, then it have to be instantiated with |
131 | 131 |
<tt>Digraph=const %ListDigraph</tt>. |
132 | 132 |
\code |
133 | 133 |
int algorithm1(const ListDigraph& g) { |
134 | 134 |
ReverseDigraph<const ListDigraph> rg(g); |
135 | 135 |
return algorithm2(rg); |
136 | 136 |
} |
137 | 137 |
\endcode |
138 | 138 |
*/ |
139 | 139 |
|
140 | 140 |
/** |
141 | 141 |
@defgroup maps Maps |
142 | 142 |
@ingroup datas |
143 | 143 |
\brief Map structures implemented in LEMON. |
144 | 144 |
|
145 | 145 |
This group contains the map structures implemented in LEMON. |
146 | 146 |
|
147 | 147 |
LEMON provides several special purpose maps and map adaptors that e.g. combine |
148 | 148 |
new maps from existing ones. |
149 | 149 |
|
150 | 150 |
<b>See also:</b> \ref map_concepts "Map Concepts". |
151 | 151 |
*/ |
152 | 152 |
|
153 | 153 |
/** |
154 | 154 |
@defgroup graph_maps Graph Maps |
155 | 155 |
@ingroup maps |
156 | 156 |
\brief Special graph-related maps. |
157 | 157 |
|
158 | 158 |
This group contains maps that are specifically designed to assign |
159 | 159 |
values to the nodes and arcs/edges of graphs. |
160 | 160 |
|
161 | 161 |
If you are looking for the standard graph maps (\c NodeMap, \c ArcMap, |
162 | 162 |
\c EdgeMap), see the \ref graph_concepts "Graph Structure Concepts". |
163 | 163 |
*/ |
164 | 164 |
|
165 | 165 |
/** |
166 | 166 |
\defgroup map_adaptors Map Adaptors |
167 | 167 |
\ingroup maps |
168 | 168 |
\brief Tools to create new maps from existing ones |
169 | 169 |
|
170 | 170 |
This group contains map adaptors that are used to create "implicit" |
171 | 171 |
maps from other maps. |
172 | 172 |
|
173 | 173 |
Most of them are \ref concepts::ReadMap "read-only maps". |
174 | 174 |
They can make arithmetic and logical operations between one or two maps |
175 | 175 |
(negation, shifting, addition, multiplication, logical 'and', 'or', |
176 | 176 |
'not' etc.) or e.g. convert a map to another one of different Value type. |
177 | 177 |
|
178 | 178 |
The typical usage of this classes is passing implicit maps to |
179 | 179 |
algorithms. If a function type algorithm is called then the function |
180 | 180 |
type map adaptors can be used comfortable. For example let's see the |
181 | 181 |
usage of map adaptors with the \c graphToEps() function. |
182 | 182 |
\code |
183 | 183 |
Color nodeColor(int deg) { |
184 | 184 |
if (deg >= 2) { |
185 | 185 |
return Color(0.5, 0.0, 0.5); |
186 | 186 |
} else if (deg == 1) { |
187 | 187 |
return Color(1.0, 0.5, 1.0); |
188 | 188 |
} else { |
189 | 189 |
return Color(0.0, 0.0, 0.0); |
190 | 190 |
} |
191 | 191 |
} |
192 | 192 |
|
193 | 193 |
Digraph::NodeMap<int> degree_map(graph); |
194 | 194 |
|
195 | 195 |
graphToEps(graph, "graph.eps") |
196 | 196 |
.coords(coords).scaleToA4().undirected() |
197 | 197 |
.nodeColors(composeMap(functorToMap(nodeColor), degree_map)) |
198 | 198 |
.run(); |
199 | 199 |
\endcode |
200 | 200 |
The \c functorToMap() function makes an \c int to \c Color map from the |
201 | 201 |
\c nodeColor() function. The \c composeMap() compose the \c degree_map |
202 | 202 |
and the previously created map. The composed map is a proper function to |
203 | 203 |
get the color of each node. |
204 | 204 |
|
205 | 205 |
The usage with class type algorithms is little bit harder. In this |
206 | 206 |
case the function type map adaptors can not be used, because the |
207 | 207 |
function map adaptors give back temporary objects. |
208 | 208 |
\code |
209 | 209 |
Digraph graph; |
210 | 210 |
|
211 | 211 |
typedef Digraph::ArcMap<double> DoubleArcMap; |
212 | 212 |
DoubleArcMap length(graph); |
213 | 213 |
DoubleArcMap speed(graph); |
214 | 214 |
|
215 | 215 |
typedef DivMap<DoubleArcMap, DoubleArcMap> TimeMap; |
216 | 216 |
TimeMap time(length, speed); |
217 | 217 |
|
218 | 218 |
Dijkstra<Digraph, TimeMap> dijkstra(graph, time); |
219 | 219 |
dijkstra.run(source, target); |
220 | 220 |
\endcode |
221 | 221 |
We have a length map and a maximum speed map on the arcs of a digraph. |
222 | 222 |
The minimum time to pass the arc can be calculated as the division of |
223 | 223 |
the two maps which can be done implicitly with the \c DivMap template |
224 | 224 |
class. We use the implicit minimum time map as the length map of the |
225 | 225 |
\c Dijkstra algorithm. |
226 | 226 |
*/ |
227 | 227 |
|
228 | 228 |
/** |
229 |
@defgroup matrices Matrices |
|
230 |
@ingroup datas |
|
231 |
\brief Two dimensional data storages implemented in LEMON. |
|
232 |
|
|
233 |
This group contains two dimensional data storages implemented in LEMON. |
|
234 |
*/ |
|
235 |
|
|
236 |
/** |
|
237 | 229 |
@defgroup paths Path Structures |
238 | 230 |
@ingroup datas |
239 | 231 |
\brief %Path structures implemented in LEMON. |
240 | 232 |
|
241 | 233 |
This group contains the path structures implemented in LEMON. |
242 | 234 |
|
243 | 235 |
LEMON provides flexible data structures to work with paths. |
244 | 236 |
All of them have similar interfaces and they can be copied easily with |
245 | 237 |
assignment operators and copy constructors. This makes it easy and |
246 | 238 |
efficient to have e.g. the Dijkstra algorithm to store its result in |
247 | 239 |
any kind of path structure. |
248 | 240 |
|
249 |
\sa |
|
241 |
\sa \ref concepts::Path "Path concept" |
|
242 |
*/ |
|
243 |
|
|
244 |
/** |
|
245 |
@defgroup heaps Heap Structures |
|
246 |
@ingroup datas |
|
247 |
\brief %Heap structures implemented in LEMON. |
|
248 |
|
|
249 |
This group contains the heap structures implemented in LEMON. |
|
250 |
|
|
251 |
LEMON provides several heap classes. They are efficient implementations |
|
252 |
of the abstract data type \e priority \e queue. They store items with |
|
253 |
specified values called \e priorities in such a way that finding and |
|
254 |
removing the item with minimum priority are efficient. |
|
255 |
The basic operations are adding and erasing items, changing the priority |
|
256 |
of an item, etc. |
|
257 |
|
|
258 |
Heaps are crucial in several algorithms, such as Dijkstra and Prim. |
|
259 |
The heap implementations have the same interface, thus any of them can be |
|
260 |
used easily in such algorithms. |
|
261 |
|
|
262 |
\sa \ref concepts::Heap "Heap concept" |
|
263 |
*/ |
|
264 |
|
|
265 |
/** |
|
266 |
@defgroup matrices Matrices |
|
267 |
@ingroup datas |
|
268 |
\brief Two dimensional data storages implemented in LEMON. |
|
269 |
|
|
270 |
This group contains two dimensional data storages implemented in LEMON. |
|
250 | 271 |
*/ |
251 | 272 |
|
252 | 273 |
/** |
253 | 274 |
@defgroup auxdat Auxiliary Data Structures |
254 | 275 |
@ingroup datas |
255 | 276 |
\brief Auxiliary data structures implemented in LEMON. |
256 | 277 |
|
257 | 278 |
This group contains some data structures implemented in LEMON in |
258 | 279 |
order to make it easier to implement combinatorial algorithms. |
259 | 280 |
*/ |
260 | 281 |
|
261 | 282 |
/** |
283 |
@defgroup geomdat Geometric Data Structures |
|
284 |
@ingroup auxdat |
|
285 |
\brief Geometric data structures implemented in LEMON. |
|
286 |
|
|
287 |
This group contains geometric data structures implemented in LEMON. |
|
288 |
|
|
289 |
- \ref lemon::dim2::Point "dim2::Point" implements a two dimensional |
|
290 |
vector with the usual operations. |
|
291 |
- \ref lemon::dim2::Box "dim2::Box" can be used to determine the |
|
292 |
rectangular bounding box of a set of \ref lemon::dim2::Point |
|
293 |
"dim2::Point"'s. |
|
294 |
*/ |
|
295 |
|
|
296 |
/** |
|
297 |
@defgroup matrices Matrices |
|
298 |
@ingroup auxdat |
|
299 |
\brief Two dimensional data storages implemented in LEMON. |
|
300 |
|
|
301 |
This group contains two dimensional data storages implemented in LEMON. |
|
302 |
*/ |
|
303 |
|
|
304 |
/** |
|
262 | 305 |
@defgroup algs Algorithms |
263 | 306 |
\brief This group contains the several algorithms |
264 | 307 |
implemented in LEMON. |
265 | 308 |
|
266 | 309 |
This group contains the several algorithms |
267 | 310 |
implemented in LEMON. |
268 | 311 |
*/ |
269 | 312 |
|
270 | 313 |
/** |
271 | 314 |
@defgroup search Graph Search |
272 | 315 |
@ingroup algs |
273 | 316 |
\brief Common graph search algorithms. |
274 | 317 |
|
275 | 318 |
This group contains the common graph search algorithms, namely |
276 |
\e breadth-first \e search (BFS) and \e depth-first \e search (DFS) |
|
319 |
\e breadth-first \e search (BFS) and \e depth-first \e search (DFS) |
|
320 |
\ref clrs01algorithms. |
|
277 | 321 |
*/ |
278 | 322 |
|
279 | 323 |
/** |
280 | 324 |
@defgroup shortest_path Shortest Path Algorithms |
281 | 325 |
@ingroup algs |
282 | 326 |
\brief Algorithms for finding shortest paths. |
283 | 327 |
|
284 |
This group contains the algorithms for finding shortest paths in digraphs |
|
328 |
This group contains the algorithms for finding shortest paths in digraphs |
|
329 |
\ref clrs01algorithms. |
|
285 | 330 |
|
286 | 331 |
- \ref Dijkstra algorithm for finding shortest paths from a source node |
287 | 332 |
when all arc lengths are non-negative. |
288 | 333 |
- \ref BellmanFord "Bellman-Ford" algorithm for finding shortest paths |
289 | 334 |
from a source node when arc lenghts can be either positive or negative, |
290 | 335 |
but the digraph should not contain directed cycles with negative total |
291 | 336 |
length. |
292 | 337 |
- \ref FloydWarshall "Floyd-Warshall" and \ref Johnson "Johnson" algorithms |
293 | 338 |
for solving the \e all-pairs \e shortest \e paths \e problem when arc |
294 | 339 |
lenghts can be either positive or negative, but the digraph should |
295 | 340 |
not contain directed cycles with negative total length. |
296 | 341 |
- \ref Suurballe A successive shortest path algorithm for finding |
297 | 342 |
arc-disjoint paths between two nodes having minimum total length. |
298 | 343 |
*/ |
299 | 344 |
|
300 | 345 |
/** |
346 |
@defgroup spantree Minimum Spanning Tree Algorithms |
|
347 |
@ingroup algs |
|
348 |
\brief Algorithms for finding minimum cost spanning trees and arborescences. |
|
349 |
|
|
350 |
This group contains the algorithms for finding minimum cost spanning |
|
351 |
trees and arborescences \ref clrs01algorithms. |
|
352 |
*/ |
|
353 |
|
|
354 |
/** |
|
301 | 355 |
@defgroup max_flow Maximum Flow Algorithms |
302 | 356 |
@ingroup algs |
303 | 357 |
\brief Algorithms for finding maximum flows. |
304 | 358 |
|
305 | 359 |
This group contains the algorithms for finding maximum flows and |
306 |
feasible circulations. |
|
360 |
feasible circulations \ref clrs01algorithms, \ref amo93networkflows. |
|
307 | 361 |
|
308 | 362 |
The \e maximum \e flow \e problem is to find a flow of maximum value between |
309 | 363 |
a single source and a single target. Formally, there is a \f$G=(V,A)\f$ |
310 | 364 |
digraph, a \f$cap: A\rightarrow\mathbf{R}^+_0\f$ capacity function and |
311 | 365 |
\f$s, t \in V\f$ source and target nodes. |
312 | 366 |
A maximum flow is an \f$f: A\rightarrow\mathbf{R}^+_0\f$ solution of the |
313 | 367 |
following optimization problem. |
314 | 368 |
|
315 | 369 |
\f[ \max\sum_{sv\in A} f(sv) - \sum_{vs\in A} f(vs) \f] |
316 | 370 |
\f[ \sum_{uv\in A} f(uv) = \sum_{vu\in A} f(vu) |
317 | 371 |
\quad \forall u\in V\setminus\{s,t\} \f] |
318 | 372 |
\f[ 0 \leq f(uv) \leq cap(uv) \quad \forall uv\in A \f] |
319 | 373 |
|
320 | 374 |
LEMON contains several algorithms for solving maximum flow problems: |
321 |
- \ref EdmondsKarp Edmonds-Karp algorithm. |
|
322 |
- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm. |
|
323 |
- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees. |
|
324 |
- \ref GoldbergTarjan Preflow push-relabel algorithm with dynamic trees. |
|
375 |
- \ref EdmondsKarp Edmonds-Karp algorithm |
|
376 |
\ref edmondskarp72theoretical. |
|
377 |
- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm |
|
378 |
\ref goldberg88newapproach. |
|
379 |
- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees |
|
380 |
\ref dinic70algorithm, \ref sleator83dynamic. |
|
381 |
- \ref GoldbergTarjan !Preflow push-relabel algorithm with dynamic trees |
|
382 |
\ref goldberg88newapproach, \ref sleator83dynamic. |
|
325 | 383 |
|
326 |
In most cases the \ref Preflow |
|
384 |
In most cases the \ref Preflow algorithm provides the |
|
327 | 385 |
fastest method for computing a maximum flow. All implementations |
328 | 386 |
also provide functions to query the minimum cut, which is the dual |
329 | 387 |
problem of maximum flow. |
330 | 388 |
|
331 | 389 |
\ref Circulation is a preflow push-relabel algorithm implemented directly |
332 | 390 |
for finding feasible circulations, which is a somewhat different problem, |
333 | 391 |
but it is strongly related to maximum flow. |
334 | 392 |
For more information, see \ref Circulation. |
335 | 393 |
*/ |
336 | 394 |
|
337 | 395 |
/** |
338 | 396 |
@defgroup min_cost_flow_algs Minimum Cost Flow Algorithms |
339 | 397 |
@ingroup algs |
340 | 398 |
|
341 | 399 |
\brief Algorithms for finding minimum cost flows and circulations. |
342 | 400 |
|
343 | 401 |
This group contains the algorithms for finding minimum cost flows and |
344 |
circulations. For more information about this problem and its dual |
|
345 |
solution see \ref min_cost_flow "Minimum Cost Flow Problem". |
|
402 |
circulations \ref amo93networkflows. For more information about this |
|
403 |
problem and its dual solution, see \ref min_cost_flow |
|
404 |
"Minimum Cost Flow Problem". |
|
346 | 405 |
|
347 | 406 |
LEMON contains several algorithms for this problem. |
348 | 407 |
- \ref NetworkSimplex Primal Network Simplex algorithm with various |
349 |
pivot strategies. |
|
408 |
pivot strategies \ref dantzig63linearprog, \ref kellyoneill91netsimplex. |
|
350 | 409 |
- \ref CostScaling Push-Relabel and Augment-Relabel algorithms based on |
351 |
cost scaling |
|
410 |
cost scaling \ref goldberg90approximation, \ref goldberg97efficient, |
|
411 |
\ref bunnagel98efficient. |
|
352 | 412 |
- \ref CapacityScaling Successive Shortest %Path algorithm with optional |
353 |
capacity scaling. |
|
354 |
- \ref CancelAndTighten The Cancel and Tighten algorithm. |
|
355 |
|
|
413 |
capacity scaling \ref edmondskarp72theoretical. |
|
414 |
- \ref CancelAndTighten The Cancel and Tighten algorithm |
|
415 |
\ref goldberg89cyclecanceling. |
|
416 |
- \ref CycleCanceling Cycle-Canceling algorithms |
|
417 |
\ref klein67primal, \ref goldberg89cyclecanceling. |
|
356 | 418 |
|
357 | 419 |
In general NetworkSimplex is the most efficient implementation, |
358 | 420 |
but in special cases other algorithms could be faster. |
359 | 421 |
For example, if the total supply and/or capacities are rather small, |
360 | 422 |
CapacityScaling is usually the fastest algorithm (without effective scaling). |
361 | 423 |
*/ |
362 | 424 |
|
363 | 425 |
/** |
364 | 426 |
@defgroup min_cut Minimum Cut Algorithms |
365 | 427 |
@ingroup algs |
366 | 428 |
|
367 | 429 |
\brief Algorithms for finding minimum cut in graphs. |
368 | 430 |
|
369 | 431 |
This group contains the algorithms for finding minimum cut in graphs. |
370 | 432 |
|
371 | 433 |
The \e minimum \e cut \e problem is to find a non-empty and non-complete |
372 | 434 |
\f$X\f$ subset of the nodes with minimum overall capacity on |
373 | 435 |
outgoing arcs. Formally, there is a \f$G=(V,A)\f$ digraph, a |
374 | 436 |
\f$cap: A\rightarrow\mathbf{R}^+_0\f$ capacity function. The minimum |
375 | 437 |
cut is the \f$X\f$ solution of the next optimization problem: |
376 | 438 |
|
377 | 439 |
\f[ \min_{X \subset V, X\not\in \{\emptyset, V\}} |
378 |
\sum_{uv\in A |
|
440 |
\sum_{uv\in A: u\in X, v\not\in X}cap(uv) \f] |
|
379 | 441 |
|
380 | 442 |
LEMON contains several algorithms related to minimum cut problems: |
381 | 443 |
|
382 | 444 |
- \ref HaoOrlin "Hao-Orlin algorithm" for calculating minimum cut |
383 | 445 |
in directed graphs. |
384 | 446 |
- \ref NagamochiIbaraki "Nagamochi-Ibaraki algorithm" for |
385 | 447 |
calculating minimum cut in undirected graphs. |
386 | 448 |
- \ref GomoryHu "Gomory-Hu tree computation" for calculating |
387 | 449 |
all-pairs minimum cut in undirected graphs. |
388 | 450 |
|
389 | 451 |
If you want to find minimum cut just between two distinict nodes, |
390 | 452 |
see the \ref max_flow "maximum flow problem". |
391 | 453 |
*/ |
392 | 454 |
|
393 | 455 |
/** |
394 |
@defgroup |
|
456 |
@defgroup min_mean_cycle Minimum Mean Cycle Algorithms |
|
395 | 457 |
@ingroup algs |
396 |
\brief Algorithms for |
|
458 |
\brief Algorithms for finding minimum mean cycles. |
|
397 | 459 |
|
398 |
This group contains the algorithms for discovering the graph properties |
|
399 |
like connectivity, bipartiteness, euler property, simplicity etc. |
|
460 |
This group contains the algorithms for finding minimum mean cycles |
|
461 |
\ref clrs01algorithms, \ref amo93networkflows. |
|
400 | 462 |
|
401 |
\image html edge_biconnected_components.png |
|
402 |
\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth |
|
403 |
|
|
463 |
The \e minimum \e mean \e cycle \e problem is to find a directed cycle |
|
464 |
of minimum mean length (cost) in a digraph. |
|
465 |
The mean length of a cycle is the average length of its arcs, i.e. the |
|
466 |
ratio between the total length of the cycle and the number of arcs on it. |
|
404 | 467 |
|
405 |
/** |
|
406 |
@defgroup planar Planarity Embedding and Drawing |
|
407 |
@ingroup algs |
|
408 |
\brief Algorithms for planarity checking, embedding and drawing |
|
468 |
This problem has an important connection to \e conservative \e length |
|
469 |
\e functions, too. A length function on the arcs of a digraph is called |
|
470 |
conservative if and only if there is no directed cycle of negative total |
|
471 |
length. For an arbitrary length function, the negative of the minimum |
|
472 |
cycle mean is the smallest \f$\epsilon\f$ value so that increasing the |
|
473 |
arc lengths uniformly by \f$\epsilon\f$ results in a conservative length |
|
474 |
function. |
|
409 | 475 |
|
410 |
This group contains the algorithms for planarity checking, |
|
411 |
embedding and drawing. |
|
476 |
LEMON contains three algorithms for solving the minimum mean cycle problem: |
|
477 |
- \ref Karp "Karp"'s original algorithm \ref amo93networkflows, |
|
478 |
\ref dasdan98minmeancycle. |
|
479 |
- \ref HartmannOrlin "Hartmann-Orlin"'s algorithm, which is an improved |
|
480 |
version of Karp's algorithm \ref dasdan98minmeancycle. |
|
481 |
- \ref Howard "Howard"'s policy iteration algorithm |
|
482 |
\ref dasdan98minmeancycle. |
|
412 | 483 |
|
413 |
\image html planar.png |
|
414 |
\image latex planar.eps "Plane graph" width=\textwidth |
|
484 |
In practice, the Howard algorithm proved to be by far the most efficient |
|
485 |
one, though the best known theoretical bound on its running time is |
|
486 |
exponential. |
|
487 |
Both Karp and HartmannOrlin algorithms run in time O(ne) and use space |
|
488 |
O(n<sup>2</sup>+e), but the latter one is typically faster due to the |
|
489 |
applied early termination scheme. |
|
415 | 490 |
*/ |
416 | 491 |
|
417 | 492 |
/** |
418 | 493 |
@defgroup matching Matching Algorithms |
419 | 494 |
@ingroup algs |
420 | 495 |
\brief Algorithms for finding matchings in graphs and bipartite graphs. |
421 | 496 |
|
422 | 497 |
This group contains the algorithms for calculating |
423 | 498 |
matchings in graphs and bipartite graphs. The general matching problem is |
424 | 499 |
finding a subset of the edges for which each node has at most one incident |
425 | 500 |
edge. |
426 | 501 |
|
427 | 502 |
There are several different algorithms for calculate matchings in |
428 | 503 |
graphs. The matching problems in bipartite graphs are generally |
429 | 504 |
easier than in general graphs. The goal of the matching optimization |
430 | 505 |
can be finding maximum cardinality, maximum weight or minimum cost |
431 | 506 |
matching. The search can be constrained to find perfect or |
432 | 507 |
maximum cardinality matching. |
433 | 508 |
|
434 | 509 |
The matching algorithms implemented in LEMON: |
435 | 510 |
- \ref MaxBipartiteMatching Hopcroft-Karp augmenting path algorithm |
436 | 511 |
for calculating maximum cardinality matching in bipartite graphs. |
437 | 512 |
- \ref PrBipartiteMatching Push-relabel algorithm |
438 | 513 |
for calculating maximum cardinality matching in bipartite graphs. |
439 | 514 |
- \ref MaxWeightedBipartiteMatching |
440 | 515 |
Successive shortest path algorithm for calculating maximum weighted |
441 | 516 |
matching and maximum weighted bipartite matching in bipartite graphs. |
442 | 517 |
- \ref MinCostMaxBipartiteMatching |
443 | 518 |
Successive shortest path algorithm for calculating minimum cost maximum |
444 | 519 |
matching in bipartite graphs. |
445 | 520 |
- \ref MaxMatching Edmond's blossom shrinking algorithm for calculating |
446 | 521 |
maximum cardinality matching in general graphs. |
447 | 522 |
- \ref MaxWeightedMatching Edmond's blossom shrinking algorithm for calculating |
448 | 523 |
maximum weighted matching in general graphs. |
449 | 524 |
- \ref MaxWeightedPerfectMatching |
450 | 525 |
Edmond's blossom shrinking algorithm for calculating maximum weighted |
451 | 526 |
perfect matching in general graphs. |
452 | 527 |
|
453 | 528 |
\image html bipartite_matching.png |
454 | 529 |
\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth |
455 | 530 |
*/ |
456 | 531 |
|
457 | 532 |
/** |
458 |
@defgroup |
|
533 |
@defgroup graph_properties Connectivity and Other Graph Properties |
|
459 | 534 |
@ingroup algs |
460 |
\brief Algorithms for |
|
535 |
\brief Algorithms for discovering the graph properties |
|
461 | 536 |
|
462 |
This group contains the algorithms for finding minimum cost spanning |
|
463 |
trees and arborescences. |
|
537 |
This group contains the algorithms for discovering the graph properties |
|
538 |
like connectivity, bipartiteness, euler property, simplicity etc. |
|
539 |
|
|
540 |
\image html connected_components.png |
|
541 |
\image latex connected_components.eps "Connected components" width=\textwidth |
|
542 |
*/ |
|
543 |
|
|
544 |
/** |
|
545 |
@defgroup planar Planarity Embedding and Drawing |
|
546 |
@ingroup algs |
|
547 |
\brief Algorithms for planarity checking, embedding and drawing |
|
548 |
|
|
549 |
This group contains the algorithms for planarity checking, |
|
550 |
embedding and drawing. |
|
551 |
|
|
552 |
\image html planar.png |
|
553 |
\image latex planar.eps "Plane graph" width=\textwidth |
|
554 |
*/ |
|
555 |
|
|
556 |
/** |
|
557 |
@defgroup approx Approximation Algorithms |
|
558 |
@ingroup algs |
|
559 |
\brief Approximation algorithms. |
|
560 |
|
|
561 |
This group contains the approximation and heuristic algorithms |
|
562 |
implemented in LEMON. |
|
464 | 563 |
*/ |
465 | 564 |
|
466 | 565 |
/** |
467 | 566 |
@defgroup auxalg Auxiliary Algorithms |
468 | 567 |
@ingroup algs |
469 | 568 |
\brief Auxiliary algorithms implemented in LEMON. |
470 | 569 |
|
471 | 570 |
This group contains some algorithms implemented in LEMON |
472 | 571 |
in order to make it easier to implement complex algorithms. |
473 | 572 |
*/ |
474 | 573 |
|
475 | 574 |
/** |
476 |
@defgroup approx Approximation Algorithms |
|
477 |
@ingroup algs |
|
478 |
\brief Approximation algorithms. |
|
479 |
|
|
480 |
This group contains the approximation and heuristic algorithms |
|
481 |
implemented in LEMON. |
|
482 |
*/ |
|
483 |
|
|
484 |
/** |
|
485 | 575 |
@defgroup gen_opt_group General Optimization Tools |
486 | 576 |
\brief This group contains some general optimization frameworks |
487 | 577 |
implemented in LEMON. |
488 | 578 |
|
489 | 579 |
This group contains some general optimization frameworks |
490 | 580 |
implemented in LEMON. |
491 | 581 |
*/ |
492 | 582 |
|
493 | 583 |
/** |
494 |
@defgroup lp_group |
|
584 |
@defgroup lp_group LP and MIP Solvers |
|
495 | 585 |
@ingroup gen_opt_group |
496 |
\brief |
|
586 |
\brief LP and MIP solver interfaces for LEMON. |
|
497 | 587 |
|
498 |
This group contains Lp and Mip solver interfaces for LEMON. The |
|
499 |
various LP solvers could be used in the same manner with this |
|
500 |
|
|
588 |
This group contains LP and MIP solver interfaces for LEMON. |
|
589 |
Various LP solvers could be used in the same manner with this |
|
590 |
high-level interface. |
|
591 |
|
|
592 |
The currently supported solvers are \ref glpk, \ref clp, \ref cbc, |
|
593 |
\ref cplex, \ref soplex. |
|
501 | 594 |
*/ |
502 | 595 |
|
503 | 596 |
/** |
504 | 597 |
@defgroup lp_utils Tools for Lp and Mip Solvers |
505 | 598 |
@ingroup lp_group |
506 | 599 |
\brief Helper tools to the Lp and Mip solvers. |
507 | 600 |
|
508 | 601 |
This group adds some helper tools to general optimization framework |
509 | 602 |
implemented in LEMON. |
510 | 603 |
*/ |
511 | 604 |
|
512 | 605 |
/** |
513 | 606 |
@defgroup metah Metaheuristics |
514 | 607 |
@ingroup gen_opt_group |
515 | 608 |
\brief Metaheuristics for LEMON library. |
516 | 609 |
|
517 | 610 |
This group contains some metaheuristic optimization tools. |
518 | 611 |
*/ |
519 | 612 |
|
520 | 613 |
/** |
521 | 614 |
@defgroup utils Tools and Utilities |
522 | 615 |
\brief Tools and utilities for programming in LEMON |
523 | 616 |
|
524 | 617 |
Tools and utilities for programming in LEMON. |
525 | 618 |
*/ |
526 | 619 |
|
527 | 620 |
/** |
528 | 621 |
@defgroup gutils Basic Graph Utilities |
529 | 622 |
@ingroup utils |
530 | 623 |
\brief Simple basic graph utilities. |
531 | 624 |
|
532 | 625 |
This group contains some simple basic graph utilities. |
533 | 626 |
*/ |
534 | 627 |
|
535 | 628 |
/** |
536 | 629 |
@defgroup misc Miscellaneous Tools |
537 | 630 |
@ingroup utils |
538 | 631 |
\brief Tools for development, debugging and testing. |
539 | 632 |
|
540 | 633 |
This group contains several useful tools for development, |
541 | 634 |
debugging and testing. |
542 | 635 |
*/ |
543 | 636 |
|
544 | 637 |
/** |
545 | 638 |
@defgroup timecount Time Measuring and Counting |
546 | 639 |
@ingroup misc |
547 | 640 |
\brief Simple tools for measuring the performance of algorithms. |
548 | 641 |
|
549 | 642 |
This group contains simple tools for measuring the performance |
550 | 643 |
of algorithms. |
551 | 644 |
*/ |
552 | 645 |
|
553 | 646 |
/** |
554 | 647 |
@defgroup exceptions Exceptions |
555 | 648 |
@ingroup utils |
556 | 649 |
\brief Exceptions defined in LEMON. |
557 | 650 |
|
558 | 651 |
This group contains the exceptions defined in LEMON. |
559 | 652 |
*/ |
560 | 653 |
|
561 | 654 |
/** |
562 | 655 |
@defgroup io_group Input-Output |
563 | 656 |
\brief Graph Input-Output methods |
564 | 657 |
|
565 | 658 |
This group contains the tools for importing and exporting graphs |
566 | 659 |
and graph related data. Now it supports the \ref lgf-format |
567 | 660 |
"LEMON Graph Format", the \c DIMACS format and the encapsulated |
568 | 661 |
postscript (EPS) format. |
569 | 662 |
*/ |
570 | 663 |
|
571 | 664 |
/** |
572 | 665 |
@defgroup lemon_io LEMON Graph Format |
573 | 666 |
@ingroup io_group |
574 | 667 |
\brief Reading and writing LEMON Graph Format. |
575 | 668 |
|
576 | 669 |
This group contains methods for reading and writing |
577 | 670 |
\ref lgf-format "LEMON Graph Format". |
578 | 671 |
*/ |
579 | 672 |
|
580 | 673 |
/** |
581 | 674 |
@defgroup eps_io Postscript Exporting |
582 | 675 |
@ingroup io_group |
583 | 676 |
\brief General \c EPS drawer and graph exporter |
584 | 677 |
|
585 | 678 |
This group contains general \c EPS drawing methods and special |
586 | 679 |
graph exporting tools. |
587 | 680 |
*/ |
588 | 681 |
|
589 | 682 |
/** |
590 |
@defgroup dimacs_group DIMACS |
|
683 |
@defgroup dimacs_group DIMACS Format |
|
591 | 684 |
@ingroup io_group |
592 | 685 |
\brief Read and write files in DIMACS format |
593 | 686 |
|
594 | 687 |
Tools to read a digraph from or write it to a file in DIMACS format data. |
595 | 688 |
*/ |
596 | 689 |
|
597 | 690 |
/** |
598 | 691 |
@defgroup nauty_group NAUTY Format |
599 | 692 |
@ingroup io_group |
600 | 693 |
\brief Read \e Nauty format |
601 | 694 |
|
602 | 695 |
Tool to read graphs from \e Nauty format data. |
603 | 696 |
*/ |
604 | 697 |
|
605 | 698 |
/** |
606 | 699 |
@defgroup concept Concepts |
607 | 700 |
\brief Skeleton classes and concept checking classes |
608 | 701 |
|
609 | 702 |
This group contains the data/algorithm skeletons and concept checking |
610 | 703 |
classes implemented in LEMON. |
611 | 704 |
|
612 | 705 |
The purpose of the classes in this group is fourfold. |
613 | 706 |
|
614 | 707 |
- These classes contain the documentations of the %concepts. In order |
615 | 708 |
to avoid document multiplications, an implementation of a concept |
616 | 709 |
simply refers to the corresponding concept class. |
617 | 710 |
|
618 | 711 |
- These classes declare every functions, <tt>typedef</tt>s etc. an |
619 | 712 |
implementation of the %concepts should provide, however completely |
620 | 713 |
without implementations and real data structures behind the |
621 | 714 |
interface. On the other hand they should provide nothing else. All |
622 | 715 |
the algorithms working on a data structure meeting a certain concept |
623 | 716 |
should compile with these classes. (Though it will not run properly, |
624 | 717 |
of course.) In this way it is easily to check if an algorithm |
625 | 718 |
doesn't use any extra feature of a certain implementation. |
626 | 719 |
|
627 | 720 |
- The concept descriptor classes also provide a <em>checker class</em> |
628 | 721 |
that makes it possible to check whether a certain implementation of a |
629 | 722 |
concept indeed provides all the required features. |
630 | 723 |
|
631 | 724 |
- Finally, They can serve as a skeleton of a new implementation of a concept. |
632 | 725 |
*/ |
633 | 726 |
|
634 | 727 |
/** |
635 | 728 |
@defgroup graph_concepts Graph Structure Concepts |
636 | 729 |
@ingroup concept |
637 | 730 |
\brief Skeleton and concept checking classes for graph structures |
638 | 731 |
|
639 |
This group contains the skeletons and concept checking classes of LEMON's |
|
640 |
graph structures and helper classes used to implement these. |
|
732 |
This group contains the skeletons and concept checking classes of |
|
733 |
graph structures. |
|
641 | 734 |
*/ |
642 | 735 |
|
643 | 736 |
/** |
644 | 737 |
@defgroup map_concepts Map Concepts |
645 | 738 |
@ingroup concept |
646 | 739 |
\brief Skeleton and concept checking classes for maps |
647 | 740 |
|
648 | 741 |
This group contains the skeletons and concept checking classes of maps. |
649 | 742 |
*/ |
650 | 743 |
|
651 | 744 |
/** |
745 |
@defgroup tools Standalone Utility Applications |
|
746 |
|
|
747 |
Some utility applications are listed here. |
|
748 |
|
|
749 |
The standard compilation procedure (<tt>./configure;make</tt>) will compile |
|
750 |
them, as well. |
|
751 |
*/ |
|
752 |
|
|
753 |
/** |
|
652 | 754 |
\anchor demoprograms |
653 | 755 |
|
654 | 756 |
@defgroup demos Demo Programs |
655 | 757 |
|
656 | 758 |
Some demo programs are listed here. Their full source codes can be found in |
657 | 759 |
the \c demo subdirectory of the source tree. |
658 | 760 |
|
659 | 761 |
In order to compile them, use the <tt>make demo</tt> or the |
660 | 762 |
<tt>make check</tt> commands. |
661 | 763 |
*/ |
662 | 764 |
|
663 |
/** |
|
664 |
@defgroup tools Standalone Utility Applications |
|
665 |
|
|
666 |
Some utility applications are listed here. |
|
667 |
|
|
668 |
The standard compilation procedure (<tt>./configure;make</tt>) will compile |
|
669 |
them, as well. |
|
670 |
*/ |
|
671 |
|
|
672 | 765 |
} |
1 | 1 |
/* -*- mode: C++; indent-tabs-mode: nil; -*- |
2 | 2 |
* |
3 | 3 |
* This file is a part of LEMON, a generic C++ optimization library. |
4 | 4 |
* |
5 | 5 |
* Copyright (C) 2003-2009 |
6 | 6 |
* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport |
7 | 7 |
* (Egervary Research Group on Combinatorial Optimization, EGRES). |
8 | 8 |
* |
9 | 9 |
* Permission to use, modify and distribute this software is granted |
10 | 10 |
* provided that this copyright notice appears in all copies. For |
11 | 11 |
* precise terms see the accompanying LICENSE file. |
12 | 12 |
* |
13 | 13 |
* This software is provided "AS IS" with no warranty of any kind, |
14 | 14 |
* express or implied, and with no claim as to its suitability for any |
15 | 15 |
* purpose. |
16 | 16 |
* |
17 | 17 |
*/ |
18 | 18 |
|
19 | 19 |
/** |
20 | 20 |
\mainpage LEMON Documentation |
21 | 21 |
|
22 | 22 |
\section intro Introduction |
23 | 23 |
|
24 |
\subsection whatis What is LEMON |
|
25 |
|
|
26 |
LEMON stands for <b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling |
|
27 |
and <b>O</b>ptimization in <b>N</b>etworks. |
|
28 |
It is a C++ template |
|
29 |
library aimed at combinatorial optimization tasks which |
|
30 |
often involve in working |
|
31 |
with graphs. |
|
24 |
<b>LEMON</b> stands for <i><b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling |
|
25 |
and <b>O</b>ptimization in <b>N</b>etworks</i>. |
|
26 |
It is a C++ template library providing efficient implementation of common |
|
27 |
data structures and algorithms with focus on combinatorial optimization |
|
28 |
problems in graphs and networks. |
|
32 | 29 |
|
33 | 30 |
<b> |
34 | 31 |
LEMON is an <a class="el" href="http://opensource.org/">open source</a> |
35 | 32 |
project. |
36 | 33 |
You are free to use it in your commercial or |
37 | 34 |
non-commercial applications under very permissive |
38 | 35 |
\ref license "license terms". |
39 | 36 |
</b> |
40 | 37 |
|
41 |
|
|
38 |
The project is maintained by the |
|
39 |
<a href="http://www.cs.elte.hu/egres/">Egerváry Research Group on |
|
40 |
Combinatorial Optimization</a> \ref egres |
|
41 |
at the Operations Research Department of the |
|
42 |
<a href="http://www.elte.hu/">Eötvös Loránd University, |
|
43 |
Budapest</a>, Hungary. |
|
44 |
LEMON is also a member of the <a href="http://www.coin-or.org/">COIN-OR</a> |
|
45 |
initiative \ref coinor. |
|
46 |
|
|
47 |
\section howtoread How to Read the Documentation |
|
42 | 48 |
|
43 | 49 |
If you would like to get to know the library, see |
44 | 50 |
<a class="el" href="http://lemon.cs.elte.hu/pub/tutorial/">LEMON Tutorial</a>. |
45 | 51 |
|
46 | 52 |
If you know what you are looking for, then try to find it under the |
47 | 53 |
<a class="el" href="modules.html">Modules</a> section. |
48 | 54 |
|
49 | 55 |
If you are a user of the old (0.x) series of LEMON, please check out the |
50 | 56 |
\ref migration "Migration Guide" for the backward incompatibilities. |
51 | 57 |
*/ |
1 | 1 |
/* -*- mode: C++; indent-tabs-mode: nil; -*- |
2 | 2 |
* |
3 | 3 |
* This file is a part of LEMON, a generic C++ optimization library. |
4 | 4 |
* |
5 | 5 |
* Copyright (C) 2003-2009 |
6 | 6 |
* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport |
7 | 7 |
* (Egervary Research Group on Combinatorial Optimization, EGRES). |
8 | 8 |
* |
9 | 9 |
* Permission to use, modify and distribute this software is granted |
10 | 10 |
* provided that this copyright notice appears in all copies. For |
11 | 11 |
* precise terms see the accompanying LICENSE file. |
12 | 12 |
* |
13 | 13 |
* This software is provided "AS IS" with no warranty of any kind, |
14 | 14 |
* express or implied, and with no claim as to its suitability for any |
15 | 15 |
* purpose. |
16 | 16 |
* |
17 | 17 |
*/ |
18 | 18 |
|
19 | 19 |
namespace lemon { |
20 | 20 |
|
21 | 21 |
/** |
22 | 22 |
\page min_cost_flow Minimum Cost Flow Problem |
23 | 23 |
|
24 | 24 |
\section mcf_def Definition (GEQ form) |
25 | 25 |
|
26 | 26 |
The \e minimum \e cost \e flow \e problem is to find a feasible flow of |
27 | 27 |
minimum total cost from a set of supply nodes to a set of demand nodes |
28 | 28 |
in a network with capacity constraints (lower and upper bounds) |
29 |
and arc costs. |
|
29 |
and arc costs \ref amo93networkflows. |
|
30 | 30 |
|
31 | 31 |
Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$, |
32 | 32 |
\f$upper: A\rightarrow\mathbf{R}\cup\{+\infty\}\f$ denote the lower and |
33 | 33 |
upper bounds for the flow values on the arcs, for which |
34 | 34 |
\f$lower(uv) \leq upper(uv)\f$ must hold for all \f$uv\in A\f$, |
35 | 35 |
\f$cost: A\rightarrow\mathbf{R}\f$ denotes the cost per unit flow |
36 | 36 |
on the arcs and \f$sup: V\rightarrow\mathbf{R}\f$ denotes the |
37 | 37 |
signed supply values of the nodes. |
38 | 38 |
If \f$sup(u)>0\f$, then \f$u\f$ is a supply node with \f$sup(u)\f$ |
39 | 39 |
supply, if \f$sup(u)<0\f$, then \f$u\f$ is a demand node with |
40 | 40 |
\f$-sup(u)\f$ demand. |
41 | 41 |
A minimum cost flow is an \f$f: A\rightarrow\mathbf{R}\f$ solution |
42 | 42 |
of the following optimization problem. |
43 | 43 |
|
44 | 44 |
\f[ \min\sum_{uv\in A} f(uv) \cdot cost(uv) \f] |
45 | 45 |
\f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \geq |
46 | 46 |
sup(u) \quad \forall u\in V \f] |
47 | 47 |
\f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f] |
48 | 48 |
|
49 | 49 |
The sum of the supply values, i.e. \f$\sum_{u\in V} sup(u)\f$ must be |
50 | 50 |
zero or negative in order to have a feasible solution (since the sum |
51 | 51 |
of the expressions on the left-hand side of the inequalities is zero). |
52 | 52 |
It means that the total demand must be greater or equal to the total |
53 | 53 |
supply and all the supplies have to be carried out from the supply nodes, |
54 | 54 |
but there could be demands that are not satisfied. |
55 | 55 |
If \f$\sum_{u\in V} sup(u)\f$ is zero, then all the supply/demand |
56 | 56 |
constraints have to be satisfied with equality, i.e. all demands |
57 | 57 |
have to be satisfied and all supplies have to be used. |
58 | 58 |
|
59 | 59 |
|
60 | 60 |
\section mcf_algs Algorithms |
61 | 61 |
|
62 | 62 |
LEMON contains several algorithms for solving this problem, for more |
63 | 63 |
information see \ref min_cost_flow_algs "Minimum Cost Flow Algorithms". |
64 | 64 |
|
65 | 65 |
A feasible solution for this problem can be found using \ref Circulation. |
66 | 66 |
|
67 | 67 |
|
68 | 68 |
\section mcf_dual Dual Solution |
69 | 69 |
|
70 | 70 |
The dual solution of the minimum cost flow problem is represented by |
71 | 71 |
node potentials \f$\pi: V\rightarrow\mathbf{R}\f$. |
72 | 72 |
An \f$f: A\rightarrow\mathbf{R}\f$ primal feasible solution is optimal |
73 | 73 |
if and only if for some \f$\pi: V\rightarrow\mathbf{R}\f$ node potentials |
74 | 74 |
the following \e complementary \e slackness optimality conditions hold. |
75 | 75 |
|
76 | 76 |
- For all \f$uv\in A\f$ arcs: |
77 | 77 |
- if \f$cost^\pi(uv)>0\f$, then \f$f(uv)=lower(uv)\f$; |
78 | 78 |
- if \f$lower(uv)<f(uv)<upper(uv)\f$, then \f$cost^\pi(uv)=0\f$; |
79 | 79 |
- if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$. |
80 | 80 |
- For all \f$u\in V\f$ nodes: |
81 |
- \f$\pi(u) |
|
81 |
- \f$\pi(u)\leq 0\f$; |
|
82 | 82 |
- if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$, |
83 | 83 |
then \f$\pi(u)=0\f$. |
84 | 84 |
|
85 | 85 |
Here \f$cost^\pi(uv)\f$ denotes the \e reduced \e cost of the arc |
86 | 86 |
\f$uv\in A\f$ with respect to the potential function \f$\pi\f$, i.e. |
87 | 87 |
\f[ cost^\pi(uv) = cost(uv) + \pi(u) - \pi(v).\f] |
88 | 88 |
|
89 | 89 |
All algorithms provide dual solution (node potentials), as well, |
90 | 90 |
if an optimal flow is found. |
91 | 91 |
|
92 | 92 |
|
93 | 93 |
\section mcf_eq Equality Form |
94 | 94 |
|
95 | 95 |
The above \ref mcf_def "definition" is actually more general than the |
96 | 96 |
usual formulation of the minimum cost flow problem, in which strict |
97 | 97 |
equalities are required in the supply/demand contraints. |
98 | 98 |
|
99 | 99 |
\f[ \min\sum_{uv\in A} f(uv) \cdot cost(uv) \f] |
100 | 100 |
\f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) = |
101 | 101 |
sup(u) \quad \forall u\in V \f] |
102 | 102 |
\f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f] |
103 | 103 |
|
104 | 104 |
However if the sum of the supply values is zero, then these two problems |
105 | 105 |
are equivalent. |
106 | 106 |
The \ref min_cost_flow_algs "algorithms" in LEMON support the general |
107 | 107 |
form, so if you need the equality form, you have to ensure this additional |
108 | 108 |
contraint manually. |
109 | 109 |
|
110 | 110 |
|
111 | 111 |
\section mcf_leq Opposite Inequalites (LEQ Form) |
112 | 112 |
|
113 | 113 |
Another possible definition of the minimum cost flow problem is |
114 | 114 |
when there are <em>"less or equal"</em> (LEQ) supply/demand constraints, |
115 | 115 |
instead of the <em>"greater or equal"</em> (GEQ) constraints. |
116 | 116 |
|
117 | 117 |
\f[ \min\sum_{uv\in A} f(uv) \cdot cost(uv) \f] |
118 | 118 |
\f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \leq |
119 | 119 |
sup(u) \quad \forall u\in V \f] |
120 | 120 |
\f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f] |
121 | 121 |
|
122 | 122 |
It means that the total demand must be less or equal to the |
123 | 123 |
total supply (i.e. \f$\sum_{u\in V} sup(u)\f$ must be zero or |
124 | 124 |
positive) and all the demands have to be satisfied, but there |
125 | 125 |
could be supplies that are not carried out from the supply |
126 | 126 |
nodes. |
127 | 127 |
The equality form is also a special case of this form, of course. |
128 | 128 |
|
129 | 129 |
You could easily transform this case to the \ref mcf_def "GEQ form" |
130 | 130 |
of the problem by reversing the direction of the arcs and taking the |
131 | 131 |
negative of the supply values (e.g. using \ref ReverseDigraph and |
132 | 132 |
\ref NegMap adaptors). |
133 | 133 |
However \ref NetworkSimplex algorithm also supports this form directly |
134 | 134 |
for the sake of convenience. |
135 | 135 |
|
136 | 136 |
Note that the optimality conditions for this supply constraint type are |
137 | 137 |
slightly differ from the conditions that are discussed for the GEQ form, |
138 | 138 |
namely the potentials have to be non-negative instead of non-positive. |
139 | 139 |
An \f$f: A\rightarrow\mathbf{R}\f$ feasible solution of this problem |
140 | 140 |
is optimal if and only if for some \f$\pi: V\rightarrow\mathbf{R}\f$ |
141 | 141 |
node potentials the following conditions hold. |
142 | 142 |
|
143 | 143 |
- For all \f$uv\in A\f$ arcs: |
144 | 144 |
- if \f$cost^\pi(uv)>0\f$, then \f$f(uv)=lower(uv)\f$; |
145 | 145 |
- if \f$lower(uv)<f(uv)<upper(uv)\f$, then \f$cost^\pi(uv)=0\f$; |
146 | 146 |
- if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$. |
147 | 147 |
- For all \f$u\in V\f$ nodes: |
148 |
- \f$\pi(u) |
|
148 |
- \f$\pi(u)\geq 0\f$; |
|
149 | 149 |
- if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$, |
150 | 150 |
then \f$\pi(u)=0\f$. |
151 | 151 |
|
152 | 152 |
*/ |
153 | 153 |
} |
1 | 1 |
EXTRA_DIST += \ |
2 | 2 |
lemon/lemon.pc.in \ |
3 | 3 |
lemon/CMakeLists.txt \ |
4 | 4 |
lemon/config.h.cmake |
5 | 5 |
|
6 | 6 |
pkgconfig_DATA += lemon/lemon.pc |
7 | 7 |
|
8 | 8 |
lib_LTLIBRARIES += lemon/libemon.la |
9 | 9 |
|
10 | 10 |
lemon_libemon_la_SOURCES = \ |
11 | 11 |
lemon/arg_parser.cc \ |
12 | 12 |
lemon/base.cc \ |
13 | 13 |
lemon/color.cc \ |
14 | 14 |
lemon/lp_base.cc \ |
15 | 15 |
lemon/lp_skeleton.cc \ |
16 | 16 |
lemon/random.cc \ |
17 | 17 |
lemon/bits/windows.cc |
18 | 18 |
|
19 | 19 |
nodist_lemon_HEADERS = lemon/config.h |
20 | 20 |
|
21 | 21 |
lemon_libemon_la_CXXFLAGS = \ |
22 | 22 |
$(AM_CXXFLAGS) \ |
23 | 23 |
$(GLPK_CFLAGS) \ |
24 | 24 |
$(CPLEX_CFLAGS) \ |
25 | 25 |
$(SOPLEX_CXXFLAGS) \ |
26 | 26 |
$(CLP_CXXFLAGS) \ |
27 | 27 |
$(CBC_CXXFLAGS) |
28 | 28 |
|
29 | 29 |
lemon_libemon_la_LDFLAGS = \ |
30 | 30 |
$(GLPK_LIBS) \ |
31 | 31 |
$(CPLEX_LIBS) \ |
32 | 32 |
$(SOPLEX_LIBS) \ |
33 | 33 |
$(CLP_LIBS) \ |
34 | 34 |
$(CBC_LIBS) |
35 | 35 |
|
36 | 36 |
if HAVE_GLPK |
37 | 37 |
lemon_libemon_la_SOURCES += lemon/glpk.cc |
38 | 38 |
endif |
39 | 39 |
|
40 | 40 |
if HAVE_CPLEX |
41 | 41 |
lemon_libemon_la_SOURCES += lemon/cplex.cc |
42 | 42 |
endif |
43 | 43 |
|
44 | 44 |
if HAVE_SOPLEX |
45 | 45 |
lemon_libemon_la_SOURCES += lemon/soplex.cc |
46 | 46 |
endif |
47 | 47 |
|
48 | 48 |
if HAVE_CLP |
49 | 49 |
lemon_libemon_la_SOURCES += lemon/clp.cc |
50 | 50 |
endif |
51 | 51 |
|
52 | 52 |
if HAVE_CBC |
53 | 53 |
lemon_libemon_la_SOURCES += lemon/cbc.cc |
54 | 54 |
endif |
55 | 55 |
|
56 | 56 |
lemon_HEADERS += \ |
57 | 57 |
lemon/adaptors.h \ |
58 | 58 |
lemon/arg_parser.h \ |
59 | 59 |
lemon/assert.h \ |
60 |
lemon/bellman_ford.h \ |
|
60 | 61 |
lemon/bfs.h \ |
61 | 62 |
lemon/bin_heap.h \ |
63 |
lemon/binom_heap.h \ |
|
62 | 64 |
lemon/bucket_heap.h \ |
63 | 65 |
lemon/cbc.h \ |
64 | 66 |
lemon/circulation.h \ |
65 | 67 |
lemon/clp.h \ |
66 | 68 |
lemon/color.h \ |
67 | 69 |
lemon/concept_check.h \ |
68 | 70 |
lemon/connectivity.h \ |
69 | 71 |
lemon/counter.h \ |
70 | 72 |
lemon/core.h \ |
71 | 73 |
lemon/cplex.h \ |
72 | 74 |
lemon/dfs.h \ |
73 | 75 |
lemon/dijkstra.h \ |
74 | 76 |
lemon/dim2.h \ |
75 | 77 |
lemon/dimacs.h \ |
76 | 78 |
lemon/edge_set.h \ |
77 | 79 |
lemon/elevator.h \ |
78 | 80 |
lemon/error.h \ |
79 | 81 |
lemon/euler.h \ |
80 | 82 |
lemon/fib_heap.h \ |
83 |
lemon/fourary_heap.h \ |
|
81 | 84 |
lemon/full_graph.h \ |
82 | 85 |
lemon/glpk.h \ |
83 | 86 |
lemon/gomory_hu.h \ |
84 | 87 |
lemon/graph_to_eps.h \ |
85 | 88 |
lemon/grid_graph.h \ |
89 |
lemon/hartmann_orlin.h \ |
|
90 |
lemon/howard.h \ |
|
86 | 91 |
lemon/hypercube_graph.h \ |
92 |
lemon/karp.h \ |
|
93 |
lemon/kary_heap.h \ |
|
87 | 94 |
lemon/kruskal.h \ |
88 | 95 |
lemon/hao_orlin.h \ |
89 | 96 |
lemon/lgf_reader.h \ |
90 | 97 |
lemon/lgf_writer.h \ |
91 | 98 |
lemon/list_graph.h \ |
92 | 99 |
lemon/lp.h \ |
93 | 100 |
lemon/lp_base.h \ |
94 | 101 |
lemon/lp_skeleton.h \ |
95 |
lemon/list_graph.h \ |
|
96 | 102 |
lemon/maps.h \ |
97 | 103 |
lemon/matching.h \ |
98 | 104 |
lemon/math.h \ |
99 | 105 |
lemon/min_cost_arborescence.h \ |
100 | 106 |
lemon/nauty_reader.h \ |
101 | 107 |
lemon/network_simplex.h \ |
108 |
lemon/pairing_heap.h \ |
|
102 | 109 |
lemon/path.h \ |
110 |
lemon/planarity.h \ |
|
103 | 111 |
lemon/preflow.h \ |
104 | 112 |
lemon/radix_heap.h \ |
105 | 113 |
lemon/radix_sort.h \ |
106 | 114 |
lemon/random.h \ |
107 | 115 |
lemon/smart_graph.h \ |
108 | 116 |
lemon/soplex.h \ |
117 |
lemon/static_graph.h \ |
|
109 | 118 |
lemon/suurballe.h \ |
110 | 119 |
lemon/time_measure.h \ |
111 | 120 |
lemon/tolerance.h \ |
112 | 121 |
lemon/unionfind.h \ |
113 | 122 |
lemon/bits/windows.h |
114 | 123 |
|
115 | 124 |
bits_HEADERS += \ |
116 | 125 |
lemon/bits/alteration_notifier.h \ |
117 | 126 |
lemon/bits/array_map.h \ |
118 | 127 |
lemon/bits/bezier.h \ |
119 | 128 |
lemon/bits/default_map.h \ |
120 | 129 |
lemon/bits/edge_set_extender.h \ |
121 | 130 |
lemon/bits/enable_if.h \ |
122 | 131 |
lemon/bits/graph_adaptor_extender.h \ |
123 | 132 |
lemon/bits/graph_extender.h \ |
124 | 133 |
lemon/bits/map_extender.h \ |
125 | 134 |
lemon/bits/path_dump.h \ |
126 | 135 |
lemon/bits/solver_bits.h \ |
127 | 136 |
lemon/bits/traits.h \ |
128 | 137 |
lemon/bits/variant.h \ |
129 | 138 |
lemon/bits/vector_map.h |
130 | 139 |
|
131 | 140 |
concept_HEADERS += \ |
132 | 141 |
lemon/concepts/digraph.h \ |
133 | 142 |
lemon/concepts/graph.h \ |
134 | 143 |
lemon/concepts/graph_components.h \ |
135 | 144 |
lemon/concepts/heap.h \ |
136 | 145 |
lemon/concepts/maps.h \ |
137 | 146 |
lemon/concepts/path.h |
... | ... |
@@ -171,743 +171,748 @@ |
171 | 171 |
GraphAdaptorBase(GR& graph) : _graph(&graph) {} |
172 | 172 |
|
173 | 173 |
typedef typename GR::Node Node; |
174 | 174 |
typedef typename GR::Arc Arc; |
175 | 175 |
typedef typename GR::Edge Edge; |
176 | 176 |
|
177 | 177 |
void first(Node& i) const { _graph->first(i); } |
178 | 178 |
void first(Arc& i) const { _graph->first(i); } |
179 | 179 |
void first(Edge& i) const { _graph->first(i); } |
180 | 180 |
void firstIn(Arc& i, const Node& n) const { _graph->firstIn(i, n); } |
181 | 181 |
void firstOut(Arc& i, const Node& n ) const { _graph->firstOut(i, n); } |
182 | 182 |
void firstInc(Edge &i, bool &d, const Node &n) const { |
183 | 183 |
_graph->firstInc(i, d, n); |
184 | 184 |
} |
185 | 185 |
|
186 | 186 |
void next(Node& i) const { _graph->next(i); } |
187 | 187 |
void next(Arc& i) const { _graph->next(i); } |
188 | 188 |
void next(Edge& i) const { _graph->next(i); } |
189 | 189 |
void nextIn(Arc& i) const { _graph->nextIn(i); } |
190 | 190 |
void nextOut(Arc& i) const { _graph->nextOut(i); } |
191 | 191 |
void nextInc(Edge &i, bool &d) const { _graph->nextInc(i, d); } |
192 | 192 |
|
193 | 193 |
Node u(const Edge& e) const { return _graph->u(e); } |
194 | 194 |
Node v(const Edge& e) const { return _graph->v(e); } |
195 | 195 |
|
196 | 196 |
Node source(const Arc& a) const { return _graph->source(a); } |
197 | 197 |
Node target(const Arc& a) const { return _graph->target(a); } |
198 | 198 |
|
199 | 199 |
typedef NodeNumTagIndicator<Graph> NodeNumTag; |
200 | 200 |
int nodeNum() const { return _graph->nodeNum(); } |
201 | 201 |
|
202 | 202 |
typedef ArcNumTagIndicator<Graph> ArcNumTag; |
203 | 203 |
int arcNum() const { return _graph->arcNum(); } |
204 | 204 |
|
205 | 205 |
typedef EdgeNumTagIndicator<Graph> EdgeNumTag; |
206 | 206 |
int edgeNum() const { return _graph->edgeNum(); } |
207 | 207 |
|
208 | 208 |
typedef FindArcTagIndicator<Graph> FindArcTag; |
209 | 209 |
Arc findArc(const Node& u, const Node& v, |
210 | 210 |
const Arc& prev = INVALID) const { |
211 | 211 |
return _graph->findArc(u, v, prev); |
212 | 212 |
} |
213 | 213 |
|
214 | 214 |
typedef FindEdgeTagIndicator<Graph> FindEdgeTag; |
215 | 215 |
Edge findEdge(const Node& u, const Node& v, |
216 | 216 |
const Edge& prev = INVALID) const { |
217 | 217 |
return _graph->findEdge(u, v, prev); |
218 | 218 |
} |
219 | 219 |
|
220 | 220 |
Node addNode() { return _graph->addNode(); } |
221 | 221 |
Edge addEdge(const Node& u, const Node& v) { return _graph->addEdge(u, v); } |
222 | 222 |
|
223 | 223 |
void erase(const Node& i) { _graph->erase(i); } |
224 | 224 |
void erase(const Edge& i) { _graph->erase(i); } |
225 | 225 |
|
226 | 226 |
void clear() { _graph->clear(); } |
227 | 227 |
|
228 | 228 |
bool direction(const Arc& a) const { return _graph->direction(a); } |
229 | 229 |
Arc direct(const Edge& e, bool d) const { return _graph->direct(e, d); } |
230 | 230 |
|
231 | 231 |
int id(const Node& v) const { return _graph->id(v); } |
232 | 232 |
int id(const Arc& a) const { return _graph->id(a); } |
233 | 233 |
int id(const Edge& e) const { return _graph->id(e); } |
234 | 234 |
|
235 | 235 |
Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); } |
236 | 236 |
Arc arcFromId(int ix) const { return _graph->arcFromId(ix); } |
237 | 237 |
Edge edgeFromId(int ix) const { return _graph->edgeFromId(ix); } |
238 | 238 |
|
239 | 239 |
int maxNodeId() const { return _graph->maxNodeId(); } |
240 | 240 |
int maxArcId() const { return _graph->maxArcId(); } |
241 | 241 |
int maxEdgeId() const { return _graph->maxEdgeId(); } |
242 | 242 |
|
243 | 243 |
typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier; |
244 | 244 |
NodeNotifier& notifier(Node) const { return _graph->notifier(Node()); } |
245 | 245 |
|
246 | 246 |
typedef typename ItemSetTraits<GR, Arc>::ItemNotifier ArcNotifier; |
247 | 247 |
ArcNotifier& notifier(Arc) const { return _graph->notifier(Arc()); } |
248 | 248 |
|
249 | 249 |
typedef typename ItemSetTraits<GR, Edge>::ItemNotifier EdgeNotifier; |
250 | 250 |
EdgeNotifier& notifier(Edge) const { return _graph->notifier(Edge()); } |
251 | 251 |
|
252 | 252 |
template <typename V> |
253 | 253 |
class NodeMap : public GR::template NodeMap<V> { |
254 | 254 |
typedef typename GR::template NodeMap<V> Parent; |
255 | 255 |
|
256 | 256 |
public: |
257 | 257 |
explicit NodeMap(const GraphAdaptorBase<GR>& adapter) |
258 | 258 |
: Parent(*adapter._graph) {} |
259 | 259 |
NodeMap(const GraphAdaptorBase<GR>& adapter, const V& value) |
260 | 260 |
: Parent(*adapter._graph, value) {} |
261 | 261 |
|
262 | 262 |
private: |
263 | 263 |
NodeMap& operator=(const NodeMap& cmap) { |
264 | 264 |
return operator=<NodeMap>(cmap); |
265 | 265 |
} |
266 | 266 |
|
267 | 267 |
template <typename CMap> |
268 | 268 |
NodeMap& operator=(const CMap& cmap) { |
269 | 269 |
Parent::operator=(cmap); |
270 | 270 |
return *this; |
271 | 271 |
} |
272 | 272 |
|
273 | 273 |
}; |
274 | 274 |
|
275 | 275 |
template <typename V> |
276 | 276 |
class ArcMap : public GR::template ArcMap<V> { |
277 | 277 |
typedef typename GR::template ArcMap<V> Parent; |
278 | 278 |
|
279 | 279 |
public: |
280 | 280 |
explicit ArcMap(const GraphAdaptorBase<GR>& adapter) |
281 | 281 |
: Parent(*adapter._graph) {} |
282 | 282 |
ArcMap(const GraphAdaptorBase<GR>& adapter, const V& value) |
283 | 283 |
: Parent(*adapter._graph, value) {} |
284 | 284 |
|
285 | 285 |
private: |
286 | 286 |
ArcMap& operator=(const ArcMap& cmap) { |
287 | 287 |
return operator=<ArcMap>(cmap); |
288 | 288 |
} |
289 | 289 |
|
290 | 290 |
template <typename CMap> |
291 | 291 |
ArcMap& operator=(const CMap& cmap) { |
292 | 292 |
Parent::operator=(cmap); |
293 | 293 |
return *this; |
294 | 294 |
} |
295 | 295 |
}; |
296 | 296 |
|
297 | 297 |
template <typename V> |
298 | 298 |
class EdgeMap : public GR::template EdgeMap<V> { |
299 | 299 |
typedef typename GR::template EdgeMap<V> Parent; |
300 | 300 |
|
301 | 301 |
public: |
302 | 302 |
explicit EdgeMap(const GraphAdaptorBase<GR>& adapter) |
303 | 303 |
: Parent(*adapter._graph) {} |
304 | 304 |
EdgeMap(const GraphAdaptorBase<GR>& adapter, const V& value) |
305 | 305 |
: Parent(*adapter._graph, value) {} |
306 | 306 |
|
307 | 307 |
private: |
308 | 308 |
EdgeMap& operator=(const EdgeMap& cmap) { |
309 | 309 |
return operator=<EdgeMap>(cmap); |
310 | 310 |
} |
311 | 311 |
|
312 | 312 |
template <typename CMap> |
313 | 313 |
EdgeMap& operator=(const CMap& cmap) { |
314 | 314 |
Parent::operator=(cmap); |
315 | 315 |
return *this; |
316 | 316 |
} |
317 | 317 |
}; |
318 | 318 |
|
319 | 319 |
}; |
320 | 320 |
|
321 | 321 |
template <typename DGR> |
322 | 322 |
class ReverseDigraphBase : public DigraphAdaptorBase<DGR> { |
323 | 323 |
typedef DigraphAdaptorBase<DGR> Parent; |
324 | 324 |
public: |
325 | 325 |
typedef DGR Digraph; |
326 | 326 |
protected: |
327 | 327 |
ReverseDigraphBase() : Parent() { } |
328 | 328 |
public: |
329 | 329 |
typedef typename Parent::Node Node; |
330 | 330 |
typedef typename Parent::Arc Arc; |
331 | 331 |
|
332 | 332 |
void firstIn(Arc& a, const Node& n) const { Parent::firstOut(a, n); } |
333 | 333 |
void firstOut(Arc& a, const Node& n ) const { Parent::firstIn(a, n); } |
334 | 334 |
|
335 | 335 |
void nextIn(Arc& a) const { Parent::nextOut(a); } |
336 | 336 |
void nextOut(Arc& a) const { Parent::nextIn(a); } |
337 | 337 |
|
338 | 338 |
Node source(const Arc& a) const { return Parent::target(a); } |
339 | 339 |
Node target(const Arc& a) const { return Parent::source(a); } |
340 | 340 |
|
341 | 341 |
Arc addArc(const Node& u, const Node& v) { return Parent::addArc(v, u); } |
342 | 342 |
|
343 | 343 |
typedef FindArcTagIndicator<DGR> FindArcTag; |
344 | 344 |
Arc findArc(const Node& u, const Node& v, |
345 | 345 |
const Arc& prev = INVALID) const { |
346 | 346 |
return Parent::findArc(v, u, prev); |
347 | 347 |
} |
348 | 348 |
|
349 | 349 |
}; |
350 | 350 |
|
351 | 351 |
/// \ingroup graph_adaptors |
352 | 352 |
/// |
353 | 353 |
/// \brief Adaptor class for reversing the orientation of the arcs in |
354 | 354 |
/// a digraph. |
355 | 355 |
/// |
356 | 356 |
/// ReverseDigraph can be used for reversing the arcs in a digraph. |
357 | 357 |
/// It conforms to the \ref concepts::Digraph "Digraph" concept. |
358 | 358 |
/// |
359 | 359 |
/// The adapted digraph can also be modified through this adaptor |
360 | 360 |
/// by adding or removing nodes or arcs, unless the \c GR template |
361 | 361 |
/// parameter is set to be \c const. |
362 | 362 |
/// |
363 |
/// This class provides item counting in the same time as the adapted |
|
364 |
/// digraph structure. |
|
365 |
/// |
|
363 | 366 |
/// \tparam DGR The type of the adapted digraph. |
364 | 367 |
/// It must conform to the \ref concepts::Digraph "Digraph" concept. |
365 | 368 |
/// It can also be specified to be \c const. |
366 | 369 |
/// |
367 | 370 |
/// \note The \c Node and \c Arc types of this adaptor and the adapted |
368 | 371 |
/// digraph are convertible to each other. |
369 | 372 |
template<typename DGR> |
370 | 373 |
#ifdef DOXYGEN |
371 | 374 |
class ReverseDigraph { |
372 | 375 |
#else |
373 | 376 |
class ReverseDigraph : |
374 | 377 |
public DigraphAdaptorExtender<ReverseDigraphBase<DGR> > { |
375 | 378 |
#endif |
376 | 379 |
typedef DigraphAdaptorExtender<ReverseDigraphBase<DGR> > Parent; |
377 | 380 |
public: |
378 | 381 |
/// The type of the adapted digraph. |
379 | 382 |
typedef DGR Digraph; |
380 | 383 |
protected: |
381 | 384 |
ReverseDigraph() { } |
382 | 385 |
public: |
383 | 386 |
|
384 | 387 |
/// \brief Constructor |
385 | 388 |
/// |
386 | 389 |
/// Creates a reverse digraph adaptor for the given digraph. |
387 | 390 |
explicit ReverseDigraph(DGR& digraph) { |
388 | 391 |
Parent::initialize(digraph); |
389 | 392 |
} |
390 | 393 |
}; |
391 | 394 |
|
392 | 395 |
/// \brief Returns a read-only ReverseDigraph adaptor |
393 | 396 |
/// |
394 | 397 |
/// This function just returns a read-only \ref ReverseDigraph adaptor. |
395 | 398 |
/// \ingroup graph_adaptors |
396 | 399 |
/// \relates ReverseDigraph |
397 | 400 |
template<typename DGR> |
398 | 401 |
ReverseDigraph<const DGR> reverseDigraph(const DGR& digraph) { |
399 | 402 |
return ReverseDigraph<const DGR>(digraph); |
400 | 403 |
} |
401 | 404 |
|
402 | 405 |
|
403 | 406 |
template <typename DGR, typename NF, typename AF, bool ch = true> |
404 | 407 |
class SubDigraphBase : public DigraphAdaptorBase<DGR> { |
405 | 408 |
typedef DigraphAdaptorBase<DGR> Parent; |
406 | 409 |
public: |
407 | 410 |
typedef DGR Digraph; |
408 | 411 |
typedef NF NodeFilterMap; |
409 | 412 |
typedef AF ArcFilterMap; |
410 | 413 |
|
411 | 414 |
typedef SubDigraphBase Adaptor; |
412 | 415 |
protected: |
413 | 416 |
NF* _node_filter; |
414 | 417 |
AF* _arc_filter; |
415 | 418 |
SubDigraphBase() |
416 | 419 |
: Parent(), _node_filter(0), _arc_filter(0) { } |
417 | 420 |
|
418 | 421 |
void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) { |
419 | 422 |
Parent::initialize(digraph); |
420 | 423 |
_node_filter = &node_filter; |
421 | 424 |
_arc_filter = &arc_filter; |
422 | 425 |
} |
423 | 426 |
|
424 | 427 |
public: |
425 | 428 |
|
426 | 429 |
typedef typename Parent::Node Node; |
427 | 430 |
typedef typename Parent::Arc Arc; |
428 | 431 |
|
429 | 432 |
void first(Node& i) const { |
430 | 433 |
Parent::first(i); |
431 | 434 |
while (i != INVALID && !(*_node_filter)[i]) Parent::next(i); |
432 | 435 |
} |
433 | 436 |
|
434 | 437 |
void first(Arc& i) const { |
435 | 438 |
Parent::first(i); |
436 | 439 |
while (i != INVALID && (!(*_arc_filter)[i] |
437 | 440 |
|| !(*_node_filter)[Parent::source(i)] |
438 | 441 |
|| !(*_node_filter)[Parent::target(i)])) |
439 | 442 |
Parent::next(i); |
440 | 443 |
} |
441 | 444 |
|
442 | 445 |
void firstIn(Arc& i, const Node& n) const { |
443 | 446 |
Parent::firstIn(i, n); |
444 | 447 |
while (i != INVALID && (!(*_arc_filter)[i] |
445 | 448 |
|| !(*_node_filter)[Parent::source(i)])) |
446 | 449 |
Parent::nextIn(i); |
447 | 450 |
} |
448 | 451 |
|
449 | 452 |
void firstOut(Arc& i, const Node& n) const { |
450 | 453 |
Parent::firstOut(i, n); |
451 | 454 |
while (i != INVALID && (!(*_arc_filter)[i] |
452 | 455 |
|| !(*_node_filter)[Parent::target(i)])) |
453 | 456 |
Parent::nextOut(i); |
454 | 457 |
} |
455 | 458 |
|
456 | 459 |
void next(Node& i) const { |
457 | 460 |
Parent::next(i); |
458 | 461 |
while (i != INVALID && !(*_node_filter)[i]) Parent::next(i); |
459 | 462 |
} |
460 | 463 |
|
461 | 464 |
void next(Arc& i) const { |
462 | 465 |
Parent::next(i); |
463 | 466 |
while (i != INVALID && (!(*_arc_filter)[i] |
464 | 467 |
|| !(*_node_filter)[Parent::source(i)] |
465 | 468 |
|| !(*_node_filter)[Parent::target(i)])) |
466 | 469 |
Parent::next(i); |
467 | 470 |
} |
468 | 471 |
|
469 | 472 |
void nextIn(Arc& i) const { |
470 | 473 |
Parent::nextIn(i); |
471 | 474 |
while (i != INVALID && (!(*_arc_filter)[i] |
472 | 475 |
|| !(*_node_filter)[Parent::source(i)])) |
473 | 476 |
Parent::nextIn(i); |
474 | 477 |
} |
475 | 478 |
|
476 | 479 |
void nextOut(Arc& i) const { |
477 | 480 |
Parent::nextOut(i); |
478 | 481 |
while (i != INVALID && (!(*_arc_filter)[i] |
479 | 482 |
|| !(*_node_filter)[Parent::target(i)])) |
480 | 483 |
Parent::nextOut(i); |
481 | 484 |
} |
482 | 485 |
|
483 | 486 |
void status(const Node& n, bool v) const { _node_filter->set(n, v); } |
484 | 487 |
void status(const Arc& a, bool v) const { _arc_filter->set(a, v); } |
485 | 488 |
|
486 | 489 |
bool status(const Node& n) const { return (*_node_filter)[n]; } |
487 | 490 |
bool status(const Arc& a) const { return (*_arc_filter)[a]; } |
488 | 491 |
|
489 | 492 |
typedef False NodeNumTag; |
490 | 493 |
typedef False ArcNumTag; |
491 | 494 |
|
492 | 495 |
typedef FindArcTagIndicator<DGR> FindArcTag; |
493 | 496 |
Arc findArc(const Node& source, const Node& target, |
494 | 497 |
const Arc& prev = INVALID) const { |
495 | 498 |
if (!(*_node_filter)[source] || !(*_node_filter)[target]) { |
496 | 499 |
return INVALID; |
497 | 500 |
} |
498 | 501 |
Arc arc = Parent::findArc(source, target, prev); |
499 | 502 |
while (arc != INVALID && !(*_arc_filter)[arc]) { |
500 | 503 |
arc = Parent::findArc(source, target, arc); |
501 | 504 |
} |
502 | 505 |
return arc; |
503 | 506 |
} |
504 | 507 |
|
505 | 508 |
public: |
506 | 509 |
|
507 | 510 |
template <typename V> |
508 | 511 |
class NodeMap |
509 | 512 |
: public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>, |
510 | 513 |
LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> { |
511 | 514 |
typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>, |
512 | 515 |
LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent; |
513 | 516 |
|
514 | 517 |
public: |
515 | 518 |
typedef V Value; |
516 | 519 |
|
517 | 520 |
NodeMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor) |
518 | 521 |
: Parent(adaptor) {} |
519 | 522 |
NodeMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor, const V& value) |
520 | 523 |
: Parent(adaptor, value) {} |
521 | 524 |
|
522 | 525 |
private: |
523 | 526 |
NodeMap& operator=(const NodeMap& cmap) { |
524 | 527 |
return operator=<NodeMap>(cmap); |
525 | 528 |
} |
526 | 529 |
|
527 | 530 |
template <typename CMap> |
528 | 531 |
NodeMap& operator=(const CMap& cmap) { |
529 | 532 |
Parent::operator=(cmap); |
530 | 533 |
return *this; |
531 | 534 |
} |
532 | 535 |
}; |
533 | 536 |
|
534 | 537 |
template <typename V> |
535 | 538 |
class ArcMap |
536 | 539 |
: public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>, |
537 | 540 |
LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> { |
538 | 541 |
typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>, |
539 | 542 |
LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent; |
540 | 543 |
|
541 | 544 |
public: |
542 | 545 |
typedef V Value; |
543 | 546 |
|
544 | 547 |
ArcMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor) |
545 | 548 |
: Parent(adaptor) {} |
546 | 549 |
ArcMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor, const V& value) |
547 | 550 |
: Parent(adaptor, value) {} |
548 | 551 |
|
549 | 552 |
private: |
550 | 553 |
ArcMap& operator=(const ArcMap& cmap) { |
551 | 554 |
return operator=<ArcMap>(cmap); |
552 | 555 |
} |
553 | 556 |
|
554 | 557 |
template <typename CMap> |
555 | 558 |
ArcMap& operator=(const CMap& cmap) { |
556 | 559 |
Parent::operator=(cmap); |
557 | 560 |
return *this; |
558 | 561 |
} |
559 | 562 |
}; |
560 | 563 |
|
561 | 564 |
}; |
562 | 565 |
|
563 | 566 |
template <typename DGR, typename NF, typename AF> |
564 | 567 |
class SubDigraphBase<DGR, NF, AF, false> |
565 | 568 |
: public DigraphAdaptorBase<DGR> { |
566 | 569 |
typedef DigraphAdaptorBase<DGR> Parent; |
567 | 570 |
public: |
568 | 571 |
typedef DGR Digraph; |
569 | 572 |
typedef NF NodeFilterMap; |
570 | 573 |
typedef AF ArcFilterMap; |
571 | 574 |
|
572 | 575 |
typedef SubDigraphBase Adaptor; |
573 | 576 |
protected: |
574 | 577 |
NF* _node_filter; |
575 | 578 |
AF* _arc_filter; |
576 | 579 |
SubDigraphBase() |
577 | 580 |
: Parent(), _node_filter(0), _arc_filter(0) { } |
578 | 581 |
|
579 | 582 |
void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) { |
580 | 583 |
Parent::initialize(digraph); |
581 | 584 |
_node_filter = &node_filter; |
582 | 585 |
_arc_filter = &arc_filter; |
583 | 586 |
} |
584 | 587 |
|
585 | 588 |
public: |
586 | 589 |
|
587 | 590 |
typedef typename Parent::Node Node; |
588 | 591 |
typedef typename Parent::Arc Arc; |
589 | 592 |
|
590 | 593 |
void first(Node& i) const { |
591 | 594 |
Parent::first(i); |
592 | 595 |
while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i); |
593 | 596 |
} |
594 | 597 |
|
595 | 598 |
void first(Arc& i) const { |
596 | 599 |
Parent::first(i); |
597 | 600 |
while (i!=INVALID && !(*_arc_filter)[i]) Parent::next(i); |
598 | 601 |
} |
599 | 602 |
|
600 | 603 |
void firstIn(Arc& i, const Node& n) const { |
601 | 604 |
Parent::firstIn(i, n); |
602 | 605 |
while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextIn(i); |
603 | 606 |
} |
604 | 607 |
|
605 | 608 |
void firstOut(Arc& i, const Node& n) const { |
606 | 609 |
Parent::firstOut(i, n); |
607 | 610 |
while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextOut(i); |
608 | 611 |
} |
609 | 612 |
|
610 | 613 |
void next(Node& i) const { |
611 | 614 |
Parent::next(i); |
612 | 615 |
while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i); |
613 | 616 |
} |
614 | 617 |
void next(Arc& i) const { |
615 | 618 |
Parent::next(i); |
616 | 619 |
while (i!=INVALID && !(*_arc_filter)[i]) Parent::next(i); |
617 | 620 |
} |
618 | 621 |
void nextIn(Arc& i) const { |
619 | 622 |
Parent::nextIn(i); |
620 | 623 |
while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextIn(i); |
621 | 624 |
} |
622 | 625 |
|
623 | 626 |
void nextOut(Arc& i) const { |
624 | 627 |
Parent::nextOut(i); |
625 | 628 |
while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextOut(i); |
626 | 629 |
} |
627 | 630 |
|
628 | 631 |
void status(const Node& n, bool v) const { _node_filter->set(n, v); } |
629 | 632 |
void status(const Arc& a, bool v) const { _arc_filter->set(a, v); } |
630 | 633 |
|
631 | 634 |
bool status(const Node& n) const { return (*_node_filter)[n]; } |
632 | 635 |
bool status(const Arc& a) const { return (*_arc_filter)[a]; } |
633 | 636 |
|
634 | 637 |
typedef False NodeNumTag; |
635 | 638 |
typedef False ArcNumTag; |
636 | 639 |
|
637 | 640 |
typedef FindArcTagIndicator<DGR> FindArcTag; |
638 | 641 |
Arc findArc(const Node& source, const Node& target, |
639 | 642 |
const Arc& prev = INVALID) const { |
640 | 643 |
if (!(*_node_filter)[source] || !(*_node_filter)[target]) { |
641 | 644 |
return INVALID; |
642 | 645 |
} |
643 | 646 |
Arc arc = Parent::findArc(source, target, prev); |
644 | 647 |
while (arc != INVALID && !(*_arc_filter)[arc]) { |
645 | 648 |
arc = Parent::findArc(source, target, arc); |
646 | 649 |
} |
647 | 650 |
return arc; |
648 | 651 |
} |
649 | 652 |
|
650 | 653 |
template <typename V> |
651 | 654 |
class NodeMap |
652 | 655 |
: public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>, |
653 | 656 |
LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> { |
654 | 657 |
typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>, |
655 | 658 |
LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent; |
656 | 659 |
|
657 | 660 |
public: |
658 | 661 |
typedef V Value; |
659 | 662 |
|
660 | 663 |
NodeMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor) |
661 | 664 |
: Parent(adaptor) {} |
662 | 665 |
NodeMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor, const V& value) |
663 | 666 |
: Parent(adaptor, value) {} |
664 | 667 |
|
665 | 668 |
private: |
666 | 669 |
NodeMap& operator=(const NodeMap& cmap) { |
667 | 670 |
return operator=<NodeMap>(cmap); |
668 | 671 |
} |
669 | 672 |
|
670 | 673 |
template <typename CMap> |
671 | 674 |
NodeMap& operator=(const CMap& cmap) { |
672 | 675 |
Parent::operator=(cmap); |
673 | 676 |
return *this; |
674 | 677 |
} |
675 | 678 |
}; |
676 | 679 |
|
677 | 680 |
template <typename V> |
678 | 681 |
class ArcMap |
679 | 682 |
: public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>, |
680 | 683 |
LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> { |
681 | 684 |
typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>, |
682 | 685 |
LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent; |
683 | 686 |
|
684 | 687 |
public: |
685 | 688 |
typedef V Value; |
686 | 689 |
|
687 | 690 |
ArcMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor) |
688 | 691 |
: Parent(adaptor) {} |
689 | 692 |
ArcMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor, const V& value) |
690 | 693 |
: Parent(adaptor, value) {} |
691 | 694 |
|
692 | 695 |
private: |
693 | 696 |
ArcMap& operator=(const ArcMap& cmap) { |
694 | 697 |
return operator=<ArcMap>(cmap); |
695 | 698 |
} |
696 | 699 |
|
697 | 700 |
template <typename CMap> |
698 | 701 |
ArcMap& operator=(const CMap& cmap) { |
699 | 702 |
Parent::operator=(cmap); |
700 | 703 |
return *this; |
701 | 704 |
} |
702 | 705 |
}; |
703 | 706 |
|
704 | 707 |
}; |
705 | 708 |
|
706 | 709 |
/// \ingroup graph_adaptors |
707 | 710 |
/// |
708 | 711 |
/// \brief Adaptor class for hiding nodes and arcs in a digraph |
709 | 712 |
/// |
710 | 713 |
/// SubDigraph can be used for hiding nodes and arcs in a digraph. |
711 | 714 |
/// A \c bool node map and a \c bool arc map must be specified, which |
712 | 715 |
/// define the filters for nodes and arcs. |
713 | 716 |
/// Only the nodes and arcs with \c true filter value are |
714 | 717 |
/// shown in the subdigraph. The arcs that are incident to hidden |
715 | 718 |
/// nodes are also filtered out. |
716 | 719 |
/// This adaptor conforms to the \ref concepts::Digraph "Digraph" concept. |
717 | 720 |
/// |
718 | 721 |
/// The adapted digraph can also be modified through this adaptor |
719 | 722 |
/// by adding or removing nodes or arcs, unless the \c GR template |
720 | 723 |
/// parameter is set to be \c const. |
721 | 724 |
/// |
725 |
/// This class provides only linear time counting for nodes and arcs. |
|
726 |
/// |
|
722 | 727 |
/// \tparam DGR The type of the adapted digraph. |
723 | 728 |
/// It must conform to the \ref concepts::Digraph "Digraph" concept. |
724 | 729 |
/// It can also be specified to be \c const. |
725 | 730 |
/// \tparam NF The type of the node filter map. |
726 | 731 |
/// It must be a \c bool (or convertible) node map of the |
727 | 732 |
/// adapted digraph. The default type is |
728 | 733 |
/// \ref concepts::Digraph::NodeMap "DGR::NodeMap<bool>". |
729 | 734 |
/// \tparam AF The type of the arc filter map. |
730 | 735 |
/// It must be \c bool (or convertible) arc map of the |
731 | 736 |
/// adapted digraph. The default type is |
732 | 737 |
/// \ref concepts::Digraph::ArcMap "DGR::ArcMap<bool>". |
733 | 738 |
/// |
734 | 739 |
/// \note The \c Node and \c Arc types of this adaptor and the adapted |
735 | 740 |
/// digraph are convertible to each other. |
736 | 741 |
/// |
737 | 742 |
/// \see FilterNodes |
738 | 743 |
/// \see FilterArcs |
739 | 744 |
#ifdef DOXYGEN |
740 | 745 |
template<typename DGR, typename NF, typename AF> |
741 | 746 |
class SubDigraph { |
742 | 747 |
#else |
743 | 748 |
template<typename DGR, |
744 | 749 |
typename NF = typename DGR::template NodeMap<bool>, |
745 | 750 |
typename AF = typename DGR::template ArcMap<bool> > |
746 | 751 |
class SubDigraph : |
747 | 752 |
public DigraphAdaptorExtender<SubDigraphBase<DGR, NF, AF, true> > { |
748 | 753 |
#endif |
749 | 754 |
public: |
750 | 755 |
/// The type of the adapted digraph. |
751 | 756 |
typedef DGR Digraph; |
752 | 757 |
/// The type of the node filter map. |
753 | 758 |
typedef NF NodeFilterMap; |
754 | 759 |
/// The type of the arc filter map. |
755 | 760 |
typedef AF ArcFilterMap; |
756 | 761 |
|
757 | 762 |
typedef DigraphAdaptorExtender<SubDigraphBase<DGR, NF, AF, true> > |
758 | 763 |
Parent; |
759 | 764 |
|
760 | 765 |
typedef typename Parent::Node Node; |
761 | 766 |
typedef typename Parent::Arc Arc; |
762 | 767 |
|
763 | 768 |
protected: |
764 | 769 |
SubDigraph() { } |
765 | 770 |
public: |
766 | 771 |
|
767 | 772 |
/// \brief Constructor |
768 | 773 |
/// |
769 | 774 |
/// Creates a subdigraph for the given digraph with the |
770 | 775 |
/// given node and arc filter maps. |
771 | 776 |
SubDigraph(DGR& digraph, NF& node_filter, AF& arc_filter) { |
772 | 777 |
Parent::initialize(digraph, node_filter, arc_filter); |
773 | 778 |
} |
774 | 779 |
|
775 | 780 |
/// \brief Sets the status of the given node |
776 | 781 |
/// |
777 | 782 |
/// This function sets the status of the given node. |
778 | 783 |
/// It is done by simply setting the assigned value of \c n |
779 | 784 |
/// to \c v in the node filter map. |
780 | 785 |
void status(const Node& n, bool v) const { Parent::status(n, v); } |
781 | 786 |
|
782 | 787 |
/// \brief Sets the status of the given arc |
783 | 788 |
/// |
784 | 789 |
/// This function sets the status of the given arc. |
785 | 790 |
/// It is done by simply setting the assigned value of \c a |
786 | 791 |
/// to \c v in the arc filter map. |
787 | 792 |
void status(const Arc& a, bool v) const { Parent::status(a, v); } |
788 | 793 |
|
789 | 794 |
/// \brief Returns the status of the given node |
790 | 795 |
/// |
791 | 796 |
/// This function returns the status of the given node. |
792 | 797 |
/// It is \c true if the given node is enabled (i.e. not hidden). |
793 | 798 |
bool status(const Node& n) const { return Parent::status(n); } |
794 | 799 |
|
795 | 800 |
/// \brief Returns the status of the given arc |
796 | 801 |
/// |
797 | 802 |
/// This function returns the status of the given arc. |
798 | 803 |
/// It is \c true if the given arc is enabled (i.e. not hidden). |
799 | 804 |
bool status(const Arc& a) const { return Parent::status(a); } |
800 | 805 |
|
801 | 806 |
/// \brief Disables the given node |
802 | 807 |
/// |
803 | 808 |
/// This function disables the given node in the subdigraph, |
804 | 809 |
/// so the iteration jumps over it. |
805 | 810 |
/// It is the same as \ref status() "status(n, false)". |
806 | 811 |
void disable(const Node& n) const { Parent::status(n, false); } |
807 | 812 |
|
808 | 813 |
/// \brief Disables the given arc |
809 | 814 |
/// |
810 | 815 |
/// This function disables the given arc in the subdigraph, |
811 | 816 |
/// so the iteration jumps over it. |
812 | 817 |
/// It is the same as \ref status() "status(a, false)". |
813 | 818 |
void disable(const Arc& a) const { Parent::status(a, false); } |
814 | 819 |
|
815 | 820 |
/// \brief Enables the given node |
816 | 821 |
/// |
817 | 822 |
/// This function enables the given node in the subdigraph. |
818 | 823 |
/// It is the same as \ref status() "status(n, true)". |
819 | 824 |
void enable(const Node& n) const { Parent::status(n, true); } |
820 | 825 |
|
821 | 826 |
/// \brief Enables the given arc |
822 | 827 |
/// |
823 | 828 |
/// This function enables the given arc in the subdigraph. |
824 | 829 |
/// It is the same as \ref status() "status(a, true)". |
825 | 830 |
void enable(const Arc& a) const { Parent::status(a, true); } |
826 | 831 |
|
827 | 832 |
}; |
828 | 833 |
|
829 | 834 |
/// \brief Returns a read-only SubDigraph adaptor |
830 | 835 |
/// |
831 | 836 |
/// This function just returns a read-only \ref SubDigraph adaptor. |
832 | 837 |
/// \ingroup graph_adaptors |
833 | 838 |
/// \relates SubDigraph |
834 | 839 |
template<typename DGR, typename NF, typename AF> |
835 | 840 |
SubDigraph<const DGR, NF, AF> |
836 | 841 |
subDigraph(const DGR& digraph, |
837 | 842 |
NF& node_filter, AF& arc_filter) { |
838 | 843 |
return SubDigraph<const DGR, NF, AF> |
839 | 844 |
(digraph, node_filter, arc_filter); |
840 | 845 |
} |
841 | 846 |
|
842 | 847 |
template<typename DGR, typename NF, typename AF> |
843 | 848 |
SubDigraph<const DGR, const NF, AF> |
844 | 849 |
subDigraph(const DGR& digraph, |
845 | 850 |
const NF& node_filter, AF& arc_filter) { |
846 | 851 |
return SubDigraph<const DGR, const NF, AF> |
847 | 852 |
(digraph, node_filter, arc_filter); |
848 | 853 |
} |
849 | 854 |
|
850 | 855 |
template<typename DGR, typename NF, typename AF> |
851 | 856 |
SubDigraph<const DGR, NF, const AF> |
852 | 857 |
subDigraph(const DGR& digraph, |
853 | 858 |
NF& node_filter, const AF& arc_filter) { |
854 | 859 |
return SubDigraph<const DGR, NF, const AF> |
855 | 860 |
(digraph, node_filter, arc_filter); |
856 | 861 |
} |
857 | 862 |
|
858 | 863 |
template<typename DGR, typename NF, typename AF> |
859 | 864 |
SubDigraph<const DGR, const NF, const AF> |
860 | 865 |
subDigraph(const DGR& digraph, |
861 | 866 |
const NF& node_filter, const AF& arc_filter) { |
862 | 867 |
return SubDigraph<const DGR, const NF, const AF> |
863 | 868 |
(digraph, node_filter, arc_filter); |
864 | 869 |
} |
865 | 870 |
|
866 | 871 |
|
867 | 872 |
template <typename GR, typename NF, typename EF, bool ch = true> |
868 | 873 |
class SubGraphBase : public GraphAdaptorBase<GR> { |
869 | 874 |
typedef GraphAdaptorBase<GR> Parent; |
870 | 875 |
public: |
871 | 876 |
typedef GR Graph; |
872 | 877 |
typedef NF NodeFilterMap; |
873 | 878 |
typedef EF EdgeFilterMap; |
874 | 879 |
|
875 | 880 |
typedef SubGraphBase Adaptor; |
876 | 881 |
protected: |
877 | 882 |
|
878 | 883 |
NF* _node_filter; |
879 | 884 |
EF* _edge_filter; |
880 | 885 |
|
881 | 886 |
SubGraphBase() |
882 | 887 |
: Parent(), _node_filter(0), _edge_filter(0) { } |
883 | 888 |
|
884 | 889 |
void initialize(GR& graph, NF& node_filter, EF& edge_filter) { |
885 | 890 |
Parent::initialize(graph); |
886 | 891 |
_node_filter = &node_filter; |
887 | 892 |
_edge_filter = &edge_filter; |
888 | 893 |
} |
889 | 894 |
|
890 | 895 |
public: |
891 | 896 |
|
892 | 897 |
typedef typename Parent::Node Node; |
893 | 898 |
typedef typename Parent::Arc Arc; |
894 | 899 |
typedef typename Parent::Edge Edge; |
895 | 900 |
|
896 | 901 |
void first(Node& i) const { |
897 | 902 |
Parent::first(i); |
898 | 903 |
while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i); |
899 | 904 |
} |
900 | 905 |
|
901 | 906 |
void first(Arc& i) const { |
902 | 907 |
Parent::first(i); |
903 | 908 |
while (i!=INVALID && (!(*_edge_filter)[i] |
904 | 909 |
|| !(*_node_filter)[Parent::source(i)] |
905 | 910 |
|| !(*_node_filter)[Parent::target(i)])) |
906 | 911 |
Parent::next(i); |
907 | 912 |
} |
908 | 913 |
|
909 | 914 |
void first(Edge& i) const { |
910 | 915 |
Parent::first(i); |
911 | 916 |
while (i!=INVALID && (!(*_edge_filter)[i] |
912 | 917 |
|| !(*_node_filter)[Parent::u(i)] |
913 | 918 |
|| !(*_node_filter)[Parent::v(i)])) |
... | ... |
@@ -1125,799 +1130,807 @@ |
1125 | 1130 |
|
1126 | 1131 |
typedef typename Parent::Node Node; |
1127 | 1132 |
typedef typename Parent::Arc Arc; |
1128 | 1133 |
typedef typename Parent::Edge Edge; |
1129 | 1134 |
|
1130 | 1135 |
void first(Node& i) const { |
1131 | 1136 |
Parent::first(i); |
1132 | 1137 |
while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i); |
1133 | 1138 |
} |
1134 | 1139 |
|
1135 | 1140 |
void first(Arc& i) const { |
1136 | 1141 |
Parent::first(i); |
1137 | 1142 |
while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i); |
1138 | 1143 |
} |
1139 | 1144 |
|
1140 | 1145 |
void first(Edge& i) const { |
1141 | 1146 |
Parent::first(i); |
1142 | 1147 |
while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i); |
1143 | 1148 |
} |
1144 | 1149 |
|
1145 | 1150 |
void firstIn(Arc& i, const Node& n) const { |
1146 | 1151 |
Parent::firstIn(i, n); |
1147 | 1152 |
while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextIn(i); |
1148 | 1153 |
} |
1149 | 1154 |
|
1150 | 1155 |
void firstOut(Arc& i, const Node& n) const { |
1151 | 1156 |
Parent::firstOut(i, n); |
1152 | 1157 |
while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextOut(i); |
1153 | 1158 |
} |
1154 | 1159 |
|
1155 | 1160 |
void firstInc(Edge& i, bool& d, const Node& n) const { |
1156 | 1161 |
Parent::firstInc(i, d, n); |
1157 | 1162 |
while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextInc(i, d); |
1158 | 1163 |
} |
1159 | 1164 |
|
1160 | 1165 |
void next(Node& i) const { |
1161 | 1166 |
Parent::next(i); |
1162 | 1167 |
while (i!=INVALID && !(*_node_filter)[i]) Parent::next(i); |
1163 | 1168 |
} |
1164 | 1169 |
void next(Arc& i) const { |
1165 | 1170 |
Parent::next(i); |
1166 | 1171 |
while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i); |
1167 | 1172 |
} |
1168 | 1173 |
void next(Edge& i) const { |
1169 | 1174 |
Parent::next(i); |
1170 | 1175 |
while (i!=INVALID && !(*_edge_filter)[i]) Parent::next(i); |
1171 | 1176 |
} |
1172 | 1177 |
void nextIn(Arc& i) const { |
1173 | 1178 |
Parent::nextIn(i); |
1174 | 1179 |
while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextIn(i); |
1175 | 1180 |
} |
1176 | 1181 |
|
1177 | 1182 |
void nextOut(Arc& i) const { |
1178 | 1183 |
Parent::nextOut(i); |
1179 | 1184 |
while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextOut(i); |
1180 | 1185 |
} |
1181 | 1186 |
void nextInc(Edge& i, bool& d) const { |
1182 | 1187 |
Parent::nextInc(i, d); |
1183 | 1188 |
while (i!=INVALID && !(*_edge_filter)[i]) Parent::nextInc(i, d); |
1184 | 1189 |
} |
1185 | 1190 |
|
1186 | 1191 |
void status(const Node& n, bool v) const { _node_filter->set(n, v); } |
1187 | 1192 |
void status(const Edge& e, bool v) const { _edge_filter->set(e, v); } |
1188 | 1193 |
|
1189 | 1194 |
bool status(const Node& n) const { return (*_node_filter)[n]; } |
1190 | 1195 |
bool status(const Edge& e) const { return (*_edge_filter)[e]; } |
1191 | 1196 |
|
1192 | 1197 |
typedef False NodeNumTag; |
1193 | 1198 |
typedef False ArcNumTag; |
1194 | 1199 |
typedef False EdgeNumTag; |
1195 | 1200 |
|
1196 | 1201 |
typedef FindArcTagIndicator<Graph> FindArcTag; |
1197 | 1202 |
Arc findArc(const Node& u, const Node& v, |
1198 | 1203 |
const Arc& prev = INVALID) const { |
1199 | 1204 |
Arc arc = Parent::findArc(u, v, prev); |
1200 | 1205 |
while (arc != INVALID && !(*_edge_filter)[arc]) { |
1201 | 1206 |
arc = Parent::findArc(u, v, arc); |
1202 | 1207 |
} |
1203 | 1208 |
return arc; |
1204 | 1209 |
} |
1205 | 1210 |
|
1206 | 1211 |
typedef FindEdgeTagIndicator<Graph> FindEdgeTag; |
1207 | 1212 |
Edge findEdge(const Node& u, const Node& v, |
1208 | 1213 |
const Edge& prev = INVALID) const { |
1209 | 1214 |
Edge edge = Parent::findEdge(u, v, prev); |
1210 | 1215 |
while (edge != INVALID && !(*_edge_filter)[edge]) { |
1211 | 1216 |
edge = Parent::findEdge(u, v, edge); |
1212 | 1217 |
} |
1213 | 1218 |
return edge; |
1214 | 1219 |
} |
1215 | 1220 |
|
1216 | 1221 |
template <typename V> |
1217 | 1222 |
class NodeMap |
1218 | 1223 |
: public SubMapExtender<SubGraphBase<GR, NF, EF, false>, |
1219 | 1224 |
LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> { |
1220 | 1225 |
typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, |
1221 | 1226 |
LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent; |
1222 | 1227 |
|
1223 | 1228 |
public: |
1224 | 1229 |
typedef V Value; |
1225 | 1230 |
|
1226 | 1231 |
NodeMap(const SubGraphBase<GR, NF, EF, false>& adaptor) |
1227 | 1232 |
: Parent(adaptor) {} |
1228 | 1233 |
NodeMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value) |
1229 | 1234 |
: Parent(adaptor, value) {} |
1230 | 1235 |
|
1231 | 1236 |
private: |
1232 | 1237 |
NodeMap& operator=(const NodeMap& cmap) { |
1233 | 1238 |
return operator=<NodeMap>(cmap); |
1234 | 1239 |
} |
1235 | 1240 |
|
1236 | 1241 |
template <typename CMap> |
1237 | 1242 |
NodeMap& operator=(const CMap& cmap) { |
1238 | 1243 |
Parent::operator=(cmap); |
1239 | 1244 |
return *this; |
1240 | 1245 |
} |
1241 | 1246 |
}; |
1242 | 1247 |
|
1243 | 1248 |
template <typename V> |
1244 | 1249 |
class ArcMap |
1245 | 1250 |
: public SubMapExtender<SubGraphBase<GR, NF, EF, false>, |
1246 | 1251 |
LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> { |
1247 | 1252 |
typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, |
1248 | 1253 |
LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent; |
1249 | 1254 |
|
1250 | 1255 |
public: |
1251 | 1256 |
typedef V Value; |
1252 | 1257 |
|
1253 | 1258 |
ArcMap(const SubGraphBase<GR, NF, EF, false>& adaptor) |
1254 | 1259 |
: Parent(adaptor) {} |
1255 | 1260 |
ArcMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value) |
1256 | 1261 |
: Parent(adaptor, value) {} |
1257 | 1262 |
|
1258 | 1263 |
private: |
1259 | 1264 |
ArcMap& operator=(const ArcMap& cmap) { |
1260 | 1265 |
return operator=<ArcMap>(cmap); |
1261 | 1266 |
} |
1262 | 1267 |
|
1263 | 1268 |
template <typename CMap> |
1264 | 1269 |
ArcMap& operator=(const CMap& cmap) { |
1265 | 1270 |
Parent::operator=(cmap); |
1266 | 1271 |
return *this; |
1267 | 1272 |
} |
1268 | 1273 |
}; |
1269 | 1274 |
|
1270 | 1275 |
template <typename V> |
1271 | 1276 |
class EdgeMap |
1272 | 1277 |
: public SubMapExtender<SubGraphBase<GR, NF, EF, false>, |
1273 | 1278 |
LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> { |
1274 | 1279 |
typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, |
1275 | 1280 |
LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent; |
1276 | 1281 |
|
1277 | 1282 |
public: |
1278 | 1283 |
typedef V Value; |
1279 | 1284 |
|
1280 | 1285 |
EdgeMap(const SubGraphBase<GR, NF, EF, false>& adaptor) |
1281 | 1286 |
: Parent(adaptor) {} |
1282 | 1287 |
|
1283 | 1288 |
EdgeMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value) |
1284 | 1289 |
: Parent(adaptor, value) {} |
1285 | 1290 |
|
1286 | 1291 |
private: |
1287 | 1292 |
EdgeMap& operator=(const EdgeMap& cmap) { |
1288 | 1293 |
return operator=<EdgeMap>(cmap); |
1289 | 1294 |
} |
1290 | 1295 |
|
1291 | 1296 |
template <typename CMap> |
1292 | 1297 |
EdgeMap& operator=(const CMap& cmap) { |
1293 | 1298 |
Parent::operator=(cmap); |
1294 | 1299 |
return *this; |
1295 | 1300 |
} |
1296 | 1301 |
}; |
1297 | 1302 |
|
1298 | 1303 |
}; |
1299 | 1304 |
|
1300 | 1305 |
/// \ingroup graph_adaptors |
1301 | 1306 |
/// |
1302 | 1307 |
/// \brief Adaptor class for hiding nodes and edges in an undirected |
1303 | 1308 |
/// graph. |
1304 | 1309 |
/// |
1305 | 1310 |
/// SubGraph can be used for hiding nodes and edges in a graph. |
1306 | 1311 |
/// A \c bool node map and a \c bool edge map must be specified, which |
1307 | 1312 |
/// define the filters for nodes and edges. |
1308 | 1313 |
/// Only the nodes and edges with \c true filter value are |
1309 | 1314 |
/// shown in the subgraph. The edges that are incident to hidden |
1310 | 1315 |
/// nodes are also filtered out. |
1311 | 1316 |
/// This adaptor conforms to the \ref concepts::Graph "Graph" concept. |
1312 | 1317 |
/// |
1313 | 1318 |
/// The adapted graph can also be modified through this adaptor |
1314 | 1319 |
/// by adding or removing nodes or edges, unless the \c GR template |
1315 | 1320 |
/// parameter is set to be \c const. |
1316 | 1321 |
/// |
1322 |
/// This class provides only linear time counting for nodes, edges and arcs. |
|
1323 |
/// |
|
1317 | 1324 |
/// \tparam GR The type of the adapted graph. |
1318 | 1325 |
/// It must conform to the \ref concepts::Graph "Graph" concept. |
1319 | 1326 |
/// It can also be specified to be \c const. |
1320 | 1327 |
/// \tparam NF The type of the node filter map. |
1321 | 1328 |
/// It must be a \c bool (or convertible) node map of the |
1322 | 1329 |
/// adapted graph. The default type is |
1323 | 1330 |
/// \ref concepts::Graph::NodeMap "GR::NodeMap<bool>". |
1324 | 1331 |
/// \tparam EF The type of the edge filter map. |
1325 | 1332 |
/// It must be a \c bool (or convertible) edge map of the |
1326 | 1333 |
/// adapted graph. The default type is |
1327 | 1334 |
/// \ref concepts::Graph::EdgeMap "GR::EdgeMap<bool>". |
1328 | 1335 |
/// |
1329 | 1336 |
/// \note The \c Node, \c Edge and \c Arc types of this adaptor and the |
1330 | 1337 |
/// adapted graph are convertible to each other. |
1331 | 1338 |
/// |
1332 | 1339 |
/// \see FilterNodes |
1333 | 1340 |
/// \see FilterEdges |
1334 | 1341 |
#ifdef DOXYGEN |
1335 | 1342 |
template<typename GR, typename NF, typename EF> |
1336 | 1343 |
class SubGraph { |
1337 | 1344 |
#else |
1338 | 1345 |
template<typename GR, |
1339 | 1346 |
typename NF = typename GR::template NodeMap<bool>, |
1340 | 1347 |
typename EF = typename GR::template EdgeMap<bool> > |
1341 | 1348 |
class SubGraph : |
1342 | 1349 |
public GraphAdaptorExtender<SubGraphBase<GR, NF, EF, true> > { |
1343 | 1350 |
#endif |
1344 | 1351 |
public: |
1345 | 1352 |
/// The type of the adapted graph. |
1346 | 1353 |
typedef GR Graph; |
1347 | 1354 |
/// The type of the node filter map. |
1348 | 1355 |
typedef NF NodeFilterMap; |
1349 | 1356 |
/// The type of the edge filter map. |
1350 | 1357 |
typedef EF EdgeFilterMap; |
1351 | 1358 |
|
1352 | 1359 |
typedef GraphAdaptorExtender<SubGraphBase<GR, NF, EF, true> > |
1353 | 1360 |
Parent; |
1354 | 1361 |
|
1355 | 1362 |
typedef typename Parent::Node Node; |
1356 | 1363 |
typedef typename Parent::Edge Edge; |
1357 | 1364 |
|
1358 | 1365 |
protected: |
1359 | 1366 |
SubGraph() { } |
1360 | 1367 |
public: |
1361 | 1368 |
|
1362 | 1369 |
/// \brief Constructor |
1363 | 1370 |
/// |
1364 | 1371 |
/// Creates a subgraph for the given graph with the given node |
1365 | 1372 |
/// and edge filter maps. |
1366 | 1373 |
SubGraph(GR& graph, NF& node_filter, EF& edge_filter) { |
1367 | 1374 |
initialize(graph, node_filter, edge_filter); |
1368 | 1375 |
} |
1369 | 1376 |
|
1370 | 1377 |
/// \brief Sets the status of the given node |
1371 | 1378 |
/// |
1372 | 1379 |
/// This function sets the status of the given node. |
1373 | 1380 |
/// It is done by simply setting the assigned value of \c n |
1374 | 1381 |
/// to \c v in the node filter map. |
1375 | 1382 |
void status(const Node& n, bool v) const { Parent::status(n, v); } |
1376 | 1383 |
|
1377 | 1384 |
/// \brief Sets the status of the given edge |
1378 | 1385 |
/// |
1379 | 1386 |
/// This function sets the status of the given edge. |
1380 | 1387 |
/// It is done by simply setting the assigned value of \c e |
1381 | 1388 |
/// to \c v in the edge filter map. |
1382 | 1389 |
void status(const Edge& e, bool v) const { Parent::status(e, v); } |
1383 | 1390 |
|
1384 | 1391 |
/// \brief Returns the status of the given node |
1385 | 1392 |
/// |
1386 | 1393 |
/// This function returns the status of the given node. |
1387 | 1394 |
/// It is \c true if the given node is enabled (i.e. not hidden). |
1388 | 1395 |
bool status(const Node& n) const { return Parent::status(n); } |
1389 | 1396 |
|
1390 | 1397 |
/// \brief Returns the status of the given edge |
1391 | 1398 |
/// |
1392 | 1399 |
/// This function returns the status of the given edge. |
1393 | 1400 |
/// It is \c true if the given edge is enabled (i.e. not hidden). |
1394 | 1401 |
bool status(const Edge& e) const { return Parent::status(e); } |
1395 | 1402 |
|
1396 | 1403 |
/// \brief Disables the given node |
1397 | 1404 |
/// |
1398 | 1405 |
/// This function disables the given node in the subdigraph, |
1399 | 1406 |
/// so the iteration jumps over it. |
1400 | 1407 |
/// It is the same as \ref status() "status(n, false)". |
1401 | 1408 |
void disable(const Node& n) const { Parent::status(n, false); } |
1402 | 1409 |
|
1403 | 1410 |
/// \brief Disables the given edge |
1404 | 1411 |
/// |
1405 | 1412 |
/// This function disables the given edge in the subgraph, |
1406 | 1413 |
/// so the iteration jumps over it. |
1407 | 1414 |
/// It is the same as \ref status() "status(e, false)". |
1408 | 1415 |
void disable(const Edge& e) const { Parent::status(e, false); } |
1409 | 1416 |
|
1410 | 1417 |
/// \brief Enables the given node |
1411 | 1418 |
/// |
1412 | 1419 |
/// This function enables the given node in the subdigraph. |
1413 | 1420 |
/// It is the same as \ref status() "status(n, true)". |
1414 | 1421 |
void enable(const Node& n) const { Parent::status(n, true); } |
1415 | 1422 |
|
1416 | 1423 |
/// \brief Enables the given edge |
1417 | 1424 |
/// |
1418 | 1425 |
/// This function enables the given edge in the subgraph. |
1419 | 1426 |
/// It is the same as \ref status() "status(e, true)". |
1420 | 1427 |
void enable(const Edge& e) const { Parent::status(e, true); } |
1421 | 1428 |
|
1422 | 1429 |
}; |
1423 | 1430 |
|
1424 | 1431 |
/// \brief Returns a read-only SubGraph adaptor |
1425 | 1432 |
/// |
1426 | 1433 |
/// This function just returns a read-only \ref SubGraph adaptor. |
1427 | 1434 |
/// \ingroup graph_adaptors |
1428 | 1435 |
/// \relates SubGraph |
1429 | 1436 |
template<typename GR, typename NF, typename EF> |
1430 | 1437 |
SubGraph<const GR, NF, EF> |
1431 | 1438 |
subGraph(const GR& graph, NF& node_filter, EF& edge_filter) { |
1432 | 1439 |
return SubGraph<const GR, NF, EF> |
1433 | 1440 |
(graph, node_filter, edge_filter); |
1434 | 1441 |
} |
1435 | 1442 |
|
1436 | 1443 |
template<typename GR, typename NF, typename EF> |
1437 | 1444 |
SubGraph<const GR, const NF, EF> |
1438 | 1445 |
subGraph(const GR& graph, const NF& node_filter, EF& edge_filter) { |
1439 | 1446 |
return SubGraph<const GR, const NF, EF> |
1440 | 1447 |
(graph, node_filter, edge_filter); |
1441 | 1448 |
} |
1442 | 1449 |
|
1443 | 1450 |
template<typename GR, typename NF, typename EF> |
1444 | 1451 |
SubGraph<const GR, NF, const EF> |
1445 | 1452 |
subGraph(const GR& graph, NF& node_filter, const EF& edge_filter) { |
1446 | 1453 |
return SubGraph<const GR, NF, const EF> |
1447 | 1454 |
(graph, node_filter, edge_filter); |
1448 | 1455 |
} |
1449 | 1456 |
|
1450 | 1457 |
template<typename GR, typename NF, typename EF> |
1451 | 1458 |
SubGraph<const GR, const NF, const EF> |
1452 | 1459 |
subGraph(const GR& graph, const NF& node_filter, const EF& edge_filter) { |
1453 | 1460 |
return SubGraph<const GR, const NF, const EF> |
1454 | 1461 |
(graph, node_filter, edge_filter); |
1455 | 1462 |
} |
1456 | 1463 |
|
1457 | 1464 |
|
1458 | 1465 |
/// \ingroup graph_adaptors |
1459 | 1466 |
/// |
1460 | 1467 |
/// \brief Adaptor class for hiding nodes in a digraph or a graph. |
1461 | 1468 |
/// |
1462 | 1469 |
/// FilterNodes adaptor can be used for hiding nodes in a digraph or a |
1463 | 1470 |
/// graph. A \c bool node map must be specified, which defines the filter |
1464 | 1471 |
/// for the nodes. Only the nodes with \c true filter value and the |
1465 | 1472 |
/// arcs/edges incident to nodes both with \c true filter value are shown |
1466 | 1473 |
/// in the subgraph. This adaptor conforms to the \ref concepts::Digraph |
1467 | 1474 |
/// "Digraph" concept or the \ref concepts::Graph "Graph" concept |
1468 | 1475 |
/// depending on the \c GR template parameter. |
1469 | 1476 |
/// |
1470 | 1477 |
/// The adapted (di)graph can also be modified through this adaptor |
1471 | 1478 |
/// by adding or removing nodes or arcs/edges, unless the \c GR template |
1472 | 1479 |
/// parameter is set to be \c const. |
1473 | 1480 |
/// |
1481 |
/// This class provides only linear time item counting. |
|
1482 |
/// |
|
1474 | 1483 |
/// \tparam GR The type of the adapted digraph or graph. |
1475 | 1484 |
/// It must conform to the \ref concepts::Digraph "Digraph" concept |
1476 | 1485 |
/// or the \ref concepts::Graph "Graph" concept. |
1477 | 1486 |
/// It can also be specified to be \c const. |
1478 | 1487 |
/// \tparam NF The type of the node filter map. |
1479 | 1488 |
/// It must be a \c bool (or convertible) node map of the |
1480 | 1489 |
/// adapted (di)graph. The default type is |
1481 | 1490 |
/// \ref concepts::Graph::NodeMap "GR::NodeMap<bool>". |
1482 | 1491 |
/// |
1483 | 1492 |
/// \note The \c Node and <tt>Arc/Edge</tt> types of this adaptor and the |
1484 | 1493 |
/// adapted (di)graph are convertible to each other. |
1485 | 1494 |
#ifdef DOXYGEN |
1486 | 1495 |
template<typename GR, typename NF> |
1487 | 1496 |
class FilterNodes { |
1488 | 1497 |
#else |
1489 | 1498 |
template<typename GR, |
1490 | 1499 |
typename NF = typename GR::template NodeMap<bool>, |
1491 | 1500 |
typename Enable = void> |
1492 | 1501 |
class FilterNodes : |
1493 | 1502 |
public DigraphAdaptorExtender< |
1494 | 1503 |
SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >, |
1495 | 1504 |
true> > { |
1496 | 1505 |
#endif |
1497 | 1506 |
typedef DigraphAdaptorExtender< |
1498 | 1507 |
SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >, |
1499 | 1508 |
true> > Parent; |
1500 | 1509 |
|
1501 | 1510 |
public: |
1502 | 1511 |
|
1503 | 1512 |
typedef GR Digraph; |
1504 | 1513 |
typedef NF NodeFilterMap; |
1505 | 1514 |
|
1506 | 1515 |
typedef typename Parent::Node Node; |
1507 | 1516 |
|
1508 | 1517 |
protected: |
1509 | 1518 |
ConstMap<typename Digraph::Arc, Const<bool, true> > const_true_map; |
1510 | 1519 |
|
1511 | 1520 |
FilterNodes() : const_true_map() {} |
1512 | 1521 |
|
1513 | 1522 |
public: |
1514 | 1523 |
|
1515 | 1524 |
/// \brief Constructor |
1516 | 1525 |
/// |
1517 | 1526 |
/// Creates a subgraph for the given digraph or graph with the |
1518 | 1527 |
/// given node filter map. |
1519 | 1528 |
FilterNodes(GR& graph, NF& node_filter) |
1520 | 1529 |
: Parent(), const_true_map() |
1521 | 1530 |
{ |
1522 | 1531 |
Parent::initialize(graph, node_filter, const_true_map); |
1523 | 1532 |
} |
1524 | 1533 |
|
1525 | 1534 |
/// \brief Sets the status of the given node |
1526 | 1535 |
/// |
1527 | 1536 |
/// This function sets the status of the given node. |
1528 | 1537 |
/// It is done by simply setting the assigned value of \c n |
1529 | 1538 |
/// to \c v in the node filter map. |
1530 | 1539 |
void status(const Node& n, bool v) const { Parent::status(n, v); } |
1531 | 1540 |
|
1532 | 1541 |
/// \brief Returns the status of the given node |
1533 | 1542 |
/// |
1534 | 1543 |
/// This function returns the status of the given node. |
1535 | 1544 |
/// It is \c true if the given node is enabled (i.e. not hidden). |
1536 | 1545 |
bool status(const Node& n) const { return Parent::status(n); } |
1537 | 1546 |
|
1538 | 1547 |
/// \brief Disables the given node |
1539 | 1548 |
/// |
1540 | 1549 |
/// This function disables the given node, so the iteration |
1541 | 1550 |
/// jumps over it. |
1542 | 1551 |
/// It is the same as \ref status() "status(n, false)". |
1543 | 1552 |
void disable(const Node& n) const { Parent::status(n, false); } |
1544 | 1553 |
|
1545 | 1554 |
/// \brief Enables the given node |
1546 | 1555 |
/// |
1547 | 1556 |
/// This function enables the given node. |
1548 | 1557 |
/// It is the same as \ref status() "status(n, true)". |
1549 | 1558 |
void enable(const Node& n) const { Parent::status(n, true); } |
1550 | 1559 |
|
1551 | 1560 |
}; |
1552 | 1561 |
|
1553 | 1562 |
template<typename GR, typename NF> |
1554 | 1563 |
class FilterNodes<GR, NF, |
1555 | 1564 |
typename enable_if<UndirectedTagIndicator<GR> >::type> : |
1556 | 1565 |
public GraphAdaptorExtender< |
1557 | 1566 |
SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >, |
1558 | 1567 |
true> > { |
1559 | 1568 |
|
1560 | 1569 |
typedef GraphAdaptorExtender< |
1561 | 1570 |
SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >, |
1562 | 1571 |
true> > Parent; |
1563 | 1572 |
|
1564 | 1573 |
public: |
1565 | 1574 |
|
1566 | 1575 |
typedef GR Graph; |
1567 | 1576 |
typedef NF NodeFilterMap; |
1568 | 1577 |
|
1569 | 1578 |
typedef typename Parent::Node Node; |
1570 | 1579 |
|
1571 | 1580 |
protected: |
1572 | 1581 |
ConstMap<typename GR::Edge, Const<bool, true> > const_true_map; |
1573 | 1582 |
|
1574 | 1583 |
FilterNodes() : const_true_map() {} |
1575 | 1584 |
|
1576 | 1585 |
public: |
1577 | 1586 |
|
1578 | 1587 |
FilterNodes(GR& graph, NodeFilterMap& node_filter) : |
1579 | 1588 |
Parent(), const_true_map() { |
1580 | 1589 |
Parent::initialize(graph, node_filter, const_true_map); |
1581 | 1590 |
} |
1582 | 1591 |
|
1583 | 1592 |
void status(const Node& n, bool v) const { Parent::status(n, v); } |
1584 | 1593 |
bool status(const Node& n) const { return Parent::status(n); } |
1585 | 1594 |
void disable(const Node& n) const { Parent::status(n, false); } |
1586 | 1595 |
void enable(const Node& n) const { Parent::status(n, true); } |
1587 | 1596 |
|
1588 | 1597 |
}; |
1589 | 1598 |
|
1590 | 1599 |
|
1591 | 1600 |
/// \brief Returns a read-only FilterNodes adaptor |
1592 | 1601 |
/// |
1593 | 1602 |
/// This function just returns a read-only \ref FilterNodes adaptor. |
1594 | 1603 |
/// \ingroup graph_adaptors |
1595 | 1604 |
/// \relates FilterNodes |
1596 | 1605 |
template<typename GR, typename NF> |
1597 | 1606 |
FilterNodes<const GR, NF> |
1598 | 1607 |
filterNodes(const GR& graph, NF& node_filter) { |
1599 | 1608 |
return FilterNodes<const GR, NF>(graph, node_filter); |
1600 | 1609 |
} |
1601 | 1610 |
|
1602 | 1611 |
template<typename GR, typename NF> |
1603 | 1612 |
FilterNodes<const GR, const NF> |
1604 | 1613 |
filterNodes(const GR& graph, const NF& node_filter) { |
1605 | 1614 |
return FilterNodes<const GR, const NF>(graph, node_filter); |
1606 | 1615 |
} |
1607 | 1616 |
|
1608 | 1617 |
/// \ingroup graph_adaptors |
1609 | 1618 |
/// |
1610 | 1619 |
/// \brief Adaptor class for hiding arcs in a digraph. |
1611 | 1620 |
/// |
1612 | 1621 |
/// FilterArcs adaptor can be used for hiding arcs in a digraph. |
1613 | 1622 |
/// A \c bool arc map must be specified, which defines the filter for |
1614 | 1623 |
/// the arcs. Only the arcs with \c true filter value are shown in the |
1615 | 1624 |
/// subdigraph. This adaptor conforms to the \ref concepts::Digraph |
1616 | 1625 |
/// "Digraph" concept. |
1617 | 1626 |
/// |
1618 | 1627 |
/// The adapted digraph can also be modified through this adaptor |
1619 | 1628 |
/// by adding or removing nodes or arcs, unless the \c GR template |
1620 | 1629 |
/// parameter is set to be \c const. |
1621 | 1630 |
/// |
1631 |
/// This class provides only linear time counting for nodes and arcs. |
|
1632 |
/// |
|
1622 | 1633 |
/// \tparam DGR The type of the adapted digraph. |
1623 | 1634 |
/// It must conform to the \ref concepts::Digraph "Digraph" concept. |
1624 | 1635 |
/// It can also be specified to be \c const. |
1625 | 1636 |
/// \tparam AF The type of the arc filter map. |
1626 | 1637 |
/// It must be a \c bool (or convertible) arc map of the |
1627 | 1638 |
/// adapted digraph. The default type is |
1628 | 1639 |
/// \ref concepts::Digraph::ArcMap "DGR::ArcMap<bool>". |
1629 | 1640 |
/// |
1630 | 1641 |
/// \note The \c Node and \c Arc types of this adaptor and the adapted |
1631 | 1642 |
/// digraph are convertible to each other. |
1632 | 1643 |
#ifdef DOXYGEN |
1633 | 1644 |
template<typename DGR, |
1634 | 1645 |
typename AF> |
1635 | 1646 |
class FilterArcs { |
1636 | 1647 |
#else |
1637 | 1648 |
template<typename DGR, |
1638 | 1649 |
typename AF = typename DGR::template ArcMap<bool> > |
1639 | 1650 |
class FilterArcs : |
1640 | 1651 |
public DigraphAdaptorExtender< |
1641 | 1652 |
SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >, |
1642 | 1653 |
AF, false> > { |
1643 | 1654 |
#endif |
1644 | 1655 |
typedef DigraphAdaptorExtender< |
1645 | 1656 |
SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >, |
1646 | 1657 |
AF, false> > Parent; |
1647 | 1658 |
|
1648 | 1659 |
public: |
1649 | 1660 |
|
1650 | 1661 |
/// The type of the adapted digraph. |
1651 | 1662 |
typedef DGR Digraph; |
1652 | 1663 |
/// The type of the arc filter map. |
1653 | 1664 |
typedef AF ArcFilterMap; |
1654 | 1665 |
|
1655 | 1666 |
typedef typename Parent::Arc Arc; |
1656 | 1667 |
|
1657 | 1668 |
protected: |
1658 | 1669 |
ConstMap<typename DGR::Node, Const<bool, true> > const_true_map; |
1659 | 1670 |
|
1660 | 1671 |
FilterArcs() : const_true_map() {} |
1661 | 1672 |
|
1662 | 1673 |
public: |
1663 | 1674 |
|
1664 | 1675 |
/// \brief Constructor |
1665 | 1676 |
/// |
1666 | 1677 |
/// Creates a subdigraph for the given digraph with the given arc |
1667 | 1678 |
/// filter map. |
1668 | 1679 |
FilterArcs(DGR& digraph, ArcFilterMap& arc_filter) |
1669 | 1680 |
: Parent(), const_true_map() { |
1670 | 1681 |
Parent::initialize(digraph, const_true_map, arc_filter); |
1671 | 1682 |
} |
1672 | 1683 |
|
1673 | 1684 |
/// \brief Sets the status of the given arc |
1674 | 1685 |
/// |
1675 | 1686 |
/// This function sets the status of the given arc. |
1676 | 1687 |
/// It is done by simply setting the assigned value of \c a |
1677 | 1688 |
/// to \c v in the arc filter map. |
1678 | 1689 |
void status(const Arc& a, bool v) const { Parent::status(a, v); } |
1679 | 1690 |
|
1680 | 1691 |
/// \brief Returns the status of the given arc |
1681 | 1692 |
/// |
1682 | 1693 |
/// This function returns the status of the given arc. |
1683 | 1694 |
/// It is \c true if the given arc is enabled (i.e. not hidden). |
1684 | 1695 |
bool status(const Arc& a) const { return Parent::status(a); } |
1685 | 1696 |
|
1686 | 1697 |
/// \brief Disables the given arc |
1687 | 1698 |
/// |
1688 | 1699 |
/// This function disables the given arc in the subdigraph, |
1689 | 1700 |
/// so the iteration jumps over it. |
1690 | 1701 |
/// It is the same as \ref status() "status(a, false)". |
1691 | 1702 |
void disable(const Arc& a) const { Parent::status(a, false); } |
1692 | 1703 |
|
1693 | 1704 |
/// \brief Enables the given arc |
1694 | 1705 |
/// |
1695 | 1706 |
/// This function enables the given arc in the subdigraph. |
1696 | 1707 |
/// It is the same as \ref status() "status(a, true)". |
1697 | 1708 |
void enable(const Arc& a) const { Parent::status(a, true); } |
1698 | 1709 |
|
1699 | 1710 |
}; |
1700 | 1711 |
|
1701 | 1712 |
/// \brief Returns a read-only FilterArcs adaptor |
1702 | 1713 |
/// |
1703 | 1714 |
/// This function just returns a read-only \ref FilterArcs adaptor. |
1704 | 1715 |
/// \ingroup graph_adaptors |
1705 | 1716 |
/// \relates FilterArcs |
1706 | 1717 |
template<typename DGR, typename AF> |
1707 | 1718 |
FilterArcs<const DGR, AF> |
1708 | 1719 |
filterArcs(const DGR& digraph, AF& arc_filter) { |
1709 | 1720 |
return FilterArcs<const DGR, AF>(digraph, arc_filter); |
1710 | 1721 |
} |
1711 | 1722 |
|
1712 | 1723 |
template<typename DGR, typename AF> |
1713 | 1724 |
FilterArcs<const DGR, const AF> |
1714 | 1725 |
filterArcs(const DGR& digraph, const AF& arc_filter) { |
1715 | 1726 |
return FilterArcs<const DGR, const AF>(digraph, arc_filter); |
1716 | 1727 |
} |
1717 | 1728 |
|
1718 | 1729 |
/// \ingroup graph_adaptors |
1719 | 1730 |
/// |
1720 | 1731 |
/// \brief Adaptor class for hiding edges in a graph. |
1721 | 1732 |
/// |
1722 | 1733 |
/// FilterEdges adaptor can be used for hiding edges in a graph. |
1723 | 1734 |
/// A \c bool edge map must be specified, which defines the filter for |
1724 | 1735 |
/// the edges. Only the edges with \c true filter value are shown in the |
1725 | 1736 |
/// subgraph. This adaptor conforms to the \ref concepts::Graph |
1726 | 1737 |
/// "Graph" concept. |
1727 | 1738 |
/// |
1728 | 1739 |
/// The adapted graph can also be modified through this adaptor |
1729 | 1740 |
/// by adding or removing nodes or edges, unless the \c GR template |
1730 | 1741 |
/// parameter is set to be \c const. |
1731 | 1742 |
/// |
1743 |
/// This class provides only linear time counting for nodes, edges and arcs. |
|
1744 |
/// |
|
1732 | 1745 |
/// \tparam GR The type of the adapted graph. |
1733 | 1746 |
/// It must conform to the \ref concepts::Graph "Graph" concept. |
1734 | 1747 |
/// It can also be specified to be \c const. |
1735 | 1748 |
/// \tparam EF The type of the edge filter map. |
1736 | 1749 |
/// It must be a \c bool (or convertible) edge map of the |
1737 | 1750 |
/// adapted graph. The default type is |
1738 | 1751 |
/// \ref concepts::Graph::EdgeMap "GR::EdgeMap<bool>". |
1739 | 1752 |
/// |
1740 | 1753 |
/// \note The \c Node, \c Edge and \c Arc types of this adaptor and the |
1741 | 1754 |
/// adapted graph are convertible to each other. |
1742 | 1755 |
#ifdef DOXYGEN |
1743 | 1756 |
template<typename GR, |
1744 | 1757 |
typename EF> |
1745 | 1758 |
class FilterEdges { |
1746 | 1759 |
#else |
1747 | 1760 |
template<typename GR, |
1748 | 1761 |
typename EF = typename GR::template EdgeMap<bool> > |
1749 | 1762 |
class FilterEdges : |
1750 | 1763 |
public GraphAdaptorExtender< |
1751 | 1764 |
SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >, |
1752 | 1765 |
EF, false> > { |
1753 | 1766 |
#endif |
1754 | 1767 |
typedef GraphAdaptorExtender< |
1755 | 1768 |
SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >, |
1756 | 1769 |
EF, false> > Parent; |
1757 | 1770 |
|
1758 | 1771 |
public: |
1759 | 1772 |
|
1760 | 1773 |
/// The type of the adapted graph. |
1761 | 1774 |
typedef GR Graph; |
1762 | 1775 |
/// The type of the edge filter map. |
1763 | 1776 |
typedef EF EdgeFilterMap; |
1764 | 1777 |
|
1765 | 1778 |
typedef typename Parent::Edge Edge; |
1766 | 1779 |
|
1767 | 1780 |
protected: |
1768 | 1781 |
ConstMap<typename GR::Node, Const<bool, true> > const_true_map; |
1769 | 1782 |
|
1770 | 1783 |
FilterEdges() : const_true_map(true) { |
1771 | 1784 |
Parent::setNodeFilterMap(const_true_map); |
1772 | 1785 |
} |
1773 | 1786 |
|
1774 | 1787 |
public: |
1775 | 1788 |
|
1776 | 1789 |
/// \brief Constructor |
1777 | 1790 |
/// |
1778 | 1791 |
/// Creates a subgraph for the given graph with the given edge |
1779 | 1792 |
/// filter map. |
1780 | 1793 |
FilterEdges(GR& graph, EF& edge_filter) |
1781 | 1794 |
: Parent(), const_true_map() { |
1782 | 1795 |
Parent::initialize(graph, const_true_map, edge_filter); |
1783 | 1796 |
} |
1784 | 1797 |
|
1785 | 1798 |
/// \brief Sets the status of the given edge |
1786 | 1799 |
/// |
1787 | 1800 |
/// This function sets the status of the given edge. |
1788 | 1801 |
/// It is done by simply setting the assigned value of \c e |
1789 | 1802 |
/// to \c v in the edge filter map. |
1790 | 1803 |
void status(const Edge& e, bool v) const { Parent::status(e, v); } |
1791 | 1804 |
|
1792 | 1805 |
/// \brief Returns the status of the given edge |
1793 | 1806 |
/// |
1794 | 1807 |
/// This function returns the status of the given edge. |
1795 | 1808 |
/// It is \c true if the given edge is enabled (i.e. not hidden). |
1796 | 1809 |
bool status(const Edge& e) const { return Parent::status(e); } |
1797 | 1810 |
|
1798 | 1811 |
/// \brief Disables the given edge |
1799 | 1812 |
/// |
1800 | 1813 |
/// This function disables the given edge in the subgraph, |
1801 | 1814 |
/// so the iteration jumps over it. |
1802 | 1815 |
/// It is the same as \ref status() "status(e, false)". |
1803 | 1816 |
void disable(const Edge& e) const { Parent::status(e, false); } |
1804 | 1817 |
|
1805 | 1818 |
/// \brief Enables the given edge |
1806 | 1819 |
/// |
1807 | 1820 |
/// This function enables the given edge in the subgraph. |
1808 | 1821 |
/// It is the same as \ref status() "status(e, true)". |
1809 | 1822 |
void enable(const Edge& e) const { Parent::status(e, true); } |
1810 | 1823 |
|
1811 | 1824 |
}; |
1812 | 1825 |
|
1813 | 1826 |
/// \brief Returns a read-only FilterEdges adaptor |
1814 | 1827 |
/// |
1815 | 1828 |
/// This function just returns a read-only \ref FilterEdges adaptor. |
1816 | 1829 |
/// \ingroup graph_adaptors |
1817 | 1830 |
/// \relates FilterEdges |
1818 | 1831 |
template<typename GR, typename EF> |
1819 | 1832 |
FilterEdges<const GR, EF> |
1820 | 1833 |
filterEdges(const GR& graph, EF& edge_filter) { |
1821 | 1834 |
return FilterEdges<const GR, EF>(graph, edge_filter); |
1822 | 1835 |
} |
1823 | 1836 |
|
1824 | 1837 |
template<typename GR, typename EF> |
1825 | 1838 |
FilterEdges<const GR, const EF> |
1826 | 1839 |
filterEdges(const GR& graph, const EF& edge_filter) { |
1827 | 1840 |
return FilterEdges<const GR, const EF>(graph, edge_filter); |
1828 | 1841 |
} |
1829 | 1842 |
|
1830 | 1843 |
|
1831 | 1844 |
template <typename DGR> |
1832 | 1845 |
class UndirectorBase { |
1833 | 1846 |
public: |
1834 | 1847 |
typedef DGR Digraph; |
1835 | 1848 |
typedef UndirectorBase Adaptor; |
1836 | 1849 |
|
1837 | 1850 |
typedef True UndirectedTag; |
1838 | 1851 |
|
1839 | 1852 |
typedef typename Digraph::Arc Edge; |
1840 | 1853 |
typedef typename Digraph::Node Node; |
1841 | 1854 |
|
1842 | 1855 |
class Arc { |
1843 | 1856 |
friend class UndirectorBase; |
1844 | 1857 |
protected: |
1845 | 1858 |
Edge _edge; |
1846 | 1859 |
bool _forward; |
1847 | 1860 |
|
1848 | 1861 |
Arc(const Edge& edge, bool forward) |
1849 | 1862 |
: _edge(edge), _forward(forward) {} |
1850 | 1863 |
|
1851 | 1864 |
public: |
1852 | 1865 |
Arc() {} |
1853 | 1866 |
|
1854 | 1867 |
Arc(Invalid) : _edge(INVALID), _forward(true) {} |
1855 | 1868 |
|
1856 | 1869 |
operator const Edge&() const { return _edge; } |
1857 | 1870 |
|
1858 | 1871 |
bool operator==(const Arc &other) const { |
1859 | 1872 |
return _forward == other._forward && _edge == other._edge; |
1860 | 1873 |
} |
1861 | 1874 |
bool operator!=(const Arc &other) const { |
1862 | 1875 |
return _forward != other._forward || _edge != other._edge; |
1863 | 1876 |
} |
1864 | 1877 |
bool operator<(const Arc &other) const { |
1865 | 1878 |
return _forward < other._forward || |
1866 | 1879 |
(_forward == other._forward && _edge < other._edge); |
1867 | 1880 |
} |
1868 | 1881 |
}; |
1869 | 1882 |
|
1870 | 1883 |
void first(Node& n) const { |
1871 | 1884 |
_digraph->first(n); |
1872 | 1885 |
} |
1873 | 1886 |
|
1874 | 1887 |
void next(Node& n) const { |
1875 | 1888 |
_digraph->next(n); |
1876 | 1889 |
} |
1877 | 1890 |
|
1878 | 1891 |
void first(Arc& a) const { |
1879 | 1892 |
_digraph->first(a._edge); |
1880 | 1893 |
a._forward = true; |
1881 | 1894 |
} |
1882 | 1895 |
|
1883 | 1896 |
void next(Arc& a) const { |
1884 | 1897 |
if (a._forward) { |
1885 | 1898 |
a._forward = false; |
1886 | 1899 |
} else { |
1887 | 1900 |
_digraph->next(a._edge); |
1888 | 1901 |
a._forward = true; |
1889 | 1902 |
} |
1890 | 1903 |
} |
1891 | 1904 |
|
1892 | 1905 |
void first(Edge& e) const { |
1893 | 1906 |
_digraph->first(e); |
1894 | 1907 |
} |
1895 | 1908 |
|
1896 | 1909 |
void next(Edge& e) const { |
1897 | 1910 |
_digraph->next(e); |
1898 | 1911 |
} |
1899 | 1912 |
|
1900 | 1913 |
void firstOut(Arc& a, const Node& n) const { |
1901 | 1914 |
_digraph->firstIn(a._edge, n); |
1902 | 1915 |
if (a._edge != INVALID ) { |
1903 | 1916 |
a._forward = false; |
1904 | 1917 |
} else { |
1905 | 1918 |
_digraph->firstOut(a._edge, n); |
1906 | 1919 |
a._forward = true; |
1907 | 1920 |
} |
1908 | 1921 |
} |
1909 | 1922 |
void nextOut(Arc &a) const { |
1910 | 1923 |
if (!a._forward) { |
1911 | 1924 |
Node n = _digraph->target(a._edge); |
1912 | 1925 |
_digraph->nextIn(a._edge); |
1913 | 1926 |
if (a._edge == INVALID) { |
1914 | 1927 |
_digraph->firstOut(a._edge, n); |
1915 | 1928 |
a._forward = true; |
1916 | 1929 |
} |
1917 | 1930 |
} |
1918 | 1931 |
else { |
1919 | 1932 |
_digraph->nextOut(a._edge); |
1920 | 1933 |
} |
1921 | 1934 |
} |
1922 | 1935 |
|
1923 | 1936 |
void firstIn(Arc &a, const Node &n) const { |
... | ... |
@@ -2043,830 +2056,838 @@ |
2043 | 2056 |
Edge findEdge(Node s, Node t, Edge p = INVALID) const { |
2044 | 2057 |
if (s != t) { |
2045 | 2058 |
if (p == INVALID) { |
2046 | 2059 |
Edge arc = _digraph->findArc(s, t); |
2047 | 2060 |
if (arc != INVALID) return arc; |
2048 | 2061 |
arc = _digraph->findArc(t, s); |
2049 | 2062 |
if (arc != INVALID) return arc; |
2050 | 2063 |
} else if (_digraph->source(p) == s) { |
2051 | 2064 |
Edge arc = _digraph->findArc(s, t, p); |
2052 | 2065 |
if (arc != INVALID) return arc; |
2053 | 2066 |
arc = _digraph->findArc(t, s); |
2054 | 2067 |
if (arc != INVALID) return arc; |
2055 | 2068 |
} else { |
2056 | 2069 |
Edge arc = _digraph->findArc(t, s, p); |
2057 | 2070 |
if (arc != INVALID) return arc; |
2058 | 2071 |
} |
2059 | 2072 |
} else { |
2060 | 2073 |
return _digraph->findArc(s, t, p); |
2061 | 2074 |
} |
2062 | 2075 |
return INVALID; |
2063 | 2076 |
} |
2064 | 2077 |
|
2065 | 2078 |
private: |
2066 | 2079 |
|
2067 | 2080 |
template <typename V> |
2068 | 2081 |
class ArcMapBase { |
2069 | 2082 |
private: |
2070 | 2083 |
|
2071 | 2084 |
typedef typename DGR::template ArcMap<V> MapImpl; |
2072 | 2085 |
|
2073 | 2086 |
public: |
2074 | 2087 |
|
2075 | 2088 |
typedef typename MapTraits<MapImpl>::ReferenceMapTag ReferenceMapTag; |
2076 | 2089 |
|
2077 | 2090 |
typedef V Value; |
2078 | 2091 |
typedef Arc Key; |
2079 | 2092 |
typedef typename MapTraits<MapImpl>::ConstReturnValue ConstReturnValue; |
2080 | 2093 |
typedef typename MapTraits<MapImpl>::ReturnValue ReturnValue; |
2081 | 2094 |
typedef typename MapTraits<MapImpl>::ConstReturnValue ConstReference; |
2082 | 2095 |
typedef typename MapTraits<MapImpl>::ReturnValue Reference; |
2083 | 2096 |
|
2084 | 2097 |
ArcMapBase(const UndirectorBase<DGR>& adaptor) : |
2085 | 2098 |
_forward(*adaptor._digraph), _backward(*adaptor._digraph) {} |
2086 | 2099 |
|
2087 | 2100 |
ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value) |
2088 | 2101 |
: _forward(*adaptor._digraph, value), |
2089 | 2102 |
_backward(*adaptor._digraph, value) {} |
2090 | 2103 |
|
2091 | 2104 |
void set(const Arc& a, const V& value) { |
2092 | 2105 |
if (direction(a)) { |
2093 | 2106 |
_forward.set(a, value); |
2094 | 2107 |
} else { |
2095 | 2108 |
_backward.set(a, value); |
2096 | 2109 |
} |
2097 | 2110 |
} |
2098 | 2111 |
|
2099 | 2112 |
ConstReturnValue operator[](const Arc& a) const { |
2100 | 2113 |
if (direction(a)) { |
2101 | 2114 |
return _forward[a]; |
2102 | 2115 |
} else { |
2103 | 2116 |
return _backward[a]; |
2104 | 2117 |
} |
2105 | 2118 |
} |
2106 | 2119 |
|
2107 | 2120 |
ReturnValue operator[](const Arc& a) { |
2108 | 2121 |
if (direction(a)) { |
2109 | 2122 |
return _forward[a]; |
2110 | 2123 |
} else { |
2111 | 2124 |
return _backward[a]; |
2112 | 2125 |
} |
2113 | 2126 |
} |
2114 | 2127 |
|
2115 | 2128 |
protected: |
2116 | 2129 |
|
2117 | 2130 |
MapImpl _forward, _backward; |
2118 | 2131 |
|
2119 | 2132 |
}; |
2120 | 2133 |
|
2121 | 2134 |
public: |
2122 | 2135 |
|
2123 | 2136 |
template <typename V> |
2124 | 2137 |
class NodeMap : public DGR::template NodeMap<V> { |
2125 | 2138 |
typedef typename DGR::template NodeMap<V> Parent; |
2126 | 2139 |
|
2127 | 2140 |
public: |
2128 | 2141 |
typedef V Value; |
2129 | 2142 |
|
2130 | 2143 |
explicit NodeMap(const UndirectorBase<DGR>& adaptor) |
2131 | 2144 |
: Parent(*adaptor._digraph) {} |
2132 | 2145 |
|
2133 | 2146 |
NodeMap(const UndirectorBase<DGR>& adaptor, const V& value) |
2134 | 2147 |
: Parent(*adaptor._digraph, value) { } |
2135 | 2148 |
|
2136 | 2149 |
private: |
2137 | 2150 |
NodeMap& operator=(const NodeMap& cmap) { |
2138 | 2151 |
return operator=<NodeMap>(cmap); |
2139 | 2152 |
} |
2140 | 2153 |
|
2141 | 2154 |
template <typename CMap> |
2142 | 2155 |
NodeMap& operator=(const CMap& cmap) { |
2143 | 2156 |
Parent::operator=(cmap); |
2144 | 2157 |
return *this; |
2145 | 2158 |
} |
2146 | 2159 |
|
2147 | 2160 |
}; |
2148 | 2161 |
|
2149 | 2162 |
template <typename V> |
2150 | 2163 |
class ArcMap |
2151 | 2164 |
: public SubMapExtender<UndirectorBase<DGR>, ArcMapBase<V> > { |
2152 | 2165 |
typedef SubMapExtender<UndirectorBase<DGR>, ArcMapBase<V> > Parent; |
2153 | 2166 |
|
2154 | 2167 |
public: |
2155 | 2168 |
typedef V Value; |
2156 | 2169 |
|
2157 | 2170 |
explicit ArcMap(const UndirectorBase<DGR>& adaptor) |
2158 | 2171 |
: Parent(adaptor) {} |
2159 | 2172 |
|
2160 | 2173 |
ArcMap(const UndirectorBase<DGR>& adaptor, const V& value) |
2161 | 2174 |
: Parent(adaptor, value) {} |
2162 | 2175 |
|
2163 | 2176 |
private: |
2164 | 2177 |
ArcMap& operator=(const ArcMap& cmap) { |
2165 | 2178 |
return operator=<ArcMap>(cmap); |
2166 | 2179 |
} |
2167 | 2180 |
|
2168 | 2181 |
template <typename CMap> |
2169 | 2182 |
ArcMap& operator=(const CMap& cmap) { |
2170 | 2183 |
Parent::operator=(cmap); |
2171 | 2184 |
return *this; |
2172 | 2185 |
} |
2173 | 2186 |
}; |
2174 | 2187 |
|
2175 | 2188 |
template <typename V> |
2176 | 2189 |
class EdgeMap : public Digraph::template ArcMap<V> { |
2177 | 2190 |
typedef typename Digraph::template ArcMap<V> Parent; |
2178 | 2191 |
|
2179 | 2192 |
public: |
2180 | 2193 |
typedef V Value; |
2181 | 2194 |
|
2182 | 2195 |
explicit EdgeMap(const UndirectorBase<DGR>& adaptor) |
2183 | 2196 |
: Parent(*adaptor._digraph) {} |
2184 | 2197 |
|
2185 | 2198 |
EdgeMap(const UndirectorBase<DGR>& adaptor, const V& value) |
2186 | 2199 |
: Parent(*adaptor._digraph, value) {} |
2187 | 2200 |
|
2188 | 2201 |
private: |
2189 | 2202 |
EdgeMap& operator=(const EdgeMap& cmap) { |
2190 | 2203 |
return operator=<EdgeMap>(cmap); |
2191 | 2204 |
} |
2192 | 2205 |
|
2193 | 2206 |
template <typename CMap> |
2194 | 2207 |
EdgeMap& operator=(const CMap& cmap) { |
2195 | 2208 |
Parent::operator=(cmap); |
2196 | 2209 |
return *this; |
2197 | 2210 |
} |
2198 | 2211 |
|
2199 | 2212 |
}; |
2200 | 2213 |
|
2201 | 2214 |
typedef typename ItemSetTraits<DGR, Node>::ItemNotifier NodeNotifier; |
2202 | 2215 |
NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); } |
2203 | 2216 |
|
2204 | 2217 |
typedef typename ItemSetTraits<DGR, Edge>::ItemNotifier EdgeNotifier; |
2205 | 2218 |
EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); } |
2206 | 2219 |
|
2207 | 2220 |
typedef EdgeNotifier ArcNotifier; |
2208 | 2221 |
ArcNotifier& notifier(Arc) const { return _digraph->notifier(Edge()); } |
2209 | 2222 |
|
2210 | 2223 |
protected: |
2211 | 2224 |
|
2212 | 2225 |
UndirectorBase() : _digraph(0) {} |
2213 | 2226 |
|
2214 | 2227 |
DGR* _digraph; |
2215 | 2228 |
|
2216 | 2229 |
void initialize(DGR& digraph) { |
2217 | 2230 |
_digraph = &digraph; |
2218 | 2231 |
} |
2219 | 2232 |
|
2220 | 2233 |
}; |
2221 | 2234 |
|
2222 | 2235 |
/// \ingroup graph_adaptors |
2223 | 2236 |
/// |
2224 | 2237 |
/// \brief Adaptor class for viewing a digraph as an undirected graph. |
2225 | 2238 |
/// |
2226 | 2239 |
/// Undirector adaptor can be used for viewing a digraph as an undirected |
2227 | 2240 |
/// graph. All arcs of the underlying digraph are showed in the |
2228 | 2241 |
/// adaptor as an edge (and also as a pair of arcs, of course). |
2229 | 2242 |
/// This adaptor conforms to the \ref concepts::Graph "Graph" concept. |
2230 | 2243 |
/// |
2231 | 2244 |
/// The adapted digraph can also be modified through this adaptor |
2232 | 2245 |
/// by adding or removing nodes or edges, unless the \c GR template |
2233 | 2246 |
/// parameter is set to be \c const. |
2234 | 2247 |
/// |
2248 |
/// This class provides item counting in the same time as the adapted |
|
2249 |
/// digraph structure. |
|
2250 |
/// |
|
2235 | 2251 |
/// \tparam DGR The type of the adapted digraph. |
2236 | 2252 |
/// It must conform to the \ref concepts::Digraph "Digraph" concept. |
2237 | 2253 |
/// It can also be specified to be \c const. |
2238 | 2254 |
/// |
2239 | 2255 |
/// \note The \c Node type of this adaptor and the adapted digraph are |
2240 | 2256 |
/// convertible to each other, moreover the \c Edge type of the adaptor |
2241 | 2257 |
/// and the \c Arc type of the adapted digraph are also convertible to |
2242 | 2258 |
/// each other. |
2243 | 2259 |
/// (Thus the \c Arc type of the adaptor is convertible to the \c Arc type |
2244 | 2260 |
/// of the adapted digraph.) |
2245 | 2261 |
template<typename DGR> |
2246 | 2262 |
#ifdef DOXYGEN |
2247 | 2263 |
class Undirector { |
2248 | 2264 |
#else |
2249 | 2265 |
class Undirector : |
2250 | 2266 |
public GraphAdaptorExtender<UndirectorBase<DGR> > { |
2251 | 2267 |
#endif |
2252 | 2268 |
typedef GraphAdaptorExtender<UndirectorBase<DGR> > Parent; |
2253 | 2269 |
public: |
2254 | 2270 |
/// The type of the adapted digraph. |
2255 | 2271 |
typedef DGR Digraph; |
2256 | 2272 |
protected: |
2257 | 2273 |
Undirector() { } |
2258 | 2274 |
public: |
2259 | 2275 |
|
2260 | 2276 |
/// \brief Constructor |
2261 | 2277 |
/// |
2262 | 2278 |
/// Creates an undirected graph from the given digraph. |
2263 | 2279 |
Undirector(DGR& digraph) { |
2264 | 2280 |
initialize(digraph); |
2265 | 2281 |
} |
2266 | 2282 |
|
2267 | 2283 |
/// \brief Arc map combined from two original arc maps |
2268 | 2284 |
/// |
2269 | 2285 |
/// This map adaptor class adapts two arc maps of the underlying |
2270 | 2286 |
/// digraph to get an arc map of the undirected graph. |
2271 | 2287 |
/// Its value type is inherited from the first arc map type (\c FW). |
2272 | 2288 |
/// \tparam FW The type of the "foward" arc map. |
2273 | 2289 |
/// \tparam BK The type of the "backward" arc map. |
2274 | 2290 |
template <typename FW, typename BK> |
2275 | 2291 |
class CombinedArcMap { |
2276 | 2292 |
public: |
2277 | 2293 |
|
2278 | 2294 |
/// The key type of the map |
2279 | 2295 |
typedef typename Parent::Arc Key; |
2280 | 2296 |
/// The value type of the map |
2281 | 2297 |
typedef typename FW::Value Value; |
2282 | 2298 |
|
2283 | 2299 |
typedef typename MapTraits<FW>::ReferenceMapTag ReferenceMapTag; |
2284 | 2300 |
|
2285 | 2301 |
typedef typename MapTraits<FW>::ReturnValue ReturnValue; |
2286 | 2302 |
typedef typename MapTraits<FW>::ConstReturnValue ConstReturnValue; |
2287 | 2303 |
typedef typename MapTraits<FW>::ReturnValue Reference; |
2288 | 2304 |
typedef typename MapTraits<FW>::ConstReturnValue ConstReference; |
2289 | 2305 |
|
2290 | 2306 |
/// Constructor |
2291 | 2307 |
CombinedArcMap(FW& forward, BK& backward) |
2292 | 2308 |
: _forward(&forward), _backward(&backward) {} |
2293 | 2309 |
|
2294 | 2310 |
/// Sets the value associated with the given key. |
2295 | 2311 |
void set(const Key& e, const Value& a) { |
2296 | 2312 |
if (Parent::direction(e)) { |
2297 | 2313 |
_forward->set(e, a); |
2298 | 2314 |
} else { |
2299 | 2315 |
_backward->set(e, a); |
2300 | 2316 |
} |
2301 | 2317 |
} |
2302 | 2318 |
|
2303 | 2319 |
/// Returns the value associated with the given key. |
2304 | 2320 |
ConstReturnValue operator[](const Key& e) const { |
2305 | 2321 |
if (Parent::direction(e)) { |
2306 | 2322 |
return (*_forward)[e]; |
2307 | 2323 |
} else { |
2308 | 2324 |
return (*_backward)[e]; |
2309 | 2325 |
} |
2310 | 2326 |
} |
2311 | 2327 |
|
2312 | 2328 |
/// Returns a reference to the value associated with the given key. |
2313 | 2329 |
ReturnValue operator[](const Key& e) { |
2314 | 2330 |
if (Parent::direction(e)) { |
2315 | 2331 |
return (*_forward)[e]; |
2316 | 2332 |
} else { |
2317 | 2333 |
return (*_backward)[e]; |
2318 | 2334 |
} |
2319 | 2335 |
} |
2320 | 2336 |
|
2321 | 2337 |
protected: |
2322 | 2338 |
|
2323 | 2339 |
FW* _forward; |
2324 | 2340 |
BK* _backward; |
2325 | 2341 |
|
2326 | 2342 |
}; |
2327 | 2343 |
|
2328 | 2344 |
/// \brief Returns a combined arc map |
2329 | 2345 |
/// |
2330 | 2346 |
/// This function just returns a combined arc map. |
2331 | 2347 |
template <typename FW, typename BK> |
2332 | 2348 |
static CombinedArcMap<FW, BK> |
2333 | 2349 |
combinedArcMap(FW& forward, BK& backward) { |
2334 | 2350 |
return CombinedArcMap<FW, BK>(forward, backward); |
2335 | 2351 |
} |
2336 | 2352 |
|
2337 | 2353 |
template <typename FW, typename BK> |
2338 | 2354 |
static CombinedArcMap<const FW, BK> |
2339 | 2355 |
combinedArcMap(const FW& forward, BK& backward) { |
2340 | 2356 |
return CombinedArcMap<const FW, BK>(forward, backward); |
2341 | 2357 |
} |
2342 | 2358 |
|
2343 | 2359 |
template <typename FW, typename BK> |
2344 | 2360 |
static CombinedArcMap<FW, const BK> |
2345 | 2361 |
combinedArcMap(FW& forward, const BK& backward) { |
2346 | 2362 |
return CombinedArcMap<FW, const BK>(forward, backward); |
2347 | 2363 |
} |
2348 | 2364 |
|
2349 | 2365 |
template <typename FW, typename BK> |
2350 | 2366 |
static CombinedArcMap<const FW, const BK> |
2351 | 2367 |
combinedArcMap(const FW& forward, const BK& backward) { |
2352 | 2368 |
return CombinedArcMap<const FW, const BK>(forward, backward); |
2353 | 2369 |
} |
2354 | 2370 |
|
2355 | 2371 |
}; |
2356 | 2372 |
|
2357 | 2373 |
/// \brief Returns a read-only Undirector adaptor |
2358 | 2374 |
/// |
2359 | 2375 |
/// This function just returns a read-only \ref Undirector adaptor. |
2360 | 2376 |
/// \ingroup graph_adaptors |
2361 | 2377 |
/// \relates Undirector |
2362 | 2378 |
template<typename DGR> |
2363 | 2379 |
Undirector<const DGR> undirector(const DGR& digraph) { |
2364 | 2380 |
return Undirector<const DGR>(digraph); |
2365 | 2381 |
} |
2366 | 2382 |
|
2367 | 2383 |
|
2368 | 2384 |
template <typename GR, typename DM> |
2369 | 2385 |
class OrienterBase { |
2370 | 2386 |
public: |
2371 | 2387 |
|
2372 | 2388 |
typedef GR Graph; |
2373 | 2389 |
typedef DM DirectionMap; |
2374 | 2390 |
|
2375 | 2391 |
typedef typename GR::Node Node; |
2376 | 2392 |
typedef typename GR::Edge Arc; |
2377 | 2393 |
|
2378 | 2394 |
void reverseArc(const Arc& arc) { |
2379 | 2395 |
_direction->set(arc, !(*_direction)[arc]); |
2380 | 2396 |
} |
2381 | 2397 |
|
2382 | 2398 |
void first(Node& i) const { _graph->first(i); } |
2383 | 2399 |
void first(Arc& i) const { _graph->first(i); } |
2384 | 2400 |
void firstIn(Arc& i, const Node& n) const { |
2385 | 2401 |
bool d = true; |
2386 | 2402 |
_graph->firstInc(i, d, n); |
2387 | 2403 |
while (i != INVALID && d == (*_direction)[i]) _graph->nextInc(i, d); |
2388 | 2404 |
} |
2389 | 2405 |
void firstOut(Arc& i, const Node& n ) const { |
2390 | 2406 |
bool d = true; |
2391 | 2407 |
_graph->firstInc(i, d, n); |
2392 | 2408 |
while (i != INVALID && d != (*_direction)[i]) _graph->nextInc(i, d); |
2393 | 2409 |
} |
2394 | 2410 |
|
2395 | 2411 |
void next(Node& i) const { _graph->next(i); } |
2396 | 2412 |
void next(Arc& i) const { _graph->next(i); } |
2397 | 2413 |
void nextIn(Arc& i) const { |
2398 | 2414 |
bool d = !(*_direction)[i]; |
2399 | 2415 |
_graph->nextInc(i, d); |
2400 | 2416 |
while (i != INVALID && d == (*_direction)[i]) _graph->nextInc(i, d); |
2401 | 2417 |
} |
2402 | 2418 |
void nextOut(Arc& i) const { |
2403 | 2419 |
bool d = (*_direction)[i]; |
2404 | 2420 |
_graph->nextInc(i, d); |
2405 | 2421 |
while (i != INVALID && d != (*_direction)[i]) _graph->nextInc(i, d); |
2406 | 2422 |
} |
2407 | 2423 |
|
2408 | 2424 |
Node source(const Arc& e) const { |
2409 | 2425 |
return (*_direction)[e] ? _graph->u(e) : _graph->v(e); |
2410 | 2426 |
} |
2411 | 2427 |
Node target(const Arc& e) const { |
2412 | 2428 |
return (*_direction)[e] ? _graph->v(e) : _graph->u(e); |
2413 | 2429 |
} |
2414 | 2430 |
|
2415 | 2431 |
typedef NodeNumTagIndicator<Graph> NodeNumTag; |
2416 | 2432 |
int nodeNum() const { return _graph->nodeNum(); } |
2417 | 2433 |
|
2418 | 2434 |
typedef EdgeNumTagIndicator<Graph> ArcNumTag; |
2419 | 2435 |
int arcNum() const { return _graph->edgeNum(); } |
2420 | 2436 |
|
2421 | 2437 |
typedef FindEdgeTagIndicator<Graph> FindArcTag; |
2422 | 2438 |
Arc findArc(const Node& u, const Node& v, |
2423 | 2439 |
const Arc& prev = INVALID) const { |
2424 | 2440 |
Arc arc = _graph->findEdge(u, v, prev); |
2425 | 2441 |
while (arc != INVALID && source(arc) != u) { |
2426 | 2442 |
arc = _graph->findEdge(u, v, arc); |
2427 | 2443 |
} |
2428 | 2444 |
return arc; |
2429 | 2445 |
} |
2430 | 2446 |
|
2431 | 2447 |
Node addNode() { |
2432 | 2448 |
return Node(_graph->addNode()); |
2433 | 2449 |
} |
2434 | 2450 |
|
2435 | 2451 |
Arc addArc(const Node& u, const Node& v) { |
2436 | 2452 |
Arc arc = _graph->addEdge(u, v); |
2437 | 2453 |
_direction->set(arc, _graph->u(arc) == u); |
2438 | 2454 |
return arc; |
2439 | 2455 |
} |
2440 | 2456 |
|
2441 | 2457 |
void erase(const Node& i) { _graph->erase(i); } |
2442 | 2458 |
void erase(const Arc& i) { _graph->erase(i); } |
2443 | 2459 |
|
2444 | 2460 |
void clear() { _graph->clear(); } |
2445 | 2461 |
|
2446 | 2462 |
int id(const Node& v) const { return _graph->id(v); } |
2447 | 2463 |
int id(const Arc& e) const { return _graph->id(e); } |
2448 | 2464 |
|
2449 | 2465 |
Node nodeFromId(int idx) const { return _graph->nodeFromId(idx); } |
2450 | 2466 |
Arc arcFromId(int idx) const { return _graph->edgeFromId(idx); } |
2451 | 2467 |
|
2452 | 2468 |
int maxNodeId() const { return _graph->maxNodeId(); } |
2453 | 2469 |
int maxArcId() const { return _graph->maxEdgeId(); } |
2454 | 2470 |
|
2455 | 2471 |
typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier; |
2456 | 2472 |
NodeNotifier& notifier(Node) const { return _graph->notifier(Node()); } |
2457 | 2473 |
|
2458 | 2474 |
typedef typename ItemSetTraits<GR, Arc>::ItemNotifier ArcNotifier; |
2459 | 2475 |
ArcNotifier& notifier(Arc) const { return _graph->notifier(Arc()); } |
2460 | 2476 |
|
2461 | 2477 |
template <typename V> |
2462 | 2478 |
class NodeMap : public GR::template NodeMap<V> { |
2463 | 2479 |
typedef typename GR::template NodeMap<V> Parent; |
2464 | 2480 |
|
2465 | 2481 |
public: |
2466 | 2482 |
|
2467 | 2483 |
explicit NodeMap(const OrienterBase<GR, DM>& adapter) |
2468 | 2484 |
: Parent(*adapter._graph) {} |
2469 | 2485 |
|
2470 | 2486 |
NodeMap(const OrienterBase<GR, DM>& adapter, const V& value) |
2471 | 2487 |
: Parent(*adapter._graph, value) {} |
2472 | 2488 |
|
2473 | 2489 |
private: |
2474 | 2490 |
NodeMap& operator=(const NodeMap& cmap) { |
2475 | 2491 |
return operator=<NodeMap>(cmap); |
2476 | 2492 |
} |
2477 | 2493 |
|
2478 | 2494 |
template <typename CMap> |
2479 | 2495 |
NodeMap& operator=(const CMap& cmap) { |
2480 | 2496 |
Parent::operator=(cmap); |
2481 | 2497 |
return *this; |
2482 | 2498 |
} |
2483 | 2499 |
|
2484 | 2500 |
}; |
2485 | 2501 |
|
2486 | 2502 |
template <typename V> |
2487 | 2503 |
class ArcMap : public GR::template EdgeMap<V> { |
2488 | 2504 |
typedef typename Graph::template EdgeMap<V> Parent; |
2489 | 2505 |
|
2490 | 2506 |
public: |
2491 | 2507 |
|
2492 | 2508 |
explicit ArcMap(const OrienterBase<GR, DM>& adapter) |
2493 | 2509 |
: Parent(*adapter._graph) { } |
2494 | 2510 |
|
2495 | 2511 |
ArcMap(const OrienterBase<GR, DM>& adapter, const V& value) |
2496 | 2512 |
: Parent(*adapter._graph, value) { } |
2497 | 2513 |
|
2498 | 2514 |
private: |
2499 | 2515 |
ArcMap& operator=(const ArcMap& cmap) { |
2500 | 2516 |
return operator=<ArcMap>(cmap); |
2501 | 2517 |
} |
2502 | 2518 |
|
2503 | 2519 |
template <typename CMap> |
2504 | 2520 |
ArcMap& operator=(const CMap& cmap) { |
2505 | 2521 |
Parent::operator=(cmap); |
2506 | 2522 |
return *this; |
2507 | 2523 |
} |
2508 | 2524 |
}; |
2509 | 2525 |
|
2510 | 2526 |
|
2511 | 2527 |
|
2512 | 2528 |
protected: |
2513 | 2529 |
Graph* _graph; |
2514 | 2530 |
DM* _direction; |
2515 | 2531 |
|
2516 | 2532 |
void initialize(GR& graph, DM& direction) { |
2517 | 2533 |
_graph = &graph; |
2518 | 2534 |
_direction = &direction; |
2519 | 2535 |
} |
2520 | 2536 |
|
2521 | 2537 |
}; |
2522 | 2538 |
|
2523 | 2539 |
/// \ingroup graph_adaptors |
2524 | 2540 |
/// |
2525 | 2541 |
/// \brief Adaptor class for orienting the edges of a graph to get a digraph |
2526 | 2542 |
/// |
2527 | 2543 |
/// Orienter adaptor can be used for orienting the edges of a graph to |
2528 | 2544 |
/// get a digraph. A \c bool edge map of the underlying graph must be |
2529 | 2545 |
/// specified, which define the direction of the arcs in the adaptor. |
2530 | 2546 |
/// The arcs can be easily reversed by the \c reverseArc() member function |
2531 | 2547 |
/// of the adaptor. |
2532 | 2548 |
/// This class conforms to the \ref concepts::Digraph "Digraph" concept. |
2533 | 2549 |
/// |
2534 | 2550 |
/// The adapted graph can also be modified through this adaptor |
2535 | 2551 |
/// by adding or removing nodes or arcs, unless the \c GR template |
2536 | 2552 |
/// parameter is set to be \c const. |
2537 | 2553 |
/// |
2554 |
/// This class provides item counting in the same time as the adapted |
|
2555 |
/// graph structure. |
|
2556 |
/// |
|
2538 | 2557 |
/// \tparam GR The type of the adapted graph. |
2539 | 2558 |
/// It must conform to the \ref concepts::Graph "Graph" concept. |
2540 | 2559 |
/// It can also be specified to be \c const. |
2541 | 2560 |
/// \tparam DM The type of the direction map. |
2542 | 2561 |
/// It must be a \c bool (or convertible) edge map of the |
2543 | 2562 |
/// adapted graph. The default type is |
2544 | 2563 |
/// \ref concepts::Graph::EdgeMap "GR::EdgeMap<bool>". |
2545 | 2564 |
/// |
2546 | 2565 |
/// \note The \c Node type of this adaptor and the adapted graph are |
2547 | 2566 |
/// convertible to each other, moreover the \c Arc type of the adaptor |
2548 | 2567 |
/// and the \c Edge type of the adapted graph are also convertible to |
2549 | 2568 |
/// each other. |
2550 | 2569 |
#ifdef DOXYGEN |
2551 | 2570 |
template<typename GR, |
2552 | 2571 |
typename DM> |
2553 | 2572 |
class Orienter { |
2554 | 2573 |
#else |
2555 | 2574 |
template<typename GR, |
2556 | 2575 |
typename DM = typename GR::template EdgeMap<bool> > |
2557 | 2576 |
class Orienter : |
2558 | 2577 |
public DigraphAdaptorExtender<OrienterBase<GR, DM> > { |
2559 | 2578 |
#endif |
2560 | 2579 |
typedef DigraphAdaptorExtender<OrienterBase<GR, DM> > Parent; |
2561 | 2580 |
public: |
2562 | 2581 |
|
2563 | 2582 |
/// The type of the adapted graph. |
2564 | 2583 |
typedef GR Graph; |
2565 | 2584 |
/// The type of the direction edge map. |
2566 | 2585 |
typedef DM DirectionMap; |
2567 | 2586 |
|
2568 | 2587 |
typedef typename Parent::Arc Arc; |
2569 | 2588 |
|
2570 | 2589 |
protected: |
2571 | 2590 |
Orienter() { } |
2572 | 2591 |
|
2573 | 2592 |
public: |
2574 | 2593 |
|
2575 | 2594 |
/// \brief Constructor |
2576 | 2595 |
/// |
2577 | 2596 |
/// Constructor of the adaptor. |
2578 | 2597 |
Orienter(GR& graph, DM& direction) { |
2579 | 2598 |
Parent::initialize(graph, direction); |
2580 | 2599 |
} |
2581 | 2600 |
|
2582 | 2601 |
/// \brief Reverses the given arc |
2583 | 2602 |
/// |
2584 | 2603 |
/// This function reverses the given arc. |
2585 | 2604 |
/// It is done by simply negate the assigned value of \c a |
2586 | 2605 |
/// in the direction map. |
2587 | 2606 |
void reverseArc(const Arc& a) { |
2588 | 2607 |
Parent::reverseArc(a); |
2589 | 2608 |
} |
2590 | 2609 |
}; |
2591 | 2610 |
|
2592 | 2611 |
/// \brief Returns a read-only Orienter adaptor |
2593 | 2612 |
/// |
2594 | 2613 |
/// This function just returns a read-only \ref Orienter adaptor. |
2595 | 2614 |
/// \ingroup graph_adaptors |
2596 | 2615 |
/// \relates Orienter |
2597 | 2616 |
template<typename GR, typename DM> |
2598 | 2617 |
Orienter<const GR, DM> |
2599 | 2618 |
orienter(const GR& graph, DM& direction) { |
2600 | 2619 |
return Orienter<const GR, DM>(graph, direction); |
2601 | 2620 |
} |
2602 | 2621 |
|
2603 | 2622 |
template<typename GR, typename DM> |
2604 | 2623 |
Orienter<const GR, const DM> |
2605 | 2624 |
orienter(const GR& graph, const DM& direction) { |
2606 | 2625 |
return Orienter<const GR, const DM>(graph, direction); |
2607 | 2626 |
} |
2608 | 2627 |
|
2609 | 2628 |
namespace _adaptor_bits { |
2610 | 2629 |
|
2611 | 2630 |
template <typename DGR, typename CM, typename FM, typename TL> |
2612 | 2631 |
class ResForwardFilter { |
2613 | 2632 |
public: |
2614 | 2633 |
|
2615 | 2634 |
typedef typename DGR::Arc Key; |
2616 | 2635 |
typedef bool Value; |
2617 | 2636 |
|
2618 | 2637 |
private: |
2619 | 2638 |
|
2620 | 2639 |
const CM* _capacity; |
2621 | 2640 |
const FM* _flow; |
2622 | 2641 |
TL _tolerance; |
2623 | 2642 |
|
2624 | 2643 |
public: |
2625 | 2644 |
|
2626 | 2645 |
ResForwardFilter(const CM& capacity, const FM& flow, |
2627 | 2646 |
const TL& tolerance = TL()) |
2628 | 2647 |
: _capacity(&capacity), _flow(&flow), _tolerance(tolerance) { } |
2629 | 2648 |
|
2630 | 2649 |
bool operator[](const typename DGR::Arc& a) const { |
2631 | 2650 |
return _tolerance.positive((*_capacity)[a] - (*_flow)[a]); |
2632 | 2651 |
} |
2633 | 2652 |
}; |
2634 | 2653 |
|
2635 | 2654 |
template<typename DGR,typename CM, typename FM, typename TL> |
2636 | 2655 |
class ResBackwardFilter { |
2637 | 2656 |
public: |
2638 | 2657 |
|
2639 | 2658 |
typedef typename DGR::Arc Key; |
2640 | 2659 |
typedef bool Value; |
2641 | 2660 |
|
2642 | 2661 |
private: |
2643 | 2662 |
|
2644 | 2663 |
const CM* _capacity; |
2645 | 2664 |
const FM* _flow; |
2646 | 2665 |
TL _tolerance; |
2647 | 2666 |
|
2648 | 2667 |
public: |
2649 | 2668 |
|
2650 | 2669 |
ResBackwardFilter(const CM& capacity, const FM& flow, |
2651 | 2670 |
const TL& tolerance = TL()) |
2652 | 2671 |
: _capacity(&capacity), _flow(&flow), _tolerance(tolerance) { } |
2653 | 2672 |
|
2654 | 2673 |
bool operator[](const typename DGR::Arc& a) const { |
2655 | 2674 |
return _tolerance.positive((*_flow)[a]); |
2656 | 2675 |
} |
2657 | 2676 |
}; |
2658 | 2677 |
|
2659 | 2678 |
} |
2660 | 2679 |
|
2661 | 2680 |
/// \ingroup graph_adaptors |
2662 | 2681 |
/// |
2663 | 2682 |
/// \brief Adaptor class for composing the residual digraph for directed |
2664 | 2683 |
/// flow and circulation problems. |
2665 | 2684 |
/// |
2666 | 2685 |
/// ResidualDigraph can be used for composing the \e residual digraph |
2667 | 2686 |
/// for directed flow and circulation problems. Let \f$ G=(V, A) \f$ |
2668 | 2687 |
/// be a directed graph and let \f$ F \f$ be a number type. |
2669 | 2688 |
/// Let \f$ flow, cap: A\to F \f$ be functions on the arcs. |
2670 | 2689 |
/// This adaptor implements a digraph structure with node set \f$ V \f$ |
2671 | 2690 |
/// and arc set \f$ A_{forward}\cup A_{backward} \f$, |
2672 | 2691 |
/// where \f$ A_{forward}=\{uv : uv\in A, flow(uv)<cap(uv)\} \f$ and |
2673 | 2692 |
/// \f$ A_{backward}=\{vu : uv\in A, flow(uv)>0\} \f$, i.e. the so |
2674 | 2693 |
/// called residual digraph. |
2675 | 2694 |
/// When the union \f$ A_{forward}\cup A_{backward} \f$ is taken, |
2676 | 2695 |
/// multiplicities are counted, i.e. the adaptor has exactly |
2677 | 2696 |
/// \f$ |A_{forward}| + |A_{backward}|\f$ arcs (it may have parallel |
2678 | 2697 |
/// arcs). |
2679 | 2698 |
/// This class conforms to the \ref concepts::Digraph "Digraph" concept. |
2680 | 2699 |
/// |
2700 |
/// This class provides only linear time counting for nodes and arcs. |
|
2701 |
/// |
|
2681 | 2702 |
/// \tparam DGR The type of the adapted digraph. |
2682 | 2703 |
/// It must conform to the \ref concepts::Digraph "Digraph" concept. |
2683 | 2704 |
/// It is implicitly \c const. |
2684 | 2705 |
/// \tparam CM The type of the capacity map. |
2685 | 2706 |
/// It must be an arc map of some numerical type, which defines |
2686 | 2707 |
/// the capacities in the flow problem. It is implicitly \c const. |
2687 | 2708 |
/// The default type is |
2688 | 2709 |
/// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>". |
2689 | 2710 |
/// \tparam FM The type of the flow map. |
2690 | 2711 |
/// It must be an arc map of some numerical type, which defines |
2691 | 2712 |
/// the flow values in the flow problem. The default type is \c CM. |
2692 | 2713 |
/// \tparam TL The tolerance type for handling inexact computation. |
2693 | 2714 |
/// The default tolerance type depends on the value type of the |
2694 | 2715 |
/// capacity map. |
2695 | 2716 |
/// |
2696 | 2717 |
/// \note This adaptor is implemented using Undirector and FilterArcs |
2697 | 2718 |
/// adaptors. |
2698 | 2719 |
/// |
2699 | 2720 |
/// \note The \c Node type of this adaptor and the adapted digraph are |
2700 | 2721 |
/// convertible to each other, moreover the \c Arc type of the adaptor |
2701 | 2722 |
/// is convertible to the \c Arc type of the adapted digraph. |
2702 | 2723 |
#ifdef DOXYGEN |
2703 | 2724 |
template<typename DGR, typename CM, typename FM, typename TL> |
2704 | 2725 |
class ResidualDigraph |
2705 | 2726 |
#else |
2706 | 2727 |
template<typename DGR, |
2707 | 2728 |
typename CM = typename DGR::template ArcMap<int>, |
2708 | 2729 |
typename FM = CM, |
2709 | 2730 |
typename TL = Tolerance<typename CM::Value> > |
2710 | 2731 |
class ResidualDigraph |
2711 | 2732 |
: public SubDigraph< |
2712 | 2733 |
Undirector<const DGR>, |
2713 | 2734 |
ConstMap<typename DGR::Node, Const<bool, true> >, |
2714 | 2735 |
typename Undirector<const DGR>::template CombinedArcMap< |
2715 | 2736 |
_adaptor_bits::ResForwardFilter<const DGR, CM, FM, TL>, |
2716 | 2737 |
_adaptor_bits::ResBackwardFilter<const DGR, CM, FM, TL> > > |
2717 | 2738 |
#endif |
2718 | 2739 |
{ |
2719 | 2740 |
public: |
2720 | 2741 |
|
2721 | 2742 |
/// The type of the underlying digraph. |
2722 | 2743 |
typedef DGR Digraph; |
2723 | 2744 |
/// The type of the capacity map. |
2724 | 2745 |
typedef CM CapacityMap; |
2725 | 2746 |
/// The type of the flow map. |
2726 | 2747 |
typedef FM FlowMap; |
2727 | 2748 |
/// The tolerance type. |
2728 | 2749 |
typedef TL Tolerance; |
2729 | 2750 |
|
2730 | 2751 |
typedef typename CapacityMap::Value Value; |
2731 | 2752 |
typedef ResidualDigraph Adaptor; |
2732 | 2753 |
|
2733 | 2754 |
protected: |
2734 | 2755 |
|
2735 | 2756 |
typedef Undirector<const Digraph> Undirected; |
2736 | 2757 |
|
2737 | 2758 |
typedef ConstMap<typename DGR::Node, Const<bool, true> > NodeFilter; |
2738 | 2759 |
|
2739 | 2760 |
typedef _adaptor_bits::ResForwardFilter<const DGR, CM, |
2740 | 2761 |
FM, TL> ForwardFilter; |
2741 | 2762 |
|
2742 | 2763 |
typedef _adaptor_bits::ResBackwardFilter<const DGR, CM, |
2743 | 2764 |
FM, TL> BackwardFilter; |
2744 | 2765 |
|
2745 | 2766 |
typedef typename Undirected:: |
2746 | 2767 |
template CombinedArcMap<ForwardFilter, BackwardFilter> ArcFilter; |
2747 | 2768 |
|
2748 | 2769 |
typedef SubDigraph<Undirected, NodeFilter, ArcFilter> Parent; |
2749 | 2770 |
|
2750 | 2771 |
const CapacityMap* _capacity; |
2751 | 2772 |
FlowMap* _flow; |
2752 | 2773 |
|
2753 | 2774 |
Undirected _graph; |
2754 | 2775 |
NodeFilter _node_filter; |
2755 | 2776 |
ForwardFilter _forward_filter; |
2756 | 2777 |
BackwardFilter _backward_filter; |
2757 | 2778 |
ArcFilter _arc_filter; |
2758 | 2779 |
|
2759 | 2780 |
public: |
2760 | 2781 |
|
2761 | 2782 |
/// \brief Constructor |
2762 | 2783 |
/// |
2763 | 2784 |
/// Constructor of the residual digraph adaptor. The parameters are the |
2764 | 2785 |
/// digraph, the capacity map, the flow map, and a tolerance object. |
2765 | 2786 |
ResidualDigraph(const DGR& digraph, const CM& capacity, |
2766 | 2787 |
FM& flow, const TL& tolerance = Tolerance()) |
2767 | 2788 |
: Parent(), _capacity(&capacity), _flow(&flow), |
2768 | 2789 |
_graph(digraph), _node_filter(), |
2769 | 2790 |
_forward_filter(capacity, flow, tolerance), |
2770 | 2791 |
_backward_filter(capacity, flow, tolerance), |
2771 | 2792 |
_arc_filter(_forward_filter, _backward_filter) |
2772 | 2793 |
{ |
2773 | 2794 |
Parent::initialize(_graph, _node_filter, _arc_filter); |
2774 | 2795 |
} |
2775 | 2796 |
|
2776 | 2797 |
typedef typename Parent::Arc Arc; |
2777 | 2798 |
|
2778 | 2799 |
/// \brief Returns the residual capacity of the given arc. |
2779 | 2800 |
/// |
2780 | 2801 |
/// Returns the residual capacity of the given arc. |
2781 | 2802 |
Value residualCapacity(const Arc& a) const { |
2782 | 2803 |
if (Undirected::direction(a)) { |
2783 | 2804 |
return (*_capacity)[a] - (*_flow)[a]; |
2784 | 2805 |
} else { |
2785 | 2806 |
return (*_flow)[a]; |
2786 | 2807 |
} |
2787 | 2808 |
} |
2788 | 2809 |
|
2789 | 2810 |
/// \brief Augments on the given arc in the residual digraph. |
2790 | 2811 |
/// |
2791 | 2812 |
/// Augments on the given arc in the residual digraph. It increases |
2792 | 2813 |
/// or decreases the flow value on the original arc according to the |
2793 | 2814 |
/// direction of the residual arc. |
2794 | 2815 |
void augment(const Arc& a, const Value& v) const { |
2795 | 2816 |
if (Undirected::direction(a)) { |
2796 | 2817 |
_flow->set(a, (*_flow)[a] + v); |
2797 | 2818 |
} else { |
2798 | 2819 |
_flow->set(a, (*_flow)[a] - v); |
2799 | 2820 |
} |
2800 | 2821 |
} |
2801 | 2822 |
|
2802 | 2823 |
/// \brief Returns \c true if the given residual arc is a forward arc. |
2803 | 2824 |
/// |
2804 | 2825 |
/// Returns \c true if the given residual arc has the same orientation |
2805 | 2826 |
/// as the original arc, i.e. it is a so called forward arc. |
2806 | 2827 |
static bool forward(const Arc& a) { |
2807 | 2828 |
return Undirected::direction(a); |
2808 | 2829 |
} |
2809 | 2830 |
|
2810 | 2831 |
/// \brief Returns \c true if the given residual arc is a backward arc. |
2811 | 2832 |
/// |
2812 | 2833 |
/// Returns \c true if the given residual arc has the opposite orientation |
2813 | 2834 |
/// than the original arc, i.e. it is a so called backward arc. |
2814 | 2835 |
static bool backward(const Arc& a) { |
2815 | 2836 |
return !Undirected::direction(a); |
2816 | 2837 |
} |
2817 | 2838 |
|
2818 | 2839 |
/// \brief Returns the forward oriented residual arc. |
2819 | 2840 |
/// |
2820 | 2841 |
/// Returns the forward oriented residual arc related to the given |
2821 | 2842 |
/// arc of the underlying digraph. |
2822 | 2843 |
static Arc forward(const typename Digraph::Arc& a) { |
2823 | 2844 |
return Undirected::direct(a, true); |
2824 | 2845 |
} |
2825 | 2846 |
|
2826 | 2847 |
/// \brief Returns the backward oriented residual arc. |
2827 | 2848 |
/// |
2828 | 2849 |
/// Returns the backward oriented residual arc related to the given |
2829 | 2850 |
/// arc of the underlying digraph. |
2830 | 2851 |
static Arc backward(const typename Digraph::Arc& a) { |
2831 | 2852 |
return Undirected::direct(a, false); |
2832 | 2853 |
} |
2833 | 2854 |
|
2834 | 2855 |
/// \brief Residual capacity map. |
2835 | 2856 |
/// |
2836 | 2857 |
/// This map adaptor class can be used for obtaining the residual |
2837 | 2858 |
/// capacities as an arc map of the residual digraph. |
2838 | 2859 |
/// Its value type is inherited from the capacity map. |
2839 | 2860 |
class ResidualCapacity { |
2840 | 2861 |
protected: |
2841 | 2862 |
const Adaptor* _adaptor; |
2842 | 2863 |
public: |
2843 | 2864 |
/// The key type of the map |
2844 | 2865 |
typedef Arc Key; |
2845 | 2866 |
/// The value type of the map |
2846 | 2867 |
typedef typename CapacityMap::Value Value; |
2847 | 2868 |
|
2848 | 2869 |
/// Constructor |
2849 | 2870 |
ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor) |
2850 | 2871 |
: _adaptor(&adaptor) {} |
2851 | 2872 |
|
2852 | 2873 |
/// Returns the value associated with the given residual arc |
2853 | 2874 |
Value operator[](const Arc& a) const { |
2854 | 2875 |
return _adaptor->residualCapacity(a); |
2855 | 2876 |
} |
2856 | 2877 |
|
2857 | 2878 |
}; |
2858 | 2879 |
|
2859 | 2880 |
/// \brief Returns a residual capacity map |
2860 | 2881 |
/// |
2861 | 2882 |
/// This function just returns a residual capacity map. |
2862 | 2883 |
ResidualCapacity residualCapacity() const { |
2863 | 2884 |
return ResidualCapacity(*this); |
2864 | 2885 |
} |
2865 | 2886 |
|
2866 | 2887 |
}; |
2867 | 2888 |
|
2868 | 2889 |
/// \brief Returns a (read-only) Residual adaptor |
2869 | 2890 |
/// |
2870 | 2891 |
/// This function just returns a (read-only) \ref ResidualDigraph adaptor. |
2871 | 2892 |
/// \ingroup graph_adaptors |
2872 | 2893 |
/// \relates ResidualDigraph |
... | ... |
@@ -3136,384 +3157,387 @@ |
3136 | 3157 |
|
3137 | 3158 |
typedef True FindArcTag; |
3138 | 3159 |
Arc findArc(const Node& u, const Node& v, |
3139 | 3160 |
const Arc& prev = INVALID) const { |
3140 | 3161 |
if (inNode(u) && outNode(v)) { |
3141 | 3162 |
if (static_cast<const DigraphNode&>(u) == |
3142 | 3163 |
static_cast<const DigraphNode&>(v) && prev == INVALID) { |
3143 | 3164 |
return Arc(u); |
3144 | 3165 |
} |
3145 | 3166 |
} |
3146 | 3167 |
else if (outNode(u) && inNode(v)) { |
3147 | 3168 |
return Arc(::lemon::findArc(*_digraph, u, v, prev)); |
3148 | 3169 |
} |
3149 | 3170 |
return INVALID; |
3150 | 3171 |
} |
3151 | 3172 |
|
3152 | 3173 |
private: |
3153 | 3174 |
|
3154 | 3175 |
template <typename V> |
3155 | 3176 |
class NodeMapBase |
3156 | 3177 |
: public MapTraits<typename Parent::template NodeMap<V> > { |
3157 | 3178 |
typedef typename Parent::template NodeMap<V> NodeImpl; |
3158 | 3179 |
public: |
3159 | 3180 |
typedef Node Key; |
3160 | 3181 |
typedef V Value; |
3161 | 3182 |
typedef typename MapTraits<NodeImpl>::ReferenceMapTag ReferenceMapTag; |
3162 | 3183 |
typedef typename MapTraits<NodeImpl>::ReturnValue ReturnValue; |
3163 | 3184 |
typedef typename MapTraits<NodeImpl>::ConstReturnValue ConstReturnValue; |
3164 | 3185 |
typedef typename MapTraits<NodeImpl>::ReturnValue Reference; |
3165 | 3186 |
typedef typename MapTraits<NodeImpl>::ConstReturnValue ConstReference; |
3166 | 3187 |
|
3167 | 3188 |
NodeMapBase(const SplitNodesBase<DGR>& adaptor) |
3168 | 3189 |
: _in_map(*adaptor._digraph), _out_map(*adaptor._digraph) {} |
3169 | 3190 |
NodeMapBase(const SplitNodesBase<DGR>& adaptor, const V& value) |
3170 | 3191 |
: _in_map(*adaptor._digraph, value), |
3171 | 3192 |
_out_map(*adaptor._digraph, value) {} |
3172 | 3193 |
|
3173 | 3194 |
void set(const Node& key, const V& val) { |
3174 | 3195 |
if (SplitNodesBase<DGR>::inNode(key)) { _in_map.set(key, val); } |
3175 | 3196 |
else {_out_map.set(key, val); } |
3176 | 3197 |
} |
3177 | 3198 |
|
3178 | 3199 |
ReturnValue operator[](const Node& key) { |
3179 | 3200 |
if (SplitNodesBase<DGR>::inNode(key)) { return _in_map[key]; } |
3180 | 3201 |
else { return _out_map[key]; } |
3181 | 3202 |
} |
3182 | 3203 |
|
3183 | 3204 |
ConstReturnValue operator[](const Node& key) const { |
3184 | 3205 |
if (Adaptor::inNode(key)) { return _in_map[key]; } |
3185 | 3206 |
else { return _out_map[key]; } |
3186 | 3207 |
} |
3187 | 3208 |
|
3188 | 3209 |
private: |
3189 | 3210 |
NodeImpl _in_map, _out_map; |
3190 | 3211 |
}; |
3191 | 3212 |
|
3192 | 3213 |
template <typename V> |
3193 | 3214 |
class ArcMapBase |
3194 | 3215 |
: public MapTraits<typename Parent::template ArcMap<V> > { |
3195 | 3216 |
typedef typename Parent::template ArcMap<V> ArcImpl; |
3196 | 3217 |
typedef typename Parent::template NodeMap<V> NodeImpl; |
3197 | 3218 |
public: |
3198 | 3219 |
typedef Arc Key; |
3199 | 3220 |
typedef V Value; |
3200 | 3221 |
typedef typename MapTraits<ArcImpl>::ReferenceMapTag ReferenceMapTag; |
3201 | 3222 |
typedef typename MapTraits<ArcImpl>::ReturnValue ReturnValue; |
3202 | 3223 |
typedef typename MapTraits<ArcImpl>::ConstReturnValue ConstReturnValue; |
3203 | 3224 |
typedef typename MapTraits<ArcImpl>::ReturnValue Reference; |
3204 | 3225 |
typedef typename MapTraits<ArcImpl>::ConstReturnValue ConstReference; |
3205 | 3226 |
|
3206 | 3227 |
ArcMapBase(const SplitNodesBase<DGR>& adaptor) |
3207 | 3228 |
: _arc_map(*adaptor._digraph), _node_map(*adaptor._digraph) {} |
3208 | 3229 |
ArcMapBase(const SplitNodesBase<DGR>& adaptor, const V& value) |
3209 | 3230 |
: _arc_map(*adaptor._digraph, value), |
3210 | 3231 |
_node_map(*adaptor._digraph, value) {} |
3211 | 3232 |
|
3212 | 3233 |
void set(const Arc& key, const V& val) { |
3213 | 3234 |
if (SplitNodesBase<DGR>::origArc(key)) { |
3214 | 3235 |
_arc_map.set(static_cast<const DigraphArc&>(key), val); |
3215 | 3236 |
} else { |
3216 | 3237 |
_node_map.set(static_cast<const DigraphNode&>(key), val); |
3217 | 3238 |
} |
3218 | 3239 |
} |
3219 | 3240 |
|
3220 | 3241 |
ReturnValue operator[](const Arc& key) { |
3221 | 3242 |
if (SplitNodesBase<DGR>::origArc(key)) { |
3222 | 3243 |
return _arc_map[static_cast<const DigraphArc&>(key)]; |
3223 | 3244 |
} else { |
3224 | 3245 |
return _node_map[static_cast<const DigraphNode&>(key)]; |
3225 | 3246 |
} |
3226 | 3247 |
} |
3227 | 3248 |
|
3228 | 3249 |
ConstReturnValue operator[](const Arc& key) const { |
3229 | 3250 |
if (SplitNodesBase<DGR>::origArc(key)) { |
3230 | 3251 |
return _arc_map[static_cast<const DigraphArc&>(key)]; |
3231 | 3252 |
} else { |
3232 | 3253 |
return _node_map[static_cast<const DigraphNode&>(key)]; |
3233 | 3254 |
} |
3234 | 3255 |
} |
3235 | 3256 |
|
3236 | 3257 |
private: |
3237 | 3258 |
ArcImpl _arc_map; |
3238 | 3259 |
NodeImpl _node_map; |
3239 | 3260 |
}; |
3240 | 3261 |
|
3241 | 3262 |
public: |
3242 | 3263 |
|
3243 | 3264 |
template <typename V> |
3244 | 3265 |
class NodeMap |
3245 | 3266 |
: public SubMapExtender<SplitNodesBase<DGR>, NodeMapBase<V> > { |
3246 | 3267 |
typedef SubMapExtender<SplitNodesBase<DGR>, NodeMapBase<V> > Parent; |
3247 | 3268 |
|
3248 | 3269 |
public: |
3249 | 3270 |
typedef V Value; |
3250 | 3271 |
|
3251 | 3272 |
NodeMap(const SplitNodesBase<DGR>& adaptor) |
3252 | 3273 |
: Parent(adaptor) {} |
3253 | 3274 |
|
3254 | 3275 |
NodeMap(const SplitNodesBase<DGR>& adaptor, const V& value) |
3255 | 3276 |
: Parent(adaptor, value) {} |
3256 | 3277 |
|
3257 | 3278 |
private: |
3258 | 3279 |
NodeMap& operator=(const NodeMap& cmap) { |
3259 | 3280 |
return operator=<NodeMap>(cmap); |
3260 | 3281 |
} |
3261 | 3282 |
|
3262 | 3283 |
template <typename CMap> |
3263 | 3284 |
NodeMap& operator=(const CMap& cmap) { |
3264 | 3285 |
Parent::operator=(cmap); |
3265 | 3286 |
return *this; |
3266 | 3287 |
} |
3267 | 3288 |
}; |
3268 | 3289 |
|
3269 | 3290 |
template <typename V> |
3270 | 3291 |
class ArcMap |
3271 | 3292 |
: public SubMapExtender<SplitNodesBase<DGR>, ArcMapBase<V> > { |
3272 | 3293 |
typedef SubMapExtender<SplitNodesBase<DGR>, ArcMapBase<V> > Parent; |
3273 | 3294 |
|
3274 | 3295 |
public: |
3275 | 3296 |
typedef V Value; |
3276 | 3297 |
|
3277 | 3298 |
ArcMap(const SplitNodesBase<DGR>& adaptor) |
3278 | 3299 |
: Parent(adaptor) {} |
3279 | 3300 |
|
3280 | 3301 |
ArcMap(const SplitNodesBase<DGR>& adaptor, const V& value) |
3281 | 3302 |
: Parent(adaptor, value) {} |
3282 | 3303 |
|
3283 | 3304 |
private: |
3284 | 3305 |
ArcMap& operator=(const ArcMap& cmap) { |
3285 | 3306 |
return operator=<ArcMap>(cmap); |
3286 | 3307 |
} |
3287 | 3308 |
|
3288 | 3309 |
template <typename CMap> |
3289 | 3310 |
ArcMap& operator=(const CMap& cmap) { |
3290 | 3311 |
Parent::operator=(cmap); |
3291 | 3312 |
return *this; |
3292 | 3313 |
} |
3293 | 3314 |
}; |
3294 | 3315 |
|
3295 | 3316 |
protected: |
3296 | 3317 |
|
3297 | 3318 |
SplitNodesBase() : _digraph(0) {} |
3298 | 3319 |
|
3299 | 3320 |
DGR* _digraph; |
3300 | 3321 |
|
3301 | 3322 |
void initialize(Digraph& digraph) { |
3302 | 3323 |
_digraph = &digraph; |
3303 | 3324 |
} |
3304 | 3325 |
|
3305 | 3326 |
}; |
3306 | 3327 |
|
3307 | 3328 |
/// \ingroup graph_adaptors |
3308 | 3329 |
/// |
3309 | 3330 |
/// \brief Adaptor class for splitting the nodes of a digraph. |
3310 | 3331 |
/// |
3311 | 3332 |
/// SplitNodes adaptor can be used for splitting each node into an |
3312 | 3333 |
/// \e in-node and an \e out-node in a digraph. Formaly, the adaptor |
3313 | 3334 |
/// replaces each node \f$ u \f$ in the digraph with two nodes, |
3314 | 3335 |
/// namely node \f$ u_{in} \f$ and node \f$ u_{out} \f$. |
3315 | 3336 |
/// If there is a \f$ (v, u) \f$ arc in the original digraph, then the |
3316 | 3337 |
/// new target of the arc will be \f$ u_{in} \f$ and similarly the |
3317 | 3338 |
/// source of each original \f$ (u, v) \f$ arc will be \f$ u_{out} \f$. |
3318 | 3339 |
/// The adaptor adds an additional \e bind \e arc from \f$ u_{in} \f$ |
3319 | 3340 |
/// to \f$ u_{out} \f$ for each node \f$ u \f$ of the original digraph. |
3320 | 3341 |
/// |
3321 | 3342 |
/// The aim of this class is running an algorithm with respect to node |
3322 | 3343 |
/// costs or capacities if the algorithm considers only arc costs or |
3323 | 3344 |
/// capacities directly. |
3324 | 3345 |
/// In this case you can use \c SplitNodes adaptor, and set the node |
3325 | 3346 |
/// costs/capacities of the original digraph to the \e bind \e arcs |
3326 | 3347 |
/// in the adaptor. |
3327 | 3348 |
/// |
3349 |
/// This class provides item counting in the same time as the adapted |
|
3350 |
/// digraph structure. |
|
3351 |
/// |
|
3328 | 3352 |
/// \tparam DGR The type of the adapted digraph. |
3329 | 3353 |
/// It must conform to the \ref concepts::Digraph "Digraph" concept. |
3330 | 3354 |
/// It is implicitly \c const. |
3331 | 3355 |
/// |
3332 | 3356 |
/// \note The \c Node type of this adaptor is converible to the \c Node |
3333 | 3357 |
/// type of the adapted digraph. |
3334 | 3358 |
template <typename DGR> |
3335 | 3359 |
#ifdef DOXYGEN |
3336 | 3360 |
class SplitNodes { |
3337 | 3361 |
#else |
3338 | 3362 |
class SplitNodes |
3339 | 3363 |
: public DigraphAdaptorExtender<SplitNodesBase<const DGR> > { |
3340 | 3364 |
#endif |
3341 | 3365 |
typedef DigraphAdaptorExtender<SplitNodesBase<const DGR> > Parent; |
3342 | 3366 |
|
3343 | 3367 |
public: |
3344 | 3368 |
typedef DGR Digraph; |
3345 | 3369 |
|
3346 | 3370 |
typedef typename DGR::Node DigraphNode; |
3347 | 3371 |
typedef typename DGR::Arc DigraphArc; |
3348 | 3372 |
|
3349 | 3373 |
typedef typename Parent::Node Node; |
3350 | 3374 |
typedef typename Parent::Arc Arc; |
3351 | 3375 |
|
3352 | 3376 |
/// \brief Constructor |
3353 | 3377 |
/// |
3354 | 3378 |
/// Constructor of the adaptor. |
3355 | 3379 |
SplitNodes(const DGR& g) { |
3356 | 3380 |
Parent::initialize(g); |
3357 | 3381 |
} |
3358 | 3382 |
|
3359 | 3383 |
/// \brief Returns \c true if the given node is an in-node. |
3360 | 3384 |
/// |
3361 | 3385 |
/// Returns \c true if the given node is an in-node. |
3362 | 3386 |
static bool inNode(const Node& n) { |
3363 | 3387 |
return Parent::inNode(n); |
3364 | 3388 |
} |
3365 | 3389 |
|
3366 | 3390 |
/// \brief Returns \c true if the given node is an out-node. |
3367 | 3391 |
/// |
3368 | 3392 |
/// Returns \c true if the given node is an out-node. |
3369 | 3393 |
static bool outNode(const Node& n) { |
3370 | 3394 |
return Parent::outNode(n); |
3371 | 3395 |
} |
3372 | 3396 |
|
3373 | 3397 |
/// \brief Returns \c true if the given arc is an original arc. |
3374 | 3398 |
/// |
3375 | 3399 |
/// Returns \c true if the given arc is one of the arcs in the |
3376 | 3400 |
/// original digraph. |
3377 | 3401 |
static bool origArc(const Arc& a) { |
3378 | 3402 |
return Parent::origArc(a); |
3379 | 3403 |
} |
3380 | 3404 |
|
3381 | 3405 |
/// \brief Returns \c true if the given arc is a bind arc. |
3382 | 3406 |
/// |
3383 | 3407 |
/// Returns \c true if the given arc is a bind arc, i.e. it connects |
3384 | 3408 |
/// an in-node and an out-node. |
3385 | 3409 |
static bool bindArc(const Arc& a) { |
3386 | 3410 |
return Parent::bindArc(a); |
3387 | 3411 |
} |
3388 | 3412 |
|
3389 | 3413 |
/// \brief Returns the in-node created from the given original node. |
3390 | 3414 |
/// |
3391 | 3415 |
/// Returns the in-node created from the given original node. |
3392 | 3416 |
static Node inNode(const DigraphNode& n) { |
3393 | 3417 |
return Parent::inNode(n); |
3394 | 3418 |
} |
3395 | 3419 |
|
3396 | 3420 |
/// \brief Returns the out-node created from the given original node. |
3397 | 3421 |
/// |
3398 | 3422 |
/// Returns the out-node created from the given original node. |
3399 | 3423 |
static Node outNode(const DigraphNode& n) { |
3400 | 3424 |
return Parent::outNode(n); |
3401 | 3425 |
} |
3402 | 3426 |
|
3403 | 3427 |
/// \brief Returns the bind arc that corresponds to the given |
3404 | 3428 |
/// original node. |
3405 | 3429 |
/// |
3406 | 3430 |
/// Returns the bind arc in the adaptor that corresponds to the given |
3407 | 3431 |
/// original node, i.e. the arc connecting the in-node and out-node |
3408 | 3432 |
/// of \c n. |
3409 | 3433 |
static Arc arc(const DigraphNode& n) { |
3410 | 3434 |
return Parent::arc(n); |
3411 | 3435 |
} |
3412 | 3436 |
|
3413 | 3437 |
/// \brief Returns the arc that corresponds to the given original arc. |
3414 | 3438 |
/// |
3415 | 3439 |
/// Returns the arc in the adaptor that corresponds to the given |
3416 | 3440 |
/// original arc. |
3417 | 3441 |
static Arc arc(const DigraphArc& a) { |
3418 | 3442 |
return Parent::arc(a); |
3419 | 3443 |
} |
3420 | 3444 |
|
3421 | 3445 |
/// \brief Node map combined from two original node maps |
3422 | 3446 |
/// |
3423 | 3447 |
/// This map adaptor class adapts two node maps of the original digraph |
3424 | 3448 |
/// to get a node map of the split digraph. |
3425 | 3449 |
/// Its value type is inherited from the first node map type (\c IN). |
3426 | 3450 |
/// \tparam IN The type of the node map for the in-nodes. |
3427 | 3451 |
/// \tparam OUT The type of the node map for the out-nodes. |
3428 | 3452 |
template <typename IN, typename OUT> |
3429 | 3453 |
class CombinedNodeMap { |
3430 | 3454 |
public: |
3431 | 3455 |
|
3432 | 3456 |
/// The key type of the map |
3433 | 3457 |
typedef Node Key; |
3434 | 3458 |
/// The value type of the map |
3435 | 3459 |
typedef typename IN::Value Value; |
3436 | 3460 |
|
3437 | 3461 |
typedef typename MapTraits<IN>::ReferenceMapTag ReferenceMapTag; |
3438 | 3462 |
typedef typename MapTraits<IN>::ReturnValue ReturnValue; |
3439 | 3463 |
typedef typename MapTraits<IN>::ConstReturnValue ConstReturnValue; |
3440 | 3464 |
typedef typename MapTraits<IN>::ReturnValue Reference; |
3441 | 3465 |
typedef typename MapTraits<IN>::ConstReturnValue ConstReference; |
3442 | 3466 |
|
3443 | 3467 |
/// Constructor |
3444 | 3468 |
CombinedNodeMap(IN& in_map, OUT& out_map) |
3445 | 3469 |
: _in_map(in_map), _out_map(out_map) {} |
3446 | 3470 |
|
3447 | 3471 |
/// Returns the value associated with the given key. |
3448 | 3472 |
Value operator[](const Key& key) const { |
3449 | 3473 |
if (SplitNodesBase<const DGR>::inNode(key)) { |
3450 | 3474 |
return _in_map[key]; |
3451 | 3475 |
} else { |
3452 | 3476 |
return _out_map[key]; |
3453 | 3477 |
} |
3454 | 3478 |
} |
3455 | 3479 |
|
3456 | 3480 |
/// Returns a reference to the value associated with the given key. |
3457 | 3481 |
Value& operator[](const Key& key) { |
3458 | 3482 |
if (SplitNodesBase<const DGR>::inNode(key)) { |
3459 | 3483 |
return _in_map[key]; |
3460 | 3484 |
} else { |
3461 | 3485 |
return _out_map[key]; |
3462 | 3486 |
} |
3463 | 3487 |
} |
3464 | 3488 |
|
3465 | 3489 |
/// Sets the value associated with the given key. |
3466 | 3490 |
void set(const Key& key, const Value& value) { |
3467 | 3491 |
if (SplitNodesBase<const DGR>::inNode(key)) { |
3468 | 3492 |
_in_map.set(key, value); |
3469 | 3493 |
} else { |
3470 | 3494 |
_out_map.set(key, value); |
3471 | 3495 |
} |
3472 | 3496 |
} |
3473 | 3497 |
|
3474 | 3498 |
private: |
3475 | 3499 |
|
3476 | 3500 |
IN& _in_map; |
3477 | 3501 |
OUT& _out_map; |
3478 | 3502 |
|
3479 | 3503 |
}; |
3480 | 3504 |
|
3481 | 3505 |
|
3482 | 3506 |
/// \brief Returns a combined node map |
3483 | 3507 |
/// |
3484 | 3508 |
/// This function just returns a combined node map. |
3485 | 3509 |
template <typename IN, typename OUT> |
3486 | 3510 |
static CombinedNodeMap<IN, OUT> |
3487 | 3511 |
combinedNodeMap(IN& in_map, OUT& out_map) { |
3488 | 3512 |
return CombinedNodeMap<IN, OUT>(in_map, out_map); |
3489 | 3513 |
} |
3490 | 3514 |
|
3491 | 3515 |
template <typename IN, typename OUT> |
3492 | 3516 |
static CombinedNodeMap<const IN, OUT> |
3493 | 3517 |
combinedNodeMap(const IN& in_map, OUT& out_map) { |
3494 | 3518 |
return CombinedNodeMap<const IN, OUT>(in_map, out_map); |
3495 | 3519 |
} |
3496 | 3520 |
|
3497 | 3521 |
template <typename IN, typename OUT> |
3498 | 3522 |
static CombinedNodeMap<IN, const OUT> |
3499 | 3523 |
combinedNodeMap(IN& in_map, const OUT& out_map) { |
3500 | 3524 |
return CombinedNodeMap<IN, const OUT>(in_map, out_map); |
3501 | 3525 |
} |
3502 | 3526 |
|
3503 | 3527 |
template <typename IN, typename OUT> |
3504 | 3528 |
static CombinedNodeMap<const IN, const OUT> |
3505 | 3529 |
combinedNodeMap(const IN& in_map, const OUT& out_map) { |
3506 | 3530 |
return CombinedNodeMap<const IN, const OUT>(in_map, out_map); |
3507 | 3531 |
} |
3508 | 3532 |
|
3509 | 3533 |
/// \brief Arc map combined from an arc map and a node map of the |
3510 | 3534 |
/// original digraph. |
3511 | 3535 |
/// |
3512 | 3536 |
/// This map adaptor class adapts an arc map and a node map of the |
3513 | 3537 |
/// original digraph to get an arc map of the split digraph. |
3514 | 3538 |
/// Its value type is inherited from the original arc map type (\c AM). |
3515 | 3539 |
/// \tparam AM The type of the arc map. |
3516 | 3540 |
/// \tparam NM the type of the node map. |
3517 | 3541 |
template <typename AM, typename NM> |
3518 | 3542 |
class CombinedArcMap { |
3519 | 3543 |
public: |
Changeset was too big and was cut off... Show full diff
0 comments (0 inline)