COIN-OR::LEMON - Graph Library

source: lemon-0.x/doc/groups.dox @ 2060:be70ea3b957a

Last change on this file since 2060:be70ea3b957a was 2060:be70ea3b957a, checked in by Balazs Dezso, 14 years ago

Images into the algorithm groups

File size: 7.2 KB
Line 
1
2/**
3@defgroup datas Data Structures
4This group describes the several graph structures implemented in LEMON.
5*/
6
7/**
8@defgroup graphs Graph Structures
9@ingroup datas
10\brief Graph structures implemented in LEMON.
11
12The implementation of combinatorial algorithms heavily relies on
13efficient graph implementations. LEMON offers data structures which are
14planned to be easily used in an experimental phase of implementation studies,
15and thereafter the program code can be made efficient by small modifications.
16
17The most efficient implementation of diverse applications require the usage of different physical graph implementations. These differences appear in the size of
18graph we require to handle, memory or time usage limitations or in
19the set of operations through which the graph can be accessed.
20LEMON provides several physical graph structures to meet the
21diverging requirements of the possible users.
22In order to save on running time or on memory usage, some structures may
23fail to provide some graph features like edge or node deletion.
24
25Alteration of standard containers need a very limited number of
26operations, these together satisfy the everyday requirements.
27In the case of graph strutures, different operations are needed which do
28not alter the physical graph, but gives another view. If some nodes or
29edges have to be hidden or the reverse oriented graph have to be used, then
30this is the case. It also may happen that in a flow implemenation
31the residual graph can be accessed by another algorithm, or a node-set
32is to be shrunk for another algorithm.
33LEMON also provides a variety of graphs for these requirements called
34\ref graph_adaptors "graph adaptors". Adaptors cannot be used alone but only
35in conjunction with other graph representation.
36
37You are free to use the graph structure that fit your requirements
38the best, most graph algorithms and auxiliary data structures can be used
39with any graph structures.
40*/
41
42/**
43@defgroup semi_adaptors Semi-Adaptors Classes for Graphs
44@ingroup graphs
45\brief Graph types between real graphs and graph adaptors.
46
47Graph types between real graphs and graph adaptors. These classes
48wrap graphs to give new functionality as the adaptors do it. But the
49other way they are not light-weigth structures as the adaptors.
50*/
51
52/**
53@defgroup maps Maps
54@ingroup datas
55\brief Some special purpose map to make life easier.
56
57LEMON provides several special maps that e.g. combine
58new maps from existing ones.
59*/
60
61/**
62@defgroup graph_maps Graph Maps
63@ingroup maps
64\brief Special Graph-Related Maps.
65
66These maps are specifically designed to assign values to the nodes and edges of
67graphs.
68*/
69
70
71/**
72\defgroup map_adaptors Map Adaptors
73\ingroup maps
74\brief Tools to create new maps from existing ones
75
76Map adaptors are used to create "implicit" maps from other maps.
77
78Most of them are \ref lemon::concept::ReadMap "ReadMap"s. They can
79make arithmetic oprerations between one or two maps (negation, scalig,
80addition, multiplication etc.) or e.g. convert a map to another one
81of different Value type.
82*/
83
84/**
85@defgroup auxdat Auxiliary Data Structures
86@ingroup datas
87\brief Some data structures implemented in LEMON.
88
89This group describes the data structures implemented in LEMON in
90order to make it easier to implement combinatorial algorithms.
91*/
92
93/**
94@defgroup graphbits Tools to Make It Easier to Make Graphs
95@ingroup auxdat
96\brief Tools to Make It Easier to Make Graphs.
97
98This group describes the tools that makes it easier to make graphs and
99the maps that dynamically update with the graph changes.
100*/
101
102/**
103@defgroup galgs Graph Algorithms
104\brief This group describes the several graph algorithms
105implemented in LEMON.
106
107This group describes the several graph algorithms
108implemented in LEMON.
109*/
110
111/**
112@defgroup gutils General Graph Utilities
113@ingroup galgs
114\brief This group describes some simple general graph utilities.
115
116This group describes some simple general graph utilities.
117*/
118
119/**
120@defgroup gen_opt_group General Optimization Tools
121\brief This group describes some general optimization frameworks
122implemented in LEMON.
123
124This group describes some general optimization frameworks
125implemented in LEMON.
126
127*/
128
129/**
130@defgroup flowalgs Path and Flow Algorithms
131@ingroup galgs
132\brief This group describes the algorithms
133for finding paths and flows in graphs.
134
135This group describes the algorithms
136for finding paths and flows in graphs.
137
138\image html flow.png
139\image latex flow.eps "Graph flow" width=\textwidth
140*/
141
142/**
143@defgroup topology Topology related algorithms
144@ingroup galgs
145\brief This group describes the algorithms
146for discover the topology of the graphs.
147
148This group describes the algorithms
149for discover the topology of the graphs.
150
151\image html edge_biconnected_components.png
152\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
153
154*/
155
156/**
157@defgroup matching Matching algorithms in graphs and bipartite graphs
158@ingroup galgs
159\brief This group describes the algorithms
160for find matchings in graphs and bipartite graphs.
161
162This group provides some algorithm objects and function
163to calculate matchings in graphs and bipartite graphs.
164
165\image html bipartite_matching.png
166\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth
167
168*/
169
170/**
171@defgroup exceptions Exceptions
172This group contains the exceptions thrown by LEMON library
173*/
174
175/**
176@defgroup misc Miscellaneous Tools
177Here you can find several useful tools for development,
178debugging and testing.
179*/
180
181/**
182@defgroup timecount Time measuring and Counting
183@ingroup misc
184Here you can find simple tools for measuring the performance
185of algorithms.
186*/
187
188/**
189@defgroup io_group Input-Output
190Here you can find tools for imporing and exporting graphs and graph related
191data
192*/
193
194/**
195@defgroup section_io Section readers and writers
196@ingroup io_group
197\brief Section readers and writers for lemon Input-Output.
198
199Here you can find which section readers and writers can attach to
200the LemonReader and LemonWriter.
201*/
202
203/**
204@defgroup item_io Item Readers and Writers
205@ingroup io_group
206\brief Item readers and writers for lemon Input-Output.
207
208The Input-Output classes can handle more data type by example
209as map or attribute value. Each of these should be written and
210read some way. The module make possible to do this. 
211*/
212
213/**
214@defgroup concept Concepts
215\brief Skeleton classes and concept checking classes
216
217This group describes the data/algorithm skeletons and concept checking
218classes implemented in LEMON.
219
220One aim of these classes is to make it easier to check if a certain
221class or template function is correctly implemented.
222
223The other (sometimes even more important) aim is to document the concepts.
224
225*/
226
227/**
228@defgroup graph_concepts Graph Structure Concepts
229@ingroup concept
230\brief Skeleton and concept checking classes for graph structures
231
232This group contains the skeletons and concept checking classes of LEMON's
233graph structures and helper classes used to implement these.
234*/
235
236/* --- Unused group
237@defgroup experimental Experimental Structures and Algorithms
238This group contains some Experimental structures and algorithms.
239The stuff here is subject to change.
240*/
241
242/**
243\anchor demoprograms
244
245@defgroup demos Demo programs
246
247Some demo programs are listed here. Their full source codes can be found in
248the \c demo subdirectory of the source tree.
249
250The standard compilation procedure (<tt>./configure;make</tt>) will compile
251them, as well.
252
253*/
254
Note: See TracBrowser for help on using the repository browser.