COIN-OR::LEMON - Graph Library

Changeset 2376:0ed45a6c74b1 in lemon-0.x


Ignore:
Timestamp:
02/21/07 14:30:21 (13 years ago)
Author:
Balazs Dezso
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3195
Message:

Reorganization of the modules and groups

Files:
16 edited

Legend:

Unmodified
Added
Removed
  • doc/groups.dox

    r2371 r2376  
    116116*/
    117117
    118 /**
    119 @defgroup graphbits Tools to Make It Easier to Make Graphs
    120 @ingroup auxdat
    121 \brief Tools to Make It Easier to Make Graphs.
    122 
    123 This group describes the tools that makes it easier to make graphs and
    124 the maps that dynamically update with the graph changes.
    125 */
    126118
    127119/**
     
    135127
    136128/**
    137 @defgroup gutils Basic Graph Utilities
    138 @ingroup algs
    139 \brief This group describes some simple basic graph utilities.
    140 
    141 This group describes some simple basic graph utilities.
    142 */
    143 
    144 /**
    145 @defgroup flowalgs Path and Flow Algorithms
     129@defgroup search Graph Search
     130@ingroup algs
     131\brief This group contains the common graph
     132search algorithms.
     133
     134This group contains the common graph
     135search algorithms like Bfs and Dfs.
     136*/
     137
     138/**
     139@defgroup shortest_path Shortest Path algorithms
    146140@ingroup algs
    147141\brief This group describes the algorithms
    148 for finding paths and flows in graphs.
    149 
    150 This group describes the algorithms
    151 for finding paths and flows in graphs.
     142for finding shortest paths.
     143
     144This group describes the algorithms for finding shortest paths in
     145graphs.
     146
     147*/
     148
     149/**
     150@defgroup max_flow Maximum Flow algorithms
     151@ingroup algs
     152\brief This group describes the algorithms for finding maximum flows.
     153
     154This group describes the algorithms for finding maximum flows.
    152155
    153156\image html flow.png
     
    156159
    157160/**
     161@defgroup min_cost_flow Minimum Cost Flow algorithms
     162@ingroup algs
     163
     164\brief This group describes the algorithms
     165for finding minimum cost flows and circulations.
     166
     167This group describes the algorithms for finding minimum cost flows and
     168circulations. 
     169*/
     170
     171/**
     172@defgroup min_cut Minimum Cut algorithms
     173@ingroup algs
     174\brief This group describes the algorithms
     175for finding minimum cut in graphs.
     176
     177This group describes the algorithms
     178for finding minimum cut in graphs.
     179*/
     180
     181/**
    158182@defgroup topology Topology related algorithms
    159183@ingroup algs
     
    169193
    170194/**
    171 @defgroup matching Matching algorithms in graphs and bipartite graphs
     195@defgroup matching Matching algorithms
    172196@ingroup algs
    173197\brief This group describes the algorithms
     
    183207
    184208/**
    185 @defgroup spantree Minimum Cost Spanning Tree Algorithms
     209@defgroup spantree Minimum Spanning Tree algorithms
    186210@ingroup algs
    187211\brief This group contains the algorithms for finding a minimum cost spanning
     
    194218
    195219/**
    196 @defgroup auxalg Auxiliary Algorithms
     220@defgroup auxalg Auxiliary algorithms
    197221@ingroup algs
    198222\brief Some algorithms implemented in LEMON.
     
    200224This group describes the algorithms in LEMON in order to make
    201225it easier to implement complex algorithms.
    202 
     226*/
     227
     228/**
     229@defgroup approx Approximation algorithms
     230\brief Approximation algorithms
     231
     232Approximation and heuristic algorithms
    203233*/
    204234
     
    232262This group adds some helper tools to general optimization framework
    233263implemented in LEMON.
    234 
    235264*/
    236265
     
    244273
    245274/**
     275@defgroup utils Tools and Utilities
     276\brief Tools and Utilities for Programming in LEMON
     277
     278Tools and Utilities for Programming in LEMON
     279*/
     280
     281/**
     282@defgroup gutils Basic Graph Utilities
     283@ingroup utils
     284\brief This group describes some simple basic graph utilities.
     285
     286This group describes some simple basic graph utilities.
     287*/
     288
     289/**
    246290@defgroup misc Miscellaneous Tools
     291@ingroup utils
    247292Here you can find several useful tools for development,
    248293debugging and testing.
    249294*/
     295
    250296
    251297/**
     
    257303
    258304/**
     305@defgroup graphbits Tools for Graph Implementation
     306@ingroup utils
     307\brief Tools to Make It Easier to Make Graphs.
     308
     309This group describes the tools that makes it easier to make graphs and
     310the maps that dynamically update with the graph changes.
     311*/
     312
     313/**
     314@defgroup exceptions Exceptions
     315@ingroup utils
     316This group contains the exceptions thrown by LEMON library
     317*/
     318
     319/**
    259320@defgroup io_group Input-Output
    260321\brief Several Graph Input-Output methods
     
    303364*/
    304365
    305 /**
    306 @defgroup exceptions Exceptions
    307 This group contains the exceptions thrown by LEMON library
    308 */
    309366
    310367/**
  • lemon/bellman_ford.h

    r2362 r2376  
    2020#define LEMON_BELMANN_FORD_H
    2121
    22 /// \ingroup flowalgs
     22/// \ingroup shortest_path
    2323/// \file
    2424/// \brief BellmanFord algorithm.
     
    145145  /// \brief %BellmanFord algorithm class.
    146146  ///
    147   /// \ingroup flowalgs
     147  /// \ingroup shortest_path
    148148  /// This class provides an efficient implementation of \c Bellman-Ford
    149149  /// algorithm. The edge lengths are passed to the algorithm using a
     
    10231023  /// \brief Function type interface for BellmanFord algorithm.
    10241024  ///
    1025   /// \ingroup flowalgs
     1025  /// \ingroup shortest_path
    10261026  /// Function type interface for BellmanFord algorithm.
    10271027  ///
  • lemon/bfs.h

    r2350 r2376  
    2020#define LEMON_BFS_H
    2121
    22 ///\ingroup flowalgs
     22///\ingroup search
    2323///\file
    2424///\brief Bfs algorithm.
     
    113113  ///%BFS algorithm class.
    114114 
    115   ///\ingroup flowalgs
     115  ///\ingroup search
    116116  ///This class provides an efficient implementation of the %BFS algorithm.
    117117  ///
     
    10741074  ///Function type interface for Bfs algorithm.
    10751075
    1076   /// \ingroup flowalgs
     1076  /// \ingroup search
    10771077  ///Function type interface for Bfs algorithm.
    10781078  ///
     
    11881188  /// %BFS Visit algorithm class.
    11891189 
    1190   /// \ingroup flowalgs
     1190  /// \ingroup search
    11911191  /// This class provides an efficient implementation of the %BFS algorithm
    11921192  /// with visitor interface.
  • lemon/circulation.h

    r2375 r2376  
    2424#include <lemon/elevator.h>
    2525
    26 ///\ingroup flowalgs
     26///\ingroup max_flow
    2727///\file
    2828///\brief Push-prelabel algorithm for finding a feasible circulation.
  • lemon/csp.h

    r2373 r2376  
    2020#define LEMON_CSP_H
    2121
    22 ///\ingroup flowalgs
     22///\ingroup approx
    2323///\file
    2424///\brief Algorithm for the Resource Constrained Shortest Path problem.
  • lemon/dfs.h

    r2335 r2376  
    2020#define LEMON_DFS_H
    2121
    22 ///\ingroup flowalgs
     22///\ingroup search
    2323///\file
    2424///\brief Dfs algorithm.
     
    115115  ///%DFS algorithm class.
    116116 
    117   ///\ingroup flowalgs
     117  ///\ingroup search
    118118  ///This class provides an efficient implementation of the %DFS algorithm.
    119119  ///
     
    10481048  ///Function type interface for Dfs algorithm.
    10491049
    1050   /// \ingroup flowalgs
     1050  ///\ingroup search
    10511051  ///Function type interface for Dfs algorithm.
    10521052  ///
     
    11751175  /// %DFS Visit algorithm class.
    11761176 
    1177   /// \ingroup flowalgs
     1177  /// \ingroup search
    11781178  /// This class provides an efficient implementation of the %DFS algorithm
    11791179  /// with visitor interface.
  • lemon/dijkstra.h

    r2358 r2376  
    2020#define LEMON_DIJKSTRA_H
    2121
    22 ///\ingroup flowalgs
     22///\ingroup shortest_path
    2323///\file
    2424///\brief Dijkstra algorithm.
     
    141141  ///%Dijkstra algorithm class.
    142142 
    143   /// \ingroup flowalgs
     143  /// \ingroup shortest_path
    144144  ///This class provides an efficient implementation of %Dijkstra algorithm.
    145145  ///The edge lengths are passed to the algorithm using a
     
    11081108  ///Function type interface for Dijkstra algorithm.
    11091109
    1110   /// \ingroup flowalgs
     1110  /// \ingroup shortest_path
    11111111  ///Function type interface for Dijkstra algorithm.
    11121112  ///
  • lemon/edmonds_karp.h

    r2151 r2376  
    2121
    2222/// \file
    23 /// \ingroup flowalgs
     23/// \ingroup max_flow
    2424/// \brief Implementation of the Edmonds-Karp algorithm.
    2525
     
    3030namespace lemon {
    3131
    32   /// \ingroup flowalgs
     32  /// \ingroup max_flow
    3333  /// \brief Edmonds-Karp algorithms class.
    3434  ///
  • lemon/floyd_warshall.h

    r2335 r2376  
    2020#define LEMON_FLOYD_WARSHALL_H
    2121
    22 ///\ingroup flowalgs
     22///\ingroup shortest_path
    2323/// \file
    2424/// \brief FloydWarshall algorithm.
     
    148148  /// \brief %FloydWarshall algorithm class.
    149149  ///
    150   /// \ingroup flowalgs
     150  /// \ingroup shortest_path
    151151  /// This class provides an efficient implementation of \c Floyd-Warshall
    152152  /// algorithm. The edge lengths are passed to the algorithm using a
  • lemon/hao_orlin.h

    r2340 r2376  
    3535
    3636/// \file
    37 /// \ingroup flowalgs
     37/// \ingroup min_cut
    3838/// \brief Implementation of the Hao-Orlin algorithm.
    3939///
     
    4343namespace lemon {
    4444
    45   /// \ingroup flowalgs
     45  /// \ingroup min_cut
    4646  ///
    4747  /// \brief %Hao-Orlin algorithm to find a minimum cut in directed graphs.
  • lemon/johnson.h

    r2335 r2376  
    2020#define LEMON_JOHNSON_H
    2121
    22 ///\ingroup flowalgs
     22///\ingroup shortest_path
    2323/// \file
    2424/// \brief Johnson algorithm.
     
    181181  /// \brief %Johnson algorithm class.
    182182  ///
    183   /// \ingroup flowalgs
     183  /// \ingroup shortest_path
    184184  /// This class provides an efficient implementation of \c %Johnson
    185185  /// algorithm. The edge lengths are passed to the algorithm using a
  • lemon/matrix_maps.h

    r2305 r2376  
    552552  ///"ReferenceMatrixMap".
    553553  ///
     554  ///\warning Do not use this map type when the two item sets are
     555  ///equal or based on the same item set.
     556  ///
    554557  ///\param _FirstContainer the desired type of first container. It is
    555558  ///ususally a Graph type, but can be any type with alteration
  • lemon/nagamochi_ibaraki.h

    r2337 r2376  
    1919
    2020
    21 /// \ingroup topology
     21/// \ingroup min_cut
    2222/// \file
    2323/// \brief Maximum cardinality search and minimum cut in undirected
     
    157157  };
    158158 
    159   /// \ingroup topology
     159  /// \ingroup search
    160160  ///
    161161  /// \brief Maximum Cardinality Search algorithm class.
     
    833833  };
    834834
    835   /// \ingroup topology
     835  /// \ingroup min_cut
    836836  ///
    837837  /// \brief Calculates the minimum cut in an undirected graph.
  • lemon/preflow.h

    r2350 r2376  
    3030
    3131/// \file
    32 /// \ingroup flowalgs
     32/// \ingroup max_flow
    3333/// \brief Implementation of the preflow algorithm.
    3434
    3535namespace lemon {
    3636
    37   ///\ingroup flowalgs
     37  ///\ingroup max_flow
    3838  ///\brief %Preflow algorithms class.
    3939  ///
     
    891891  };
    892892
    893   ///\ingroup flowalgs
     893  ///\ingroup max_flow
    894894  ///\brief Function type interface for Preflow algorithm.
    895895  ///
  • lemon/ssp_min_cost_flow.h

    r2350 r2376  
    2020#define LEMON_MIN_COST_FLOW_H
    2121
    22 ///\ingroup flowalgs
     22///\ingroup min_cost_flow
    2323///
    2424///\file
     
    3434namespace lemon {
    3535
    36   /// \addtogroup flowalgs
     36  /// \addtogroup min_cost_flow
    3737  /// @{
    3838
  • lemon/suurballe.h

    r2335 r2376  
    3232namespace lemon {
    3333
    34 /// \addtogroup flowalgs
     34/// \addtogroup shortest_path
    3535/// @{
    3636
Note: See TracChangeset for help on using the changeset viewer.