Changeset 1946:17eb3eaad9f8 in lemon-0.x
- Timestamp:
- 02/02/06 18:43:24 (18 years ago)
- Branch:
- default
- Phase:
- public
- Convert:
- svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2521
- Location:
- lemon
- Files:
-
- 25 edited
Legend:
- Unmodified
- Added
- Removed
-
lemon/bellman_ford.h
r1875 r1946 545 545 /// 546 546 /// \note d.run(s) is just a shortcut of the following code. 547 /// 547 ///\code 548 548 /// d.init(); 549 549 /// d.addSource(s); 550 550 /// d.start(); 551 /// 551 ///\endcode 552 552 void run(Node s) { 553 553 init(); … … 566 566 /// 567 567 /// \note d.run(s, len) is just a shortcut of the following code. 568 /// 568 ///\code 569 569 /// d.init(); 570 570 /// d.addSource(s); 571 571 /// d.limitedStart(len); 572 /// 572 ///\endcode 573 573 void run(Node s, int len) { 574 574 init(); … … 929 929 /// The following 930 930 /// example shows how to use these parameters. 931 /// 931 ///\code 932 932 /// bellmanford(g,length,source).predMap(preds).run(); 933 /// 933 ///\endcode 934 934 /// \warning Don't forget to put the \ref BellmanFordWizard::run() "run()" 935 935 /// to the end of the parameter list. -
lemon/bits/alteration_notifier.h
r1910 r1946 21 21 #include <algorithm> 22 22 23 ///\ingro ingraphmapfactory23 ///\ingroup graphmapfactory 24 24 ///\file 25 25 ///\brief Observer registry for graph alteration observers. -
lemon/bits/array_map.h
r1910 r1946 24 24 #include <lemon/concept/maps.h> 25 25 26 /// \ingro ingraphmapfactory26 /// \ingroup graphmapfactory 27 27 /// \file 28 28 /// \brief Graph maps that construct and destruct … … 31 31 namespace lemon { 32 32 33 /// \ingro ingraphmapfactory33 /// \ingroup graphmapfactory 34 34 /// 35 35 /// \brief Graph map based on the array storage. -
lemon/bits/default_map.h
r1910 r1946 22 22 #include <lemon/bits/vector_map.h> 23 23 24 ///\ingro ingraphmapfactory24 ///\ingroup graphmapfactory 25 25 ///\file 26 26 ///\brief Graph maps that construct and destruct -
lemon/bits/item_reader.h
r1910 r1946 16 16 17 17 /// @defgroin item_io Item Readers and Writers 18 /// @ingro inio_groin18 /// @ingroup io_groin 19 19 /// \brief Item Readers and Writers 20 20 /// … … 23 23 /// read some way. The module make possible to do this. 24 24 25 /// \ingro initem_io25 /// \ingroup item_io 26 26 /// \file 27 27 /// \brief Item reader bits for lemon input. … … 43 43 class DefaultReader; 44 44 45 /// \ingro initem_io45 /// \ingroup item_io 46 46 /// 47 47 /// \brief Reader class for quoted strings. … … 158 158 }; 159 159 160 /// \ingro initem_io160 /// \ingroup item_io 161 161 /// \brief Reader for standard containers. 162 162 /// … … 205 205 }; 206 206 207 /// \ingro initem_io207 /// \ingroup item_io 208 208 /// 209 209 /// \brief Reader for standard containers. … … 253 253 }; 254 254 255 /// \ingro initem_io255 /// \ingroup item_io 256 256 /// \brief Reader for parsed string. 257 257 /// … … 301 301 }; 302 302 303 /// \ingro initem_io303 /// \ingroup item_io 304 304 /// \brief Reader for read the whole line. 305 305 /// … … 331 331 }; 332 332 333 /// \ingro initem_io333 /// \ingroup item_io 334 334 /// \brief Reader for std::pair. 335 335 /// … … 385 385 }; 386 386 387 /// \ingro initem_io387 /// \ingroup item_io 388 388 /// 389 389 /// \brief The default item reader template class. … … 472 472 : public PairReader<std::pair<First, Second> > {}; 473 473 474 /// \ingro initem_io474 /// \ingroup item_io 475 475 /// 476 476 /// \brief The default item reader for skipping a value in the stream. … … 481 481 class DefaultSkipper : public DefaultReader<std::string> {}; 482 482 483 /// \ingro initem_io483 /// \ingroup item_io 484 484 /// \brief Standard ReaderTraits for the GraphReader class. 485 485 /// -
lemon/bits/item_writer.h
r1910 r1946 15 15 */ 16 16 17 /// \ingro initem_io17 /// \ingroup item_io 18 18 /// \file 19 19 /// \brief Item writer bits for lemon output. … … 35 35 class DefaultWriter; 36 36 37 /// \ingro initem_io37 /// \ingroup item_io 38 38 /// \brief Writer class for quoted strings. 39 39 /// … … 118 118 }; 119 119 120 /// \ingro initem_io120 /// \ingroup item_io 121 121 /// \brief Writer class for quoted char array. 122 122 /// … … 146 146 147 147 148 /// \ingro initem_io148 /// \ingroup item_io 149 149 /// 150 150 /// \brief Writer for standard containers. … … 188 188 }; 189 189 190 /// \ingro initem_io190 /// \ingroup item_io 191 191 /// 192 192 /// \brief Writer for standard pairs. 193 193 /// 194 194 /// Writer for standard pairs. The representation of a pair is 195 /// 195 ///\code ( first_value => second_value ) \endcode. 196 196 /// \author Balazs Dezso 197 197 template <typename _Pair, … … 235 235 }; 236 236 237 /// \ingro initem_io237 /// \ingroup item_io 238 238 /// 239 239 /// \brief The default item writer template class. … … 308 308 : public PairWriter<std::pair<First, Second> > {}; 309 309 310 /// \ingro initem_io310 /// \ingroup item_io 311 311 /// \brief Standard WriterTraits for the section writers. 312 312 /// -
lemon/bits/static_map.h
r1910 r1946 28 28 #include <lemon/concept/maps.h> 29 29 30 /// \ingro ingraphmaps30 /// \ingroup graphmaps 31 31 /// 32 32 ///\file … … 35 35 namespace lemon { 36 36 37 /// \ingro ingraphmaps37 /// \ingroup graphmaps 38 38 /// 39 39 /// \brief Graph map with static sized storage. -
lemon/bits/vector_map.h
r1910 r1946 27 27 #include <lemon/concept/maps.h> 28 28 29 /// \ingro ingraphmapfactory29 /// \ingroup graphmapfactory 30 30 /// 31 31 ///\file … … 34 34 namespace lemon { 35 35 36 /// \ingro ingraphmapfactory36 /// \ingroup graphmapfactory 37 37 /// 38 38 /// \brief Graph map based on the std::vector storage. -
lemon/concept/bpugraph.h
r1933 r1946 245 245 /// Its usage is quite simple, for example you can count the number 246 246 /// of nodes in graph \c g of type \c Graph like this: 247 /// 247 ///\code 248 248 /// int count=0; 249 249 /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count; 250 /// 250 ///\endcode 251 251 class NodeIt : public Node { 252 252 public: … … 290 290 /// Its usage is quite simple, for example you can count the number 291 291 /// of nodes in graph \c g of type \c Graph like this: 292 /// 292 ///\code 293 293 /// int count=0; 294 294 /// for (Graph::ANodeIt n(g); n!=INVALID; ++n) ++count; 295 /// 295 ///\endcode 296 296 class ANodeIt : public ANode { 297 297 public: … … 335 335 /// Its usage is quite simple, for example you can count the number 336 336 /// of nodes in graph \c g of type \c Graph like this: 337 /// 337 ///\code 338 338 /// int count=0; 339 339 /// for (Graph::BNodeIt n(g); n!=INVALID; ++n) ++count; 340 /// 340 ///\endcode 341 341 class BNodeIt : public BNode { 342 342 public: … … 426 426 /// Its usage is quite simple, for example you can count the number 427 427 /// of undirected edges in a graph \c g of type \c Graph as follows: 428 /// 428 ///\code 429 429 /// int count=0; 430 430 /// for(Graph::UEdgeIt e(g); e!=INVALID; ++e) ++count; 431 /// 431 ///\endcode 432 432 class UEdgeIt : public UEdge { 433 433 public: … … 474 474 /// of incident edges of a node \c n 475 475 /// in graph \c g of type \c Graph as follows. 476 /// 476 ///\code 477 477 /// int count=0; 478 478 /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count; 479 /// 479 ///\endcode 480 480 class IncEdgeIt : public UEdge { 481 481 public: … … 563 563 /// Its usage is quite simple, for example you can count the number 564 564 /// of edges in a graph \c g of type \c Graph as follows: 565 /// 565 ///\code 566 566 /// int count=0; 567 567 /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count; 568 /// 568 ///\endcode 569 569 class EdgeIt : public Edge { 570 570 public: … … 608 608 /// of outgoing edges of a node \c n 609 609 /// in graph \c g of type \c Graph as follows. 610 /// 610 ///\code 611 611 /// int count=0; 612 612 /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count; 613 /// 613 ///\endcode 614 614 615 615 class OutEdgeIt : public Edge { … … 660 660 /// of outgoing edges of a node \c n 661 661 /// in graph \c g of type \c Graph as follows. 662 /// 662 ///\code 663 663 /// int count=0; 664 664 /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count; 665 /// 665 ///\endcode 666 666 667 667 class InEdgeIt : public Edge { -
lemon/concept/graph.h
r1909 r1946 193 193 /// Its usage is quite simple, for example you can count the number 194 194 /// of nodes in graph \c g of type \c Graph like this: 195 /// 195 ///\code 196 196 /// int count=0; 197 197 /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count; 198 /// 198 ///\endcode 199 199 class NodeIt : public Node { 200 200 public: … … 286 286 /// of outgoing edges of a node \c n 287 287 /// in graph \c g of type \c Graph as follows. 288 /// 288 ///\code 289 289 /// int count=0; 290 290 /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count; 291 /// 291 ///\endcode 292 292 293 293 class OutEdgeIt : public Edge { … … 333 333 /// of outgoing edges of a node \c n 334 334 /// in graph \c g of type \c Graph as follows. 335 /// 335 ///\code 336 336 /// int count=0; 337 337 /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count; 338 /// 338 ///\endcode 339 339 340 340 class InEdgeIt : public Edge { … … 377 377 /// Its usage is quite simple, for example you can count the number 378 378 /// of edges in a graph \c g of type \c Graph as follows: 379 /// 379 ///\code 380 380 /// int count=0; 381 381 /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count; 382 /// 382 ///\endcode 383 383 class EdgeIt : public Edge { 384 384 public: -
lemon/concept/ugraph.h
r1910 r1946 305 305 /// Its usage is quite simple, for example you can count the number 306 306 /// of nodes in graph \c g of type \c Graph like this: 307 /// 307 ///\code 308 308 /// int count=0; 309 309 /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count; 310 /// 310 ///\endcode 311 311 class NodeIt : public Node { 312 312 public: … … 396 396 /// Its usage is quite simple, for example you can count the number 397 397 /// of undirected edges in a graph \c g of type \c Graph as follows: 398 /// 398 ///\code 399 399 /// int count=0; 400 400 /// for(Graph::UEdgeIt e(g); e!=INVALID; ++e) ++count; 401 /// 401 ///\endcode 402 402 class UEdgeIt : public UEdge { 403 403 public: … … 444 444 /// of incident edges of a node \c n 445 445 /// in graph \c g of type \c Graph as follows. 446 /// 446 ///\code 447 447 /// int count=0; 448 448 /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count; 449 /// 449 ///\endcode 450 450 class IncEdgeIt : public UEdge { 451 451 public: … … 533 533 /// Its usage is quite simple, for example you can count the number 534 534 /// of edges in a graph \c g of type \c Graph as follows: 535 /// 535 ///\code 536 536 /// int count=0; 537 537 /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count; 538 /// 538 ///\endcode 539 539 class EdgeIt : public Edge { 540 540 public: … … 578 578 /// of outgoing edges of a node \c n 579 579 /// in graph \c g of type \c Graph as follows. 580 /// 580 ///\code 581 581 /// int count=0; 582 582 /// for (Graph::OutEdgeIt e(g, n); e!=INVALID; ++e) ++count; 583 /// 583 ///\endcode 584 584 585 585 class OutEdgeIt : public Edge { … … 630 630 /// of outgoing edges of a node \c n 631 631 /// in graph \c g of type \c Graph as follows. 632 /// 632 ///\code 633 633 /// int count=0; 634 634 /// for(Graph::InEdgeIt e(g, n); e!=INVALID; ++e) ++count; 635 /// 635 ///\endcode 636 636 637 637 class InEdgeIt : public Edge { -
lemon/dag_shortest_path.h
r1912 r1946 117 117 /// 118 118 /// This function instantiates a \ref PredMap. 119 /// \param G is the graph, to which we would like to define the PredMap. 119 /// \param graph is the graph, to which we would 120 /// like to define the PredMap. 120 121 /// \todo The graph alone may be insufficient for the initialization 121 122 static PredMap *createPredMap(const _Graph& graph) { … … 134 135 /// 135 136 /// This function instantiates a \ref DistMap. 136 /// \param Gis the graph, to which we would like to define the137 /// \param graph is the graph, to which we would like to define the 137 138 /// \ref DistMap 138 139 static DistMap *createDistMap(const _Graph& graph) { … … 228 229 /// 229 230 /// This function instantiates a \ref PredMap. 230 /// \param G is the graph, to which we would like to define the PredMap. 231 /// \param graph is the graph, 232 /// to which we would like to define the PredMap. 231 233 /// \todo The graph alone may be insufficient for the initialization 232 234 static PredMap *createPredMap(const _Graph& graph) { … … 245 247 /// 246 248 /// This function instantiates a \ref DistMap. 247 /// \param Gis the graph, to which we would like to define the249 /// \param graph is the graph, to which we would like to define the 248 250 /// \ref DistMap 249 251 static DistMap *createDistMap(const _Graph& graph) { … … 682 684 /// 683 685 /// \note d.run(s) is just a shortcut of the following code. 684 /// 686 ///\code 685 687 /// d.init(); 686 688 /// d.addSource(s); 687 689 /// d.start(); 688 /// 690 ///\endcode 689 691 void run(Node s) { 690 692 init(); … … 978 980 /// 979 981 /// Runs DagShortestPath algorithm from the given node. 980 /// \param s is the given source.982 /// \param source is the given source. 981 983 void run(Node source) { 982 984 Base::_source = source; … … 1043 1045 /// 1044 1046 /// Sets the source node, from which the DagShortestPath algorithm runs. 1045 /// \param s is the source node.1047 /// \param source is the source node. 1046 1048 DagShortestPathWizard<_Traits>& source(Node source) { 1047 1049 Base::_source = source; … … 1061 1063 /// The following 1062 1064 /// example shows how to use these parameters. 1063 /// 1065 ///\code 1064 1066 /// dagShortestPath(g,length,source).predMap(preds).run(); 1065 /// 1067 ///\endcode 1066 1068 /// \warning Don't forget to put the \ref DagShortestPathWizard::run() "run()" 1067 1069 /// to the end of the parameter list. -
lemon/dfs.h
r1875 r1946 1443 1443 /// This method runs the %DFS algorithm from a root node \c s. 1444 1444 /// \note d.run(s) is just a shortcut of the following code. 1445 /// 1445 ///\code 1446 1446 /// d.init(); 1447 1447 /// d.addSource(s); 1448 1448 /// d.start(); 1449 /// 1449 ///\endcode 1450 1450 void run(Node s) { 1451 1451 init(); -
lemon/dimacs.h
r1875 r1946 45 45 /// This function reads a min cost flow instance from dimacs format, 46 46 /// i.e. from dimacs files having a line starting with 47 /// 47 ///\code 48 48 /// p "min" 49 /// 49 ///\endcode 50 50 /// At the beginning \c g is cleared by \c g.clear(). The edge 51 51 /// capacities are written to \c capacity, \c s and \c t are set to … … 125 125 /// This function reads a max flow instance from dimacs format, 126 126 /// i.e. from dimacs files having a line starting with 127 /// 127 ///\code 128 128 /// p "max" 129 /// 129 ///\endcode 130 130 ///At the beginning \c g is cleared by \c g.clear(). The 131 131 /// edge capacities are written to \c capacity and \c s and \c t are … … 145 145 /// This function reads a shortest path instance from dimacs format, 146 146 /// i.e. from dimacs files having a line starting with 147 /// 147 ///\code 148 148 /// p "sp" 149 /// 149 ///\endcode 150 150 /// At the beginning \c g is cleared by \c g.clear(). The edge 151 151 /// capacities are written to \c capacity and \c s is set to the … … 181 181 /// maps from dimacs format, i.e. from dimacs files having a line 182 182 /// starting with 183 /// 183 ///\code 184 184 /// p "mat" 185 /// 185 ///\endcode 186 186 /// At the beginning \c g is cleared 187 187 /// by \c g.clear(). -
lemon/floyd_warshall.h
r1875 r1946 118 118 /// 119 119 /// This function instantiates a \ref PredMap. 120 /// \param G is the graph, to which we would like to define the PredMap. 120 /// \param graph is the graph, 121 /// to which we would like to define the PredMap. 121 122 /// \todo The graph alone may be insufficient for the initialization 122 123 static PredMap *createPredMap(const _Graph& graph) { … … 134 135 /// 135 136 /// This function instantiates a \ref DistMap. 136 /// \param Gis the graph, to which we would like to define the137 /// \param graph is the graph, to which we would like to define the 137 138 /// \ref DistMap 138 139 static DistMap *createDistMap(const _Graph& graph) { … … 455 456 /// 456 457 /// \note d.run(s) is just a shortcut of the following code. 457 /// 458 ///\code 458 459 /// d.init(); 459 460 /// d.start(); 460 /// 461 ///\endcode 461 462 void run() { 462 463 init(); -
lemon/fredman_tarjan.h
r1912 r1946 66 66 67 67 ///This function instantiates a \ref TreeMap. 68 ///\param gis the graph, to which68 ///\param _graph is the graph, to which 69 69 ///we would like to define the \ref TreeMap 70 70 static TreeMap *createTreeMap(const GR &_graph){ -
lemon/graph_adaptor.h
r1909 r1946 189 189 /// suppose that a graph instange \c g of type 190 190 /// \c ListGraph implements \f$G\f$. 191 /// 191 ///\code 192 192 /// ListGraph g; 193 /// 193 ///\endcode 194 194 /// For each directed edge 195 195 /// \f$e\in A\f$, let \f$\bar e\f$ denote the edge obtained by … … 200 200 /// reversing the orientation of its edges. The following code shows how 201 201 /// such an instance can be constructed. 202 /// 202 ///\code 203 203 /// RevGraphAdaptor<ListGraph> gw(g); 204 /// 204 ///\endcode 205 205 ///\author Marton Makai 206 206 207 template<typename _Graph> 207 208 class RevGraphAdaptor : … … 1279 1280 /// For blocking flows. 1280 1281 1281 ///\warning Graph adaptors are in even more experimental state than the other 1282 ///\warning Graph adaptors are in even more 1283 ///experimental state than the other 1282 1284 ///parts of the lib. Use them at you own risk. 1283 1285 /// 1284 /// This graph adaptor is used for on-the-fly 1285 /// Dinits blocking flow computations. 1286 /// For each node, an out-edge is stored which is used when the 1287 /// \code 1288 /// OutEdgeIt& first(OutEdgeIt&, const Node&) 1289 /// \endcode 1290 /// is called. 1286 ///This graph adaptor is used for on-the-fly 1287 ///Dinits blocking flow computations. 1288 ///For each node, an out-edge is stored which is used when the 1289 ///\code OutEdgeIt& first(OutEdgeIt&, const Node&)\endcode 1290 ///is called. 1291 1291 /// 1292 /// \author Marton Makai 1292 ///\author Marton Makai 1293 /// 1293 1294 template <typename _Graph, typename FirstOutEdgesMap> 1294 1295 class ErasingFirstGraphAdaptor : -
lemon/graph_reader.h
r1935 r1946 55 55 /// it should skip the values when the string representation contains spaces. 56 56 /// 57 /// 57 ///\code 58 58 /// GraphReader<ListGraph> reader(std::cin, graph); 59 /// 59 ///\endcode 60 60 /// 61 61 /// The \c readNodeMap() function reads a map from the \c \@nodeset section. … … 65 65 /// parameters. 66 66 /// 67 /// 67 ///\code 68 68 /// reader.readNodeMap("coords", coords); 69 69 /// … … 71 71 /// 72 72 /// reader.readNodeMap("color", colorMap); 73 /// 73 ///\endcode 74 74 /// 75 75 /// With the \c readEdgeMap() member function you can give an edge map 76 76 /// reading command similar to the NodeMaps. 77 77 /// 78 /// 78 ///\code 79 79 /// reader.readEdgeMap("weight", weightMap); 80 80 /// reader.readEdgeMap("label", labelMap); 81 /// 81 ///\endcode 82 82 /// 83 83 /// With \c readNode() and \c readEdge() functions you can read 84 84 /// labeled Nodes and Edges. 85 85 /// 86 /// 86 ///\code 87 87 /// reader.readNode("source", sourceNode); 88 88 /// reader.readNode("target", targetNode); 89 89 /// 90 90 /// reader.readEdge("observed", edge); 91 /// 91 ///\endcode 92 92 /// 93 93 /// With the \c readAttribute() functions you can read an attribute … … 98 98 /// function, which executes all the commands. 99 99 /// 100 /// 100 ///\code 101 101 /// reader.run(); 102 /// 102 ///\endcode 103 103 /// 104 104 /// \see DefaultReaderTraits … … 399 399 /// it should skip the values when the string representation contains spaces. 400 400 /// 401 /// 401 ///\code 402 402 /// UGraphReader<ListUGraph> reader(std::cin, graph); 403 /// 403 ///\endcode 404 404 /// 405 405 /// The \c readNodeMap() function reads a map from the \c \@nodeset section. … … 409 409 /// parameters. 410 410 /// 411 /// 411 ///\code 412 412 /// reader.readNodeMap("coords", coords); 413 413 /// … … 415 415 /// 416 416 /// reader.readNodeMap("color", colorMap); 417 /// 417 ///\endcode 418 418 /// 419 419 /// With the \c readUEdgeMap() member function you can give an 420 420 /// uedge map reading command similar to the NodeMaps. 421 421 /// 422 /// 422 ///\code 423 423 /// reader.readUEdgeMap("capacity", capacityMap); 424 /// 424 ///\endcode 425 425 /// 426 426 /// The reading of the directed edge maps is just a syntactical sugar. … … 429 429 /// \c '-' character and the same. 430 430 /// 431 /// 431 ///\code 432 432 /// reader.readEdgeMap("flow", flowMap); 433 /// 433 ///\endcode 434 434 /// 435 435 /// With \c readNode() and \c readUEdge() functions you can read 436 436 /// labeled Nodes and UEdges. 437 437 /// 438 /// 438 ///\code 439 439 /// reader.readNode("source", sourceNode); 440 440 /// reader.readNode("target", targetNode); 441 441 /// 442 442 /// reader.readUEdge("observed", uEdge); 443 /// 443 ///\endcode 444 444 /// 445 445 /// With the \c readAttribute() functions you can read an attribute … … 450 450 /// function, which execute all the commands. 451 451 /// 452 /// 452 ///\code 453 453 /// reader.run(); 454 /// 454 ///\endcode 455 455 /// 456 456 /// \see GraphReader -
lemon/graph_utils.h
r1931 r1946 259 259 /// 260 260 /// Thus you can iterate through each edge from \c u to \c v as it follows. 261 /// 261 ///\code 262 262 /// for(Edge e=findEdge(g,u,v);e!=INVALID;e=findEdge(g,u,v,e)) { 263 263 /// ... 264 264 /// } 265 /// 265 ///\endcode 266 266 // /// \todo We may want to use the "GraphBase" 267 267 // /// interface here... … … 279 279 /// higher level interface for the findEdge() function. You can 280 280 /// use it the following way: 281 /// 281 ///\code 282 282 /// for (ConEdgeIt<Graph> it(g, src, trg); it != INVALID; ++it) { 283 283 /// ... 284 284 /// } 285 /// 285 ///\endcode 286 286 /// 287 287 /// \author Balazs Dezso … … 361 361 /// 362 362 /// Thus you can iterate through each edge from \c u to \c v as it follows. 363 /// 363 ///\code 364 364 /// for(UEdge e = findUEdge(g,u,v); e != INVALID; 365 365 /// e = findUEdge(g,u,v,e)) { 366 366 /// ... 367 367 /// } 368 /// 368 ///\endcode 369 369 // /// \todo We may want to use the "GraphBase" 370 370 // /// interface here... … … 383 383 /// higher level interface for the findUEdge() function. You can 384 384 /// use it the following way: 385 /// 385 ///\code 386 386 /// for (ConUEdgeIt<Graph> it(g, src, trg); it != INVALID; ++it) { 387 387 /// ... 388 388 /// } 389 /// 389 ///\endcode 390 390 /// 391 391 /// \author Balazs Dezso … … 581 581 /// The usage of the function: 582 582 /// 583 /// 583 ///\code 584 584 /// copyGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr); 585 /// 585 ///\endcode 586 586 /// 587 587 /// After the copy the \c nr map will contain the mapping from the … … 793 793 /// The usage of the function: 794 794 /// 795 /// 795 ///\code 796 796 /// copyGraph(trg, src).nodeRef(nr).edgeCrossRef(ecr); 797 /// 797 ///\endcode 798 798 /// 799 799 /// After the copy the \c nr map will contain the mapping from the -
lemon/graph_writer.h
r1909 r1946 48 48 /// Edge writing. 49 49 /// 50 /// 50 ///\code 51 51 /// GraphWriter<ListGraph> writer(std::cout, graph); 52 /// 52 ///\endcode 53 53 /// 54 54 /// The \c writeNodeMap() function declares a \c NodeMap writing … … 58 58 /// is regarded as label map (such a map is essential if the graph has edges). 59 59 /// 60 /// 60 ///\code 61 61 /// IdMap<ListGraph, Node> nodeLabelMap; 62 62 /// writer.writeNodeMap("label", nodeLabelMap); … … 64 64 /// writer.writeNodeMap("coords", coords); 65 65 /// writer.writeNodeMap("color", colorMap); 66 /// 66 ///\endcode 67 67 /// 68 68 /// With the \c writeEdgeMap() member function you can give an edge map 69 69 /// writing command similar to the NodeMaps. 70 70 /// 71 /// 71 ///\code 72 72 /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> > 73 73 /// edgeDescMap(graph); … … 76 76 /// writer.writeEdgeMap("weight", weightMap); 77 77 /// writer.writeEdgeMap("label", labelMap); 78 /// 78 ///\endcode 79 79 /// 80 80 /// With \c writeNode() and \c writeEdge() functions you can … … 82 82 /// write out the source and target of a maximum flow instance. 83 83 /// 84 /// 84 ///\code 85 85 /// writer.writeNode("source", sourceNode); 86 86 /// writer.writeNode("target", targetNode); 87 87 /// 88 88 /// writer.writeEdge("observed", edge); 89 /// 89 ///\endcode 90 90 /// 91 91 /// After you give all write commands you must call the \c run() member 92 92 /// function, which executes all the writing commands. 93 93 /// 94 /// 94 ///\code 95 95 /// writer.run(); 96 /// 96 ///\endcode 97 97 /// 98 98 /// \see DefaultWriterTraits … … 321 321 /// writing and labeled Node, Edge or UEdge writing. 322 322 /// 323 /// 323 ///\code 324 324 /// UGraphWriter<ListUGraph> writer(std::cout, graph); 325 /// 325 ///\endcode 326 326 /// 327 327 /// The \c writeNodeMap() function declares a \c NodeMap writing … … 331 331 /// is regarded as label map. 332 332 /// 333 /// 333 ///\code 334 334 /// IdMap<ListUGraph, Node> nodeLabelMap; 335 335 /// writer.writeNodeMap("label", nodeLabelMap); … … 337 337 /// writer.writeNodeMap("coords", coords); 338 338 /// writer.writeNodeMap("color", colorMap); 339 /// 339 ///\endcode 340 340 /// 341 341 /// With the \c writeUEdgeMap() member function you can give an 342 342 /// undirected edge map writing command similar to the NodeMaps. 343 343 /// 344 /// 344 ///\code 345 345 /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> > 346 346 /// edgeDescMap(graph); … … 349 349 /// writer.writeUEdgeMap("weight", weightMap); 350 350 /// writer.writeUEdgeMap("label", labelMap); 351 /// 351 ///\endcode 352 352 /// 353 353 /// The EdgeMap handling is just a syntactical sugar. It writes 354 354 /// two undirected edge map with '+' and '-' prefix in the name. 355 355 /// 356 /// 356 ///\code 357 357 /// writer.writeEdgeMap("capacity", capacityMap); 358 /// 358 ///\endcode 359 359 /// 360 360 /// … … 363 363 /// write out the source and target of the graph. 364 364 /// 365 /// 365 ///\code 366 366 /// writer.writeNode("source", sourceNode); 367 367 /// writer.writeNode("target", targetNode); 368 368 /// 369 369 /// writer.writeUEdge("observed", uEdge); 370 /// 370 ///\endcode 371 371 /// 372 372 /// After you give all write commands you must call the \c run() member 373 373 /// function, which executes all the writing commands. 374 374 /// 375 /// 375 ///\code 376 376 /// writer.run(); 377 /// 377 ///\endcode 378 378 /// 379 379 /// \see DefaultWriterTraits -
lemon/grid_graph.h
r1909 r1946 355 355 /// 356 356 /// The graph can be indiced in the following way: 357 /// 357 ///\code 358 358 /// GridGraph graph(w, h); 359 359 /// GridGraph::NodeMap<int> val(graph); … … 363 363 /// } 364 364 /// } 365 /// 365 ///\endcode 366 366 /// 367 367 /// The graph type is fully conform to the \ref concept::UGraph -
lemon/hypercube_graph.h
r1909 r1946 277 277 /// should be the dimension number of the graph. 278 278 /// 279 /// 279 ///\code 280 280 /// const int DIM = 3; 281 281 /// HyperCubeGraph graph(DIM); … … 287 287 /// HyperCubeGraph::HyperMap<xy<double> > 288 288 /// pos(graph, base, base + DIM, xy<double>(0.0, 0.0)); 289 /// 289 ///\endcode 290 290 /// 291 291 /// \see HyperCubeGraph -
lemon/johnson.h
r1916 r1946 609 609 /// 610 610 /// \note d.run(s) is just a shortcut of the following code. 611 /// 611 ///\code 612 612 /// d.init(); 613 613 /// d.start(); 614 /// 614 ///\endcode 615 615 void run() { 616 616 init(); -
lemon/kruskal.h
r1942 r1946 78 78 /// say 53 edges, then 79 79 /// we can put its edges into a STL vector \c tree with a code like this. 80 /// 80 ///\code 81 81 /// std::vector<Edge> tree(53); 82 82 /// kruskal(g,cost,tree.begin()); 83 /// 83 ///\endcode 84 84 /// Or if we don't know in advance the size of the tree, we can write this. 85 /// 85 ///\code 86 86 /// std::vector<Edge> tree; 87 87 /// kruskal(g,cost,std::back_inserter(tree)); 88 /// 88 ///\endcode 89 89 /// 90 90 /// \return The cost of the found tree. … … 301 301 /// 302 302 /// A typical usage: 303 /// 303 ///\code 304 304 /// std::vector<Graph::Edge> v; 305 305 /// kruskal(g, input, makeKruskalSequenceOutput(back_inserter(v))); 306 /// 306 ///\endcode 307 307 /// 308 308 /// For the most common case, when the input is given by a simple edge … … 397 397 // say 53 edges, then 398 398 // we can put its edges into a STL vector \c tree with a code like this. 399 // 399 //\code 400 400 // std::vector<Edge> tree(53); 401 401 // kruskal(g,cost,tree.begin()); 402 // 402 //\endcode 403 403 // Or if we don't know in advance the size of the tree, we can write this. 404 // 404 //\code 405 405 // std::vector<Edge> tree; 406 406 // kruskal(g,cost,std::back_inserter(tree)); 407 // 407 //\endcode 408 408 // 409 409 // \return The cost of the found tree. -
lemon/lemon_reader.h
r1909 r1946 1963 1963 /// to know which sections, maps and items are in the file 1964 1964 /// use the next code: 1965 /// 1965 ///\code 1966 1966 /// LemonReader reader("input.lgf"); 1967 1967 /// ContentReader content(reader); 1968 1968 /// reader.run(); 1969 /// 1969 ///\endcode 1970 1970 class ContentReader : public LemonReader::SectionReader { 1971 1971 typedef LemonReader::SectionReader Parent;
Note: See TracChangeset
for help on using the changeset viewer.