lemon-1.1: comparison doc/groups.dox

equal deleted inserted replaced

-:687f577f60dc
+:c4469754715c
 \ref graph_adaptors "graph adaptors". Adaptors cannot be used alone but only
 in conjunction with other graph representations.
 You are free to use the graph structure that fit your requirements
 the best, most graph algorithms and auxiliary data structures can be used
-with any graph structures.
+with any graph structure.
+<b>See also:</b> \ref graph_concepts "Graph Structure Concepts".
 */
 /**
 @defgroup semi_adaptors Semi-Adaptor Classes for Graphs
 @ingroup graphs
 @ingroup datas
 \brief Map structures implemented in LEMON.
 This group describes the map structures implemented in LEMON.
-LEMON provides several special purpose maps that e.g. combine
+LEMON provides several special purpose maps and map adaptors that e.g. combine
 new maps from existing ones.
+<b>See also:</b> \ref map_concepts "Map Concepts".
 */
 /**
 @defgroup graph_maps Graph Maps
 @ingroup maps
 \brief Special graph-related maps.
 This group describes maps that are specifically designed to assign
 values to the nodes and arcs of graphs.
 */
 /**
 \defgroup map_adaptors Map Adaptors
 \ingroup maps
 \brief Tools to create new maps from existing ones
 'not' etc.) or e.g. convert a map to another one of different Value type.
 The typical usage of this classes is passing implicit maps to
 algorithms.  If a function type algorithm is called then the function
 type map adaptors can be used comfortable. For example let's see the
-usage of map adaptors with the \c digraphToEps() function.
+usage of map adaptors with the \c graphToEps() function.
 \code
 Color nodeColor(int deg) {
 if (deg >= 2) {
 return Color(0.5, 0.0, 0.5);
 } else if (deg == 1) {
 }
 }
 Digraph::NodeMap<int> degree_map(graph);
-digraphToEps(graph, "graph.eps")
+graphToEps(graph, "graph.eps")
 .coords(coords).scaleToA4().undirected()
 .nodeColors(composeMap(functorToMap(nodeColor), degree_map))
 .run();
 \endcode
 The \c functorToMap() function makes an \c int to \c Color map from the
-\e nodeColor() function. The \c composeMap() compose the \e degree_map
+\c nodeColor() function. The \c composeMap() compose the \c degree_map
 and the previously created map. The composed map is a proper function to
 get the color of each node.
 The usage with class type algorithms is little bit harder. In this
 case the function type map adaptors can not be used, because the
 assignment operators and copy constructors. This makes it easy and
 efficient to have e.g. the Dijkstra algorithm to store its result in
 any kind of path structure.
 \sa lemon::concepts::Path
 */
 /**
 @defgroup auxdat Auxiliary Data Structures
 @ingroup datas
 This group describes some data structures implemented in LEMON in
 order to make it easier to implement combinatorial algorithms.
 */
 /**
 @defgroup algs Algorithms
 \brief This group describes the several algorithms
 implemented in LEMON.
 @defgroup search Graph Search
 @ingroup algs
 \brief Common graph search algorithms.
 This group describes the common graph search algorithms like
-Breadth-first search (Bfs) and Depth-first search (Dfs).
+Breadth-First Search (BFS) and Depth-First Search (DFS).
 */
 /**
-@defgroup shortest_path Shortest Path algorithms
+@defgroup shortest_path Shortest Path Algorithms
 @ingroup algs
 \brief Algorithms for finding shortest paths.
 This group describes the algorithms for finding shortest paths in graphs.
 */
 /**
-@defgroup max_flow Maximum Flow algorithms
+@defgroup max_flow Maximum Flow Algorithms
 @ingroup algs
 \brief Algorithms for finding maximum flows.
 This group describes the algorithms for finding maximum flows and
 feasible circulations.
 In most cases the \ref lemon::Preflow "Preflow" algorithm provides the
 fastest method to compute the maximum flow. All impelementations
 provides functions to query the minimum cut, which is the dual linear
 programming problem of the maximum flow.
+*/
-*/
+/**
-/**
+@defgroup min_cost_flow Minimum Cost Flow Algorithms
-@defgroup min_cost_flow Minimum Cost Flow algorithms
 @ingroup algs
 \brief Algorithms for finding minimum cost flows and circulations.
 This group describes the algorithms for finding minimum cost flows and
 circulations.
 */
 /**
-@defgroup min_cut Minimum Cut algorithms
+@defgroup min_cut Minimum Cut Algorithms
 @ingroup algs
 \brief Algorithms for finding minimum cut in graphs.
 This group describes the algorithms for finding minimum cut in graphs.
 - \ref lemon::GomoryHuTree "Gomory-Hu tree computation" to calculate all
 pairs minimum cut in undirected graphs
 If you want to find minimum cut just between two distinict nodes,
 please see the \ref max_flow "Maximum Flow page".
+*/
-*/
+/**
-/**
+@defgroup graph_prop Connectivity and Other Graph Properties
-@defgroup graph_prop Connectivity and other graph properties
 @ingroup algs
 \brief Algorithms for discovering the graph properties
 This group describes the algorithms for discovering the graph properties
 like connectivity, bipartiteness, euler property, simplicity etc.
 \image html edge_biconnected_components.png
 \image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
 */
 /**
-@defgroup planar Planarity embedding and drawing
+@defgroup planar Planarity Embedding and Drawing
 @ingroup algs
 \brief Algorithms for planarity checking, embedding and drawing
 This group describes the algorithms for planarity checking,
 embedding and drawing.
 \image html planar.png
 \image latex planar.eps "Plane graph" width=\textwidth
 */
 /**
-@defgroup matching Matching algorithms
+@defgroup matching Matching Algorithms
 @ingroup algs
 \brief Algorithms for finding matchings in graphs and bipartite graphs.
 This group contains algorithm objects and functions to calculate
 matchings in graphs and bipartite graphs. The general matching problem is
 Edmond's blossom shrinking algorithm for calculate maximum weighted
 perfect matching in general graph
 \image html bipartite_matching.png
 \image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth
+*/
-*/
+/**
-/**
+@defgroup spantree Minimum Spanning Tree Algorithms
-@defgroup spantree Minimum Spanning Tree algorithms
 @ingroup algs
 \brief Algorithms for finding a minimum cost spanning tree in a graph.
 This group describes the algorithms for finding a minimum cost spanning
 tree in a graph
 */
+/**
-/**
+@defgroup auxalg Auxiliary Algorithms
-@defgroup auxalg Auxiliary algorithms
 @ingroup algs
 \brief Auxiliary algorithms implemented in LEMON.
 This group describes some algorithms implemented in LEMON
 in order to make it easier to implement complex algorithms.
 */
 /**
-@defgroup approx Approximation algorithms
+@defgroup approx Approximation Algorithms
+@ingroup algs
 \brief Approximation algorithms.
 This group describes the approximation and heuristic algorithms
 implemented in LEMON.
 */
 \brief This group describes some general optimization frameworks
 implemented in LEMON.
 This group describes some general optimization frameworks
 implemented in LEMON.
+*/
-*/
+/**
-/**
+@defgroup lp_group Lp and Mip Solvers
-@defgroup lp_group Lp and Mip solvers
 @ingroup gen_opt_group
 \brief Lp and Mip solver interfaces for LEMON.
 This group describes Lp and Mip solver interfaces for LEMON. The
 various LP solvers could be used in the same manner with this
 interface.
+*/
-*/
+/**
-/**
+@defgroup lp_utils Tools for Lp and Mip Solvers
-@defgroup lp_utils Tools for Lp and Mip solvers
 @ingroup lp_group
 \brief Helper tools to the Lp and Mip solvers.
 This group adds some helper tools to general optimization framework
 implemented in LEMON.
 This group describes several useful tools for development,
 debugging and testing.
 */
 /**
-@defgroup timecount Time measuring and Counting
+@defgroup timecount Time Measuring and Counting
 @ingroup misc
 \brief Simple tools for measuring the performance of algorithms.
 This group describes simple tools for measuring the performance
 of algorithms.
-*/
-/**
-@defgroup graphbits Tools for Graph Implementation
-@ingroup utils
-\brief Tools to make it easier to create graphs.
-This group describes the tools that makes it easier to create graphs and
-the maps that dynamically update with the graph changes.
 */
 /**
 @defgroup exceptions Exceptions
 @ingroup utils
 /**
 @defgroup io_group Input-Output
 \brief Graph Input-Output methods
 This group describes the tools for importing and exporting graphs
-and graph related data. Now it supports the LEMON format, the
+and graph related data. Now it supports the \ref lgf-format
-\c DIMACS format and the encapsulated postscript (EPS) format.
+"LEMON Graph Format", the \c DIMACS format and the encapsulated
+postscript (EPS) format.
 */
 /**
 @defgroup lemon_io LEMON Input-Output
 @ingroup io_group
-\brief Reading and writing \ref lgf-format "LEMON Graph Format".
+\brief Reading and writing LEMON Graph Format.
 This group describes methods for reading and writing
 \ref lgf-format "LEMON Graph Format".
 */
 /**
-@defgroup eps_io Postscript exporting
+@defgroup eps_io Postscript Exporting
 @ingroup io_group
 \brief General \c EPS drawer and graph exporter
 This group describes general \c EPS drawing methods and special
 graph exporting tools.
 */
 /**
 @defgroup concept Concepts
 \brief Skeleton classes and concept checking classes
 - The concept descriptor classes also provide a <em>checker class</em>
 that makes it possible to check whether a certain implementation of a
 concept indeed provides all the required features.
 - Finally, They can serve as a skeleton of a new implementation of a concept.
+*/
-*/
 /**
 @defgroup graph_concepts Graph Structure Concepts
 @ingroup concept
 \brief Skeleton and concept checking classes for graph structures
 This group describes the skeletons and concept checking classes of LEMON's
 graph structures and helper classes used to implement these.
 */
-/* --- Unused group
+/**
-@defgroup experimental Experimental Structures and Algorithms
+@defgroup map_concepts Map Concepts
-This group describes some Experimental structures and algorithms.
+@ingroup concept
-The stuff here is subject to change.
+\brief Skeleton and concept checking classes for maps
+This group describes the skeletons and concept checking classes of maps.
 */
 /**
 \anchor demoprograms

changeset 314	2cc60866a0c9
parent 236	da953e387d31
child 318	1e2d6ca80793