doc/groups.dox
changeset 797 30cb42e3e43a
parent 663 8b0df68370a4
child 715 ece80147fb08
child 869 636dadefe1e6
equal deleted inserted replaced
29:44bea10dbfb9 30:62b55e0d5e85
   224 class. We use the implicit minimum time map as the length map of the
   224 class. We use the implicit minimum time map as the length map of the
   225 \c Dijkstra algorithm.
   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 @defgroup paths Path Structures
   229 @defgroup paths Path Structures
   238 @ingroup datas
   230 @ingroup datas
   239 \brief %Path structures implemented in LEMON.
   231 \brief %Path structures implemented in LEMON.
   240 
   232 
   241 This group contains the path structures implemented in LEMON.
   233 This group contains the path structures implemented in LEMON.
   244 All of them have similar interfaces and they can be copied easily with
   236 All of them have similar interfaces and they can be copied easily with
   245 assignment operators and copy constructors. This makes it easy and
   237 assignment operators and copy constructors. This makes it easy and
   246 efficient to have e.g. the Dijkstra algorithm to store its result in
   238 efficient to have e.g. the Dijkstra algorithm to store its result in
   247 any kind of path structure.
   239 any kind of path structure.
   248 
   240 
   249 \sa lemon::concepts::Path
   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 @defgroup auxdat Auxiliary Data Structures
   274 @defgroup auxdat Auxiliary Data Structures
   254 @ingroup datas
   275 @ingroup datas