[Lemon-commits] deba: r3195 - in hugo/trunk: doc lemon

Lemon SVN svn at lemon.cs.elte.hu
Wed Feb 21 14:30:23 CET 2007 

Author: deba
Date: Wed Feb 21 14:30:21 2007
New Revision: 3195

Modified:
   hugo/trunk/doc/groups.dox
   hugo/trunk/lemon/bellman_ford.h
   hugo/trunk/lemon/bfs.h
   hugo/trunk/lemon/circulation.h
   hugo/trunk/lemon/csp.h
   hugo/trunk/lemon/dfs.h
   hugo/trunk/lemon/dijkstra.h
   hugo/trunk/lemon/edmonds_karp.h
   hugo/trunk/lemon/floyd_warshall.h
   hugo/trunk/lemon/hao_orlin.h
   hugo/trunk/lemon/johnson.h
   hugo/trunk/lemon/matrix_maps.h
   hugo/trunk/lemon/nagamochi_ibaraki.h
   hugo/trunk/lemon/preflow.h
   hugo/trunk/lemon/ssp_min_cost_flow.h
   hugo/trunk/lemon/suurballe.h

Log:
Reorganization of the modules and groups



Modified: hugo/trunk/doc/groups.dox
==============================================================================
--- hugo/trunk/doc/groups.dox	(original)
+++ hugo/trunk/doc/groups.dox	Wed Feb 21 14:30:21 2007
@@ -115,14 +115,6 @@
 order to make it easier to implement combinatorial algorithms.
 */
 
-/**
- at defgroup graphbits Tools to Make It Easier to Make Graphs
- at ingroup auxdat
-\brief Tools to Make It Easier to Make Graphs.
-
-This group describes the tools that makes it easier to make graphs and
-the maps that dynamically update with the graph changes.
-*/
 
 /**
 @defgroup algs Algorithms
@@ -134,27 +126,59 @@
 */
 
 /**
- at defgroup gutils Basic Graph Utilities
+ at defgroup search Graph Search
 @ingroup algs
-\brief This group describes some simple basic graph utilities.
+\brief This group contains the common graph
+search algorithms.
 
-This group describes some simple basic graph utilities.
+This group contains the common graph
+search algorithms like Bfs and Dfs.
 */
 
 /**
- at defgroup flowalgs Path and Flow Algorithms
+ at defgroup shortest_path Shortest Path algorithms
 @ingroup algs
 \brief This group describes the algorithms
-for finding paths and flows in graphs.
+for finding shortest paths.
 
-This group describes the algorithms
-for finding paths and flows in graphs.
+This group describes the algorithms for finding shortest paths in
+graphs.
+
+*/
+
+/** 
+ at defgroup max_flow Maximum Flow algorithms 
+ at ingroup algs 
+\brief This group describes the algorithms for finding maximum flows.
+
+This group describes the algorithms for finding maximum flows.
 
 \image html flow.png
 \image latex flow.eps "Graph flow" width=\textwidth
 */
 
 /**
+ at defgroup min_cost_flow Minimum Cost Flow algorithms
+ at ingroup algs
+
+\brief This group describes the algorithms
+for finding minimum cost flows and circulations.
+
+This group describes the algorithms for finding minimum cost flows and
+circulations.  
+*/
+
+/**
+ at defgroup min_cut Minimum Cut algorithms
+ at ingroup algs
+\brief This group describes the algorithms
+for finding minimum cut in graphs.
+
+This group describes the algorithms
+for finding minimum cut in graphs.
+*/
+
+/**
 @defgroup topology Topology related algorithms
 @ingroup algs
 \brief This group describes the algorithms
@@ -168,7 +192,7 @@
 */
 
 /**
- at defgroup matching Matching algorithms in graphs and bipartite graphs
+ at defgroup matching Matching algorithms 
 @ingroup algs
 \brief This group describes the algorithms
 for find matchings in graphs and bipartite graphs.
@@ -182,7 +206,7 @@
 */
 
 /**
- at defgroup spantree Minimum Cost Spanning Tree Algorithms
+ at defgroup spantree Minimum Spanning Tree algorithms
 @ingroup algs
 \brief This group contains the algorithms for finding a minimum cost spanning
 tree in a graph
@@ -193,13 +217,19 @@
 
 
 /**
- at defgroup auxalg Auxiliary Algorithms
+ at defgroup auxalg Auxiliary algorithms
 @ingroup algs
 \brief Some algorithms implemented in LEMON.
 
 This group describes the algorithms in LEMON in order to make 
 it easier to implement complex algorithms.
+*/
 
+/**
+ at defgroup approx Approximation algorithms
+\brief Approximation algorithms
+
+Approximation and heuristic algorithms
 */
 
 /**
@@ -231,7 +261,6 @@
 
 This group adds some helper tools to general optimization framework
 implemented in LEMON.
-
 */
 
 /**
@@ -243,11 +272,28 @@
 */
 
 /**
+ at defgroup utils Tools and Utilities 
+\brief Tools and Utilities for Programming in LEMON
+
+Tools and Utilities for Programming in LEMON
+*/
+
+/**
+ at defgroup gutils Basic Graph Utilities
+ at ingroup utils
+\brief This group describes some simple basic graph utilities.
+
+This group describes some simple basic graph utilities.
+*/
+
+/**
 @defgroup misc Miscellaneous Tools
+ at ingroup utils
 Here you can find several useful tools for development,
 debugging and testing.
 */
 
+
 /**
 @defgroup timecount Time measuring and Counting
 @ingroup misc
@@ -256,6 +302,21 @@
 */
 
 /**
+ at defgroup graphbits Tools for Graph Implementation
+ at ingroup utils
+\brief Tools to Make It Easier to Make Graphs.
+
+This group describes the tools that makes it easier to make graphs and
+the maps that dynamically update with the graph changes.
+*/
+
+/**
+ at defgroup exceptions Exceptions
+ at ingroup utils
+This group contains the exceptions thrown by LEMON library
+*/
+
+/**
 @defgroup io_group Input-Output
 \brief Several Graph Input-Output methods
 
@@ -302,10 +363,6 @@
 graph exporting tools. 
 */
 
-/**
- at defgroup exceptions Exceptions
-This group contains the exceptions thrown by LEMON library
-*/
 
 /**
 @defgroup concept Concepts

Modified: hugo/trunk/lemon/bellman_ford.h
==============================================================================
--- hugo/trunk/lemon/bellman_ford.h	(original)
+++ hugo/trunk/lemon/bellman_ford.h	Wed Feb 21 14:30:21 2007
@@ -19,7 +19,7 @@
 #ifndef LEMON_BELMANN_FORD_H
 #define LEMON_BELMANN_FORD_H
 
-/// \ingroup flowalgs
+/// \ingroup shortest_path
 /// \file
 /// \brief BellmanFord algorithm.
 ///
@@ -144,7 +144,7 @@
   
   /// \brief %BellmanFord algorithm class.
   ///
-  /// \ingroup flowalgs
+  /// \ingroup shortest_path
   /// This class provides an efficient implementation of \c Bellman-Ford 
   /// algorithm. The edge lengths are passed to the algorithm using a
   /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any 
@@ -1022,7 +1022,7 @@
   
   /// \brief Function type interface for BellmanFord algorithm.
   ///
-  /// \ingroup flowalgs
+  /// \ingroup shortest_path
   /// Function type interface for BellmanFord algorithm.
   ///
   /// This function also has several \ref named-templ-func-param 

Modified: hugo/trunk/lemon/bfs.h
==============================================================================
--- hugo/trunk/lemon/bfs.h	(original)
+++ hugo/trunk/lemon/bfs.h	Wed Feb 21 14:30:21 2007
@@ -19,7 +19,7 @@
 #ifndef LEMON_BFS_H
 #define LEMON_BFS_H
 
-///\ingroup flowalgs
+///\ingroup search
 ///\file
 ///\brief Bfs algorithm.
 
@@ -112,7 +112,7 @@
   
   ///%BFS algorithm class.
   
-  ///\ingroup flowalgs
+  ///\ingroup search
   ///This class provides an efficient implementation of the %BFS algorithm.
   ///
   ///\param GR The graph type the algorithm runs on. The default value is
@@ -1073,7 +1073,7 @@
   
   ///Function type interface for Bfs algorithm.
 
-  /// \ingroup flowalgs
+  /// \ingroup search
   ///Function type interface for Bfs algorithm.
   ///
   ///This function also has several
@@ -1187,7 +1187,7 @@
   
   /// %BFS Visit algorithm class.
   
-  /// \ingroup flowalgs
+  /// \ingroup search
   /// This class provides an efficient implementation of the %BFS algorithm
   /// with visitor interface.
   ///

Modified: hugo/trunk/lemon/circulation.h
==============================================================================
--- hugo/trunk/lemon/circulation.h	(original)
+++ hugo/trunk/lemon/circulation.h	Wed Feb 21 14:30:21 2007
@@ -23,7 +23,7 @@
 #include <lemon/tolerance.h>
 #include <lemon/elevator.h>
 
-///\ingroup flowalgs
+///\ingroup max_flow
 ///\file
 ///\brief Push-prelabel algorithm for finding a feasible circulation.
 ///

Modified: hugo/trunk/lemon/csp.h
==============================================================================
--- hugo/trunk/lemon/csp.h	(original)
+++ hugo/trunk/lemon/csp.h	Wed Feb 21 14:30:21 2007
@@ -19,7 +19,7 @@
 #ifndef LEMON_CSP_H
 #define LEMON_CSP_H
 
-///\ingroup flowalgs
+///\ingroup approx
 ///\file
 ///\brief Algorithm for the Resource Constrained Shortest Path problem.
 ///

Modified: hugo/trunk/lemon/dfs.h
==============================================================================
--- hugo/trunk/lemon/dfs.h	(original)
+++ hugo/trunk/lemon/dfs.h	Wed Feb 21 14:30:21 2007
@@ -19,7 +19,7 @@
 #ifndef LEMON_DFS_H
 #define LEMON_DFS_H
 
-///\ingroup flowalgs
+///\ingroup search
 ///\file
 ///\brief Dfs algorithm.
 
@@ -114,7 +114,7 @@
   
   ///%DFS algorithm class.
   
-  ///\ingroup flowalgs
+  ///\ingroup search
   ///This class provides an efficient implementation of the %DFS algorithm.
   ///
   ///\param GR The graph type the algorithm runs on. The default value is
@@ -1047,7 +1047,7 @@
   
   ///Function type interface for Dfs algorithm.
 
-  /// \ingroup flowalgs
+  ///\ingroup search
   ///Function type interface for Dfs algorithm.
   ///
   ///This function also has several
@@ -1174,7 +1174,7 @@
   
   /// %DFS Visit algorithm class.
   
-  /// \ingroup flowalgs
+  /// \ingroup search
   /// This class provides an efficient implementation of the %DFS algorithm
   /// with visitor interface.
   ///

Modified: hugo/trunk/lemon/dijkstra.h
==============================================================================
--- hugo/trunk/lemon/dijkstra.h	(original)
+++ hugo/trunk/lemon/dijkstra.h	Wed Feb 21 14:30:21 2007
@@ -19,7 +19,7 @@
 #ifndef LEMON_DIJKSTRA_H
 #define LEMON_DIJKSTRA_H
 
-///\ingroup flowalgs
+///\ingroup shortest_path
 ///\file
 ///\brief Dijkstra algorithm.
 ///
@@ -140,7 +140,7 @@
   
   ///%Dijkstra algorithm class.
   
-  /// \ingroup flowalgs
+  /// \ingroup shortest_path
   ///This class provides an efficient implementation of %Dijkstra algorithm.
   ///The edge lengths are passed to the algorithm using a
   ///\ref concepts::ReadMap "ReadMap",
@@ -1107,7 +1107,7 @@
   
   ///Function type interface for Dijkstra algorithm.
 
-  /// \ingroup flowalgs
+  /// \ingroup shortest_path
   ///Function type interface for Dijkstra algorithm.
   ///
   ///This function also has several

Modified: hugo/trunk/lemon/edmonds_karp.h
==============================================================================
--- hugo/trunk/lemon/edmonds_karp.h	(original)
+++ hugo/trunk/lemon/edmonds_karp.h	Wed Feb 21 14:30:21 2007
@@ -20,7 +20,7 @@
 #define LEMON_EDMONDS_KARP_H
 
 /// \file
-/// \ingroup flowalgs
+/// \ingroup max_flow
 /// \brief Implementation of the Edmonds-Karp algorithm.
 
 #include <lemon/graph_adaptor.h>
@@ -29,7 +29,7 @@
 
 namespace lemon {
 
-  /// \ingroup flowalgs
+  /// \ingroup max_flow
   /// \brief Edmonds-Karp algorithms class.
   ///
   /// This class provides an implementation of the \e Edmonds-Karp \e

Modified: hugo/trunk/lemon/floyd_warshall.h
==============================================================================
--- hugo/trunk/lemon/floyd_warshall.h	(original)
+++ hugo/trunk/lemon/floyd_warshall.h	Wed Feb 21 14:30:21 2007
@@ -19,7 +19,7 @@
 #ifndef LEMON_FLOYD_WARSHALL_H
 #define LEMON_FLOYD_WARSHALL_H
 
-///\ingroup flowalgs
+///\ingroup shortest_path
 /// \file
 /// \brief FloydWarshall algorithm.
 ///
@@ -147,7 +147,7 @@
   
   /// \brief %FloydWarshall algorithm class.
   ///
-  /// \ingroup flowalgs
+  /// \ingroup shortest_path
   /// This class provides an efficient implementation of \c Floyd-Warshall 
   /// algorithm. The edge lengths are passed to the algorithm using a
   /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any 

Modified: hugo/trunk/lemon/hao_orlin.h
==============================================================================
--- hugo/trunk/lemon/hao_orlin.h	(original)
+++ hugo/trunk/lemon/hao_orlin.h	Wed Feb 21 14:30:21 2007
@@ -34,7 +34,7 @@
 #include <lemon/iterable_maps.h>
 
 /// \file
-/// \ingroup flowalgs
+/// \ingroup min_cut
 /// \brief Implementation of the Hao-Orlin algorithm.
 ///
 /// Implementation of the HaoOrlin algorithms class for testing network 
@@ -42,7 +42,7 @@
 
 namespace lemon {
 
-  /// \ingroup flowalgs
+  /// \ingroup min_cut
   ///
   /// \brief %Hao-Orlin algorithm to find a minimum cut in directed graphs.
   ///

Modified: hugo/trunk/lemon/johnson.h
==============================================================================
--- hugo/trunk/lemon/johnson.h	(original)
+++ hugo/trunk/lemon/johnson.h	Wed Feb 21 14:30:21 2007
@@ -19,7 +19,7 @@
 #ifndef LEMON_JOHNSON_H
 #define LEMON_JOHNSON_H
 
-///\ingroup flowalgs
+///\ingroup shortest_path
 /// \file
 /// \brief Johnson algorithm.
 ///
@@ -180,7 +180,7 @@
 
   /// \brief %Johnson algorithm class.
   ///
-  /// \ingroup flowalgs
+  /// \ingroup shortest_path
   /// This class provides an efficient implementation of \c %Johnson 
   /// algorithm. The edge lengths are passed to the algorithm using a
   /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any 

Modified: hugo/trunk/lemon/matrix_maps.h
==============================================================================
--- hugo/trunk/lemon/matrix_maps.h	(original)
+++ hugo/trunk/lemon/matrix_maps.h	Wed Feb 21 14:30:21 2007
@@ -551,6 +551,9 @@
   ///typename K2, typename V, typename R, typename CR> called as
   ///"ReferenceMatrixMap".
   ///
+  ///\warning Do not use this map type when the two item sets are
+  ///equal or based on the same item set.
+  ///
   ///\param _FirstContainer the desired type of first container. It is
   ///ususally a Graph type, but can be any type with alteration
   ///property.

Modified: hugo/trunk/lemon/nagamochi_ibaraki.h
==============================================================================
--- hugo/trunk/lemon/nagamochi_ibaraki.h	(original)
+++ hugo/trunk/lemon/nagamochi_ibaraki.h	Wed Feb 21 14:30:21 2007
@@ -18,7 +18,7 @@
 #define LEMON_NAGAMOCHI_IBARAKI_H
 
 
-/// \ingroup topology 
+/// \ingroup min_cut
 /// \file 
 /// \brief Maximum cardinality search and minimum cut in undirected
 /// graphs.
@@ -156,7 +156,7 @@
 
   };
   
-  /// \ingroup topology
+  /// \ingroup search
   ///
   /// \brief Maximum Cardinality Search algorithm class.
   ///
@@ -832,7 +832,7 @@
 
   };
 
-  /// \ingroup topology
+  /// \ingroup min_cut
   ///
   /// \brief Calculates the minimum cut in an undirected graph.
   ///

Modified: hugo/trunk/lemon/preflow.h
==============================================================================
--- hugo/trunk/lemon/preflow.h	(original)
+++ hugo/trunk/lemon/preflow.h	Wed Feb 21 14:30:21 2007
@@ -29,12 +29,12 @@
 #include <lemon/graph_utils.h>
 
 /// \file
-/// \ingroup flowalgs
+/// \ingroup max_flow
 /// \brief Implementation of the preflow algorithm.
 
 namespace lemon {
 
-  ///\ingroup flowalgs
+  ///\ingroup max_flow
   ///\brief %Preflow algorithms class.
   ///
   ///This class provides an implementation of the \e preflow \e
@@ -890,7 +890,7 @@
 
   }; 
 
-  ///\ingroup flowalgs
+  ///\ingroup max_flow
   ///\brief Function type interface for Preflow algorithm.
   ///
   ///Function type interface for Preflow algorithm.

Modified: hugo/trunk/lemon/ssp_min_cost_flow.h
==============================================================================
--- hugo/trunk/lemon/ssp_min_cost_flow.h	(original)
+++ hugo/trunk/lemon/ssp_min_cost_flow.h	Wed Feb 21 14:30:21 2007
@@ -19,7 +19,7 @@
 #ifndef LEMON_MIN_COST_FLOW_H
 #define LEMON_MIN_COST_FLOW_H
 
-///\ingroup flowalgs 
+///\ingroup min_cost_flow 
 ///
 ///\file
 ///\brief An algorithm for finding a flow of value \c k (for
@@ -33,7 +33,7 @@
 
 namespace lemon {
 
-  /// \addtogroup flowalgs
+  /// \addtogroup min_cost_flow
   /// @{
 
   /// \brief Implementation of an algorithm for finding a flow of

Modified: hugo/trunk/lemon/suurballe.h
==============================================================================
--- hugo/trunk/lemon/suurballe.h	(original)
+++ hugo/trunk/lemon/suurballe.h	Wed Feb 21 14:30:21 2007
@@ -31,7 +31,7 @@
 
 namespace lemon {
 
-/// \addtogroup flowalgs
+/// \addtogroup shortest_path
 /// @{
 
   ///\brief Implementation of an algorithm for finding k edge-disjoint

More information about the Lemon-commits mailing list