# Changes in /[838:4e3484a2e90c:839:a2d5fd4c309a] in lemon

Ignore:
Files:
28 edited

Unmodified
Removed
• ## doc/min_cost_flow.dox

 r802 - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$. - For all \f$u\in V\f$ nodes: - \f$\pi(u)<=0\f$; - \f$\pi(u)\leq 0\f$; - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$, then \f$\pi(u)=0\f$. - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$. - For all \f$u\in V\f$ nodes: - \f$\pi(u)>=0\f$; - \f$\pi(u)\geq 0\f$; - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$, then \f$\pi(u)=0\f$.

• ## lemon/bellman_ford.h

 r828 /// \ref named-templ-param "Named parameter" for setting /// \c OperationTraits type. /// For more information see \ref BellmanFordDefaultOperationTraits. /// For more information, see \ref BellmanFordDefaultOperationTraits. template struct SetOperationTraits /// /// The shortest path tree used here is equal to the shortest path /// tree used in \ref predNode() and \predMap(). /// tree used in \ref predNode() and \ref predMap(). /// /// \pre Either \ref run() or \ref init() must be called before /// /// The shortest path tree used here is equal to the shortest path /// tree used in \ref predArc() and \predMap(). /// tree used in \ref predArc() and \ref predMap(). /// /// \pre Either \ref run() or \ref init() must be called before
• ## lemon/bfs.h

 r764 ///The type of the map that indicates which nodes are processed. ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. ///By default it is a NullMap. ///By default, it is a NullMap. typedef NullMap ProcessedMap; ///Instantiates a \c ProcessedMap. ///Runs the algorithm to visit all nodes in the digraph. ///This method runs the %BFS algorithm in order to ///compute the shortest path to each node. /// ///The algorithm computes ///- the shortest path tree (forest), ///- the distance of each node from the root(s). ///This method runs the %BFS algorithm in order to visit all nodes ///in the digraph. /// ///\note b.run(s) is just a shortcut of the following code. ///The type of the map that indicates which nodes are processed. ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. ///By default it is a NullMap. ///By default, it is a NullMap. typedef NullMap ProcessedMap; ///Instantiates a ProcessedMap. ///Runs BFS algorithm to visit all nodes in the digraph. ///This method runs BFS algorithm in order to compute ///the shortest path to each node. ///This method runs BFS algorithm in order to visit all nodes ///in the digraph. void run() { /// \brief Runs the algorithm to visit all nodes in the digraph. /// /// This method runs the %BFS algorithm in order to /// compute the shortest path to each node. /// /// The algorithm computes /// - the shortest path tree (forest), /// - the distance of each node from the root(s). /// This method runs the %BFS algorithm in order to visit all nodes /// in the digraph. /// /// \note b.run(s) is just a shortcut of the following code.
• ## lemon/circulation.h

 r762 /// able to automatically created by the algorithm (i.e. the /// digraph and the maximum level should be passed to it). /// However an external elevator object could also be passed to the /// However, an external elevator object could also be passed to the /// algorithm with the \ref elevator(Elevator&) "elevator()" function /// before calling \ref run() or \ref init().
• ## lemon/concepts/digraph.h

 r781 /// This iterator goes through each node of the digraph. /// Its usage is quite simple, for example you can count the number /// Its usage is quite simple, for example, you can count the number /// of nodes in a digraph \c g of type \c %Digraph like this: ///\code /// This iterator goes trough the \e outgoing arcs of a certain node /// of a digraph. /// Its usage is quite simple, for example you can count the number /// Its usage is quite simple, for example, you can count the number /// of outgoing arcs of a node \c n /// in a digraph \c g of type \c %Digraph as follows. /// This iterator goes trough the \e incoming arcs of a certain node /// of a digraph. /// Its usage is quite simple, for example you can count the number /// Its usage is quite simple, for example, you can count the number /// of incoming arcs of a node \c n /// in a digraph \c g of type \c %Digraph as follows. /// This iterator goes through each arc of the digraph. /// Its usage is quite simple, for example you can count the number /// Its usage is quite simple, for example, you can count the number /// of arcs in a digraph \c g of type \c %Digraph as follows: ///\code
• ## lemon/concepts/graph.h

 r781 /// This iterator goes through each node of the graph. /// Its usage is quite simple, for example you can count the number /// Its usage is quite simple, for example, you can count the number /// of nodes in a graph \c g of type \c %Graph like this: ///\code /// This iterator goes through each edge of the graph. /// Its usage is quite simple, for example you can count the number /// Its usage is quite simple, for example, you can count the number /// of edges in a graph \c g of type \c %Graph as follows: ///\code /// This iterator goes trough the incident undirected edges /// of a certain node of a graph. /// Its usage is quite simple, for example you can compute the /// Its usage is quite simple, for example, you can compute the /// degree (i.e. the number of incident edges) of a node \c n /// in a graph \c g of type \c %Graph as follows. /// This iterator goes through each directed arc of the graph. /// Its usage is quite simple, for example you can count the number /// Its usage is quite simple, for example, you can count the number /// of arcs in a graph \c g of type \c %Graph as follows: ///\code /// This iterator goes trough the \e outgoing directed arcs of a /// certain node of a graph. /// Its usage is quite simple, for example you can count the number /// Its usage is quite simple, for example, you can count the number /// of outgoing arcs of a node \c n /// in a graph \c g of type \c %Graph as follows. /// This iterator goes trough the \e incoming directed arcs of a /// certain node of a graph. /// Its usage is quite simple, for example you can count the number /// Its usage is quite simple, for example, you can count the number /// of incoming arcs of a node \c n /// in a graph \c g of type \c %Graph as follows. /// Returns the first node of the given edge. /// /// Edges don't have source and target nodes, however methods /// Edges don't have source and target nodes, however, methods /// u() and v() are used to query the two end-nodes of an edge. /// The orientation of an edge that arises this way is called /// Returns the second node of the given edge. /// /// Edges don't have source and target nodes, however methods /// Edges don't have source and target nodes, however, methods /// u() and v() are used to query the two end-nodes of an edge. /// The orientation of an edge that arises this way is called
• ## lemon/concepts/graph_components.h

 r781 ///\ingroup graph_concepts ///\file ///\brief The concept of graph components. ///\brief The concepts of graph components. #ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H
• ## lemon/concepts/path.h

 r606 ///\ingroup concept ///\file ///\brief Classes for representing paths in digraphs. ///\brief The concept of paths /// /// A skeleton structure for representing directed paths in a /// digraph. /// In a sense, a path can be treated as a list of arcs. /// LEMON path types just store this list. As a consequence, they cannot /// enumerate the nodes on the path directly and a zero length path /// cannot store its source node. /// /// The arcs of a path should be stored in the order of their directions, /// i.e. the target node of each arc should be the same as the source /// node of the next arc. This consistency could be checked using /// \ref checkPath(). /// The source and target nodes of a (consistent) path can be obtained /// using \ref pathSource() and \ref pathTarget(). /// /// A path can be constructed from another path of any type using the /// copy constructor or the assignment operator. /// /// \tparam GR The digraph type in which the path is. /// /// In a sense, the path can be treated as a list of arcs. The /// lemon path type stores just this list. As a consequence it /// cannot enumerate the nodes in the path and the zero length /// paths cannot store the source. /// template class Path { Path() {} /// \brief Template constructor /// \brief Template copy constructor template Path(const CPath& cpath) {} /// \brief Template assigment /// \brief Template assigment operator template Path& operator=(const CPath& cpath) { } /// Length of the path ie. the number of arcs in the path. /// Length of the path, i.e. the number of arcs on the path. int length() const { return 0;} void clear() {} /// \brief LEMON style iterator for path arcs /// \brief LEMON style iterator for enumerating the arcs of a path. /// /// This class is used to iterate on the arcs of the paths. /// LEMON style iterator class for enumerating the arcs of a path. class ArcIt { public: /// Invalid constructor ArcIt(Invalid) {} /// Constructor for first arc /// Sets the iterator to the first arc of the given path ArcIt(const Path &) {} /// Conversion to Arc /// Conversion to \c Arc operator Arc() const { return INVALID; } /// /// A skeleton structure for path dumpers. The path dumpers are /// the generalization of the paths. The path dumpers can /// enumerate the arcs of the path wheter in forward or in /// backward order.  In most time these classes are not used /// directly rather it used to assign a dumped class to a real /// path type. /// the generalization of the paths, they can enumerate the arcs /// of the path either in forward or in backward order. /// These classes are typically not used directly, they are rather /// used to be assigned to a real path type. /// /// The main purpose of this concept is that the shortest path /// algorithms can enumerate easily the arcs in reverse order. /// If we would like to give back a real path from these /// algorithms then we should create a temporarly path object. In /// LEMON such algorithms gives back a path dumper what can /// assigned to a real path and the dumpers can be implemented as /// algorithms can enumerate the arcs easily in reverse order. /// In LEMON, such algorithms give back a (reverse) path dumper that /// can be assigned to a real path. The dumpers can be implemented as /// an adaptor class to the predecessor map. /// /// \tparam GR The digraph type in which the path is. /// /// The paths can be constructed from any path type by a /// template constructor or a template assignment operator. template class PathDumper { typedef typename Digraph::Arc Arc; /// Length of the path ie. the number of arcs in the path. /// Length of the path, i.e. the number of arcs on the path. int length() const { return 0;} /// \brief Forward or reverse dumping /// /// If the RevPathTag is defined and true then reverse dumping /// is provided in the path dumper. In this case instead of the /// ArcIt the RevArcIt iterator should be implemented in the /// dumper. /// If this tag is defined to be \c True, then reverse dumping /// is provided in the path dumper. In this case, \c RevArcIt /// iterator should be implemented instead of \c ArcIt iterator. typedef False RevPathTag; /// \brief LEMON style iterator for path arcs /// \brief LEMON style iterator for enumerating the arcs of a path. /// /// This class is used to iterate on the arcs of the paths. /// LEMON style iterator class for enumerating the arcs of a path. class ArcIt { public: /// Invalid constructor ArcIt(Invalid) {} /// Constructor for first arc /// Sets the iterator to the first arc of the given path ArcIt(const PathDumper&) {} /// Conversion to Arc /// Conversion to \c Arc operator Arc() const { return INVALID; } }; /// \brief LEMON style iterator for path arcs /// \brief LEMON style iterator for enumerating the arcs of a path /// in reverse direction. /// /// This class is used to iterate on the arcs of the paths in /// reverse direction. /// LEMON style iterator class for enumerating the arcs of a path /// in reverse direction. class RevArcIt { public: /// Invalid constructor RevArcIt(Invalid) {} /// Constructor for first arc /// Sets the iterator to the last arc of the given path RevArcIt(const PathDumper &) {} /// Conversion to Arc /// Conversion to \c Arc operator Arc() const { return INVALID; }
• ## lemon/counter.h

 r463 /// 'Do nothing' version of Counter. /// This class can be used in the same way as \ref Counter however it /// This class can be used in the same way as \ref Counter, but it /// does not count at all and does not print report on destruction. ///
• ## lemon/dfs.h

 r764 ///The type of the map that indicates which nodes are processed. ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. ///By default it is a NullMap. ///By default, it is a NullMap. typedef NullMap ProcessedMap; ///Instantiates a \c ProcessedMap. ///Runs the algorithm to visit all nodes in the digraph. ///This method runs the %DFS algorithm in order to compute the ///%DFS path to each node. /// ///The algorithm computes ///- the %DFS tree (forest), ///- the distance of each node from the root(s) in the %DFS tree. ///This method runs the %DFS algorithm in order to visit all nodes ///in the digraph. /// ///\note d.run() is just a shortcut of the following code. ///The type of the map that indicates which nodes are processed. ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. ///By default it is a NullMap. ///By default, it is a NullMap. typedef NullMap ProcessedMap; ///Instantiates a ProcessedMap. ///Runs DFS algorithm to visit all nodes in the digraph. ///This method runs DFS algorithm in order to compute ///the DFS path to each node. ///This method runs DFS algorithm in order to visit all nodes ///in the digraph. void run() { /// \brief Runs the algorithm to visit all nodes in the digraph. /// This method runs the %DFS algorithm in order to /// compute the %DFS path to each node. /// /// The algorithm computes /// - the %DFS tree (forest), /// - the distance of each node from the root(s) in the %DFS tree. /// This method runs the %DFS algorithm in order to visit all nodes /// in the digraph. /// /// \note d.run() is just a shortcut of the following code.
• ## lemon/dijkstra.h

 r764 ///The type of the map that indicates which nodes are processed. ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. ///By default it is a NullMap. ///By default, it is a NullMap. typedef NullMap ProcessedMap; ///Instantiates a \c ProcessedMap. ///The type of the arc lengths. typedef typename TR::LengthMap::Value Value; typedef typename TR::Value Value; ///The type of the map that stores the arc lengths. typedef typename TR::LengthMap LengthMap; ///passed to the constructor of the cross reference and the cross ///reference should be passed to the constructor of the heap). ///However external heap and cross reference objects could also be ///However, external heap and cross reference objects could also be ///passed to the algorithm using the \ref heap() function before ///calling \ref run(Node) "run()" or \ref init(). ///\ref named-templ-param "Named parameter" for setting ///\c OperationTraits type. /// For more information see \ref DijkstraDefaultOperationTraits. /// For more information, see \ref DijkstraDefaultOperationTraits. template struct SetOperationTraits ///The type of the map that indicates which nodes are processed. ///It must conform to the \ref concepts::WriteMap "WriteMap" concept. ///By default it is a NullMap. ///By default, it is a NullMap. typedef NullMap ProcessedMap; ///Instantiates a ProcessedMap.
• ## lemon/edge_set.h

 r825 /// all arcs incident to the given node is erased from the arc set. /// /// This class fully conforms to the \ref concepts::Digraph /// "Digraph" concept. /// It provides only linear time counting for nodes and arcs. /// /// \param GR The type of the graph which shares its node set with /// this class. Its interface must conform to the /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph" /// concept. /// /// This class fully conforms to the \ref concepts::Digraph /// "Digraph" concept. template class ListArcSet : public ArcSetExtender > { /// incident to the given node is erased from the arc set. /// /// This class fully conforms to the \ref concepts::Graph "Graph" /// concept. /// It provides only linear time counting for nodes, edges and arcs. /// /// \param GR The type of the graph which shares its node set /// with this class. Its interface must conform to the /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph" /// concept. /// /// This class fully conforms to the \ref concepts::Graph "Graph" /// concept. template /// arcs. Therefore the arcs cannot be erased from the arc sets. /// /// This class fully conforms to the \ref concepts::Digraph "Digraph" /// concept. /// It provides only linear time counting for nodes and arcs. /// /// \warning If a node is erased from the underlying graph and this /// node is the source or target of one arc in the arc set, then /// the arc set is invalidated, and it cannot be used anymore. The /// validity can be checked with the \c valid() member function. /// /// This class fully conforms to the \ref concepts::Digraph /// "Digraph" concept. template class SmartArcSet : public ArcSetExtender > { /// edges cannot be erased from the edge sets. /// /// This class fully conforms to the \ref concepts::Graph "Graph" /// concept. /// It provides only linear time counting for nodes, edges and arcs. /// /// \warning If a node is erased from the underlying graph and this /// node is incident to one edge in the edge set, then the edge set /// is invalidated, and it cannot be used anymore. The validity can /// be checked with the \c valid() member function. /// /// This class fully conforms to the \ref concepts::Graph /// "Graph" concept. template class SmartEdgeSet : public EdgeSetExtender > {
• ## lemon/full_graph.h

 r827 /// only in the concept class. /// /// This class provides constant time counting for nodes and arcs. /// /// \note FullDigraph and FullGraph classes are very similar, /// but there are two differences. While this class conforms only /// completely static, the nodes can be indexed with integers from /// the range [0..nodeNum()-1]. /// The index of a node is the same as its ID. /// \sa index() Node operator()(int ix) const { return Parent::operator()(ix); } /// completely static, the nodes can be indexed with integers from /// the range [0..nodeNum()-1]. /// The index of a node is the same as its ID. /// \sa operator()() static int index(const Node& node) { return Parent::index(node); } /// only in the concept class. /// /// This class provides constant time counting for nodes, edges and arcs. /// /// \note FullDigraph and FullGraph classes are very similar, /// but there are two differences. While FullDigraph /// completely static, the nodes can be indexed with integers from /// the range [0..nodeNum()-1]. /// The index of a node is the same as its ID. /// \sa index() Node operator()(int ix) const { return Parent::operator()(ix); } /// completely static, the nodes can be indexed with integers from /// the range [0..nodeNum()-1]. /// The index of a node is the same as its ID. /// \sa operator()() static int index(const Node& node) { return Parent::index(node); }
• ## lemon/gomory_hu.h

 r760 /// \pre \ref run() must be called before using this function. template Value minCutMap(const Node& s, ///< Value minCutMap(const Node& s, const Node& t, ///< CutMap& cutMap ///< ) const { Node sn = s, tn = t; /// \endcode /// does not necessarily give the same set of nodes. /// However it is ensured that /// However, it is ensured that /// \code /// MinCutNodeIt(gomory, s, t, true);
• ## lemon/graph_to_eps.h

 r664 ///\param gr  Reference to the graph to be printed. ///\param ost Reference to the output stream. ///By default it is std::cout. ///By default, it is std::cout. ///\param pros If it is \c true, then the \c ostream referenced by \c os ///will be explicitly deallocated by the destructor. ///Turn on/off pre-scaling ///By default graphToEps() rescales the whole image in order to avoid ///By default, graphToEps() rescales the whole image in order to avoid ///very big or very small bounding boxes. /// ///\param g Reference to the graph to be printed. ///\param os Reference to the output stream. ///By default it is std::cout. ///By default, it is std::cout. /// ///This function also has a lot of ///\endcode /// ///For more detailed examples see the \ref graph_to_eps_demo.cc demo file. ///For more detailed examples, see the \ref graph_to_eps_demo.cc demo file. /// ///\warning Don't forget to put the \ref GraphToEps::run() "run()"
• ## lemon/grid_graph.h

 r782 /// Most of its member functions and nested classes are documented /// only in the concept class. /// /// This class provides constant time counting for nodes, edges and arcs. class GridGraph : public ExtendedGridGraphBase { typedef ExtendedGridGraphBase Parent;
• ## lemon/hypercube_graph.h

 r827 /// differ only on one position in the binary form. /// This class is completely static and it needs constant memory space. /// Thus you can neither add nor delete nodes or edges, however /// Thus you can neither add nor delete nodes or edges, however, /// the structure can be resized using resize(). /// /// Most of its member functions and nested classes are documented /// only in the concept class. /// /// This class provides constant time counting for nodes, edges and arcs. /// /// \note The type of the indices is chosen to \c int for efficiency

 r646 ///\endcode /// /// By default the reader uses the first section in the file of the /// By default, the reader uses the first section in the file of the /// proper type. If a section has an optional name, then it can be /// selected for reading by giving an optional name parameter to the /// whitespaces are trimmed from each processed string. /// /// For example let's see a section, which contain several /// For example, let's see a section, which contain several /// integers, which should be inserted into a vector. ///\code
• ## lemon/list_graph.h

 r788 ///only in the concept class. /// ///This class provides only linear time counting for nodes and arcs. /// ///\sa concepts::Digraph ///\sa ListGraph ///\brief Erase a node from the digraph. /// ///This function erases the given node from the digraph. ///This function erases the given node along with its outgoing and ///incoming arcs from the digraph. /// ///\note All iterators referencing the removed node or the connected ///arcs are invalidated, of course. void erase(Node n) { Parent::erase(n); } /// ///This function erases the given arc from the digraph. /// ///\note All iterators referencing the removed arc are invalidated, ///of course. void erase(Arc a) { Parent::erase(a); } /// ///\note \c ArcIt and \c OutArcIt iterators referencing the changed ///arc remain valid, however \c InArcIt iterators are invalidated. ///arc remain valid, but \c InArcIt iterators are invalidated. /// ///\warning This functionality cannot be used together with the Snapshot /// ///\note \c InArcIt iterators referencing the changed arc remain ///valid, however \c ArcIt and \c OutArcIt iterators are invalidated. ///valid, but \c ArcIt and \c OutArcIt iterators are invalidated. /// ///\warning This functionality cannot be used together with the Snapshot ///This function erases all nodes and arcs from the digraph. /// ///\note All iterators of the digraph are invalidated, of course. void clear() { Parent::clear(); /// reversing, contracting, splitting arcs or nodes) cannot be /// restored. These events invalidate the snapshot. /// However the arcs and nodes that were added to the digraph after /// However, the arcs and nodes that were added to the digraph after /// making the current snapshot can be removed without invalidating it. class Snapshot { ///only in the concept class. /// ///This class provides only linear time counting for nodes, edges and arcs. /// ///\sa concepts::Graph ///\sa ListDigraph ///\brief Erase a node from the graph. /// /// This function erases the given node from the graph. /// This function erases the given node along with its incident arcs /// from the graph. /// /// \note All iterators referencing the removed node or the incident /// edges are invalidated, of course. void erase(Node n) { Parent::erase(n); } /// /// This function erases the given edge from the graph. /// /// \note All iterators referencing the removed edge are invalidated, /// of course. void erase(Edge e) { Parent::erase(e); } /// Node validity check /// ///\note \c EdgeIt iterators referencing the changed edge remain ///valid, however \c ArcIt iterators referencing the changed edge and ///valid, but \c ArcIt iterators referencing the changed edge and ///all other iterators whose base node is the changed node are also ///invalidated. ///This function erases all nodes and arcs from the graph. /// ///\note All iterators of the graph are invalidated, of course. void clear() { Parent::clear(); /// (e.g. changing the end-nodes of edges or contracting nodes) /// cannot be restored. These events invalidate the snapshot. /// However the edges and nodes that were added to the graph after /// However, the edges and nodes that were added to the graph after /// making the current snapshot can be removed without invalidating it. class Snapshot {
• ## lemon/lp_base.h

 r793 ///Iterator for iterate over the columns of an LP problem /// Its usage is quite simple, for example you can count the number /// Its usage is quite simple, for example, you can count the number /// of columns in an LP \c lp: ///\code ///Iterator for iterate over the rows of an LP problem /// Its usage is quite simple, for example you can count the number /// Its usage is quite simple, for example, you can count the number /// of rows in an LP \c lp: ///\code
• ## lemon/maps.h

 r836 /// This map is essentially a wrapper for \c std::vector. It assigns /// values to integer keys from the range [0..size-1]. /// It can be used with some data structures, for example /// \c UnionFind, \c BinHeap, when the used items are small /// It can be used together with some data structures, e.g. /// heap types and \c UnionFind, when the used items are small /// integers. This map conforms to the \ref concepts::ReferenceMap /// "ReferenceMap" concept. /// "ReferenceMap" concept. /// /// The simplest way of using this map is through the rangeMap() /// The name of this type also refers to this important usage. /// /// Apart form that this map can be used in many other cases since it /// Apart form that, this map can be used in many other cases since it /// is based on \c std::map, which is a general associative container. /// However keep in mind that it is usually not as efficient as other /// However, keep in mind that it is usually not as efficient as other /// maps. /// /// The most important usage of it is storing certain nodes or arcs /// that were marked \c true by an algorithm. /// For example it makes easier to store the nodes in the processing /// For example, it makes easier to store the nodes in the processing /// order of Dfs algorithm, as the following examples show. /// \code /// /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so /// it cannot be used when a readable map is needed, for example as /// it cannot be used when a readable map is needed, for example, as /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms. /// /// Otherwise consider to use \c IterableValueMap, which is more /// suitable and more efficient for such cases. It provides iterators /// to traverse the items with the same associated value, however /// to traverse the items with the same associated value, but /// it does not have \c InverseMap. /// /// may provide alternative ways to modify the digraph. /// The correct behavior of InDegMap is not guarantied if these additional /// features are used. For example the functions /// features are used. For example, the functions /// \ref ListDigraph::changeSource() "changeSource()", /// \ref ListDigraph::changeTarget() "changeTarget()" and /// may provide alternative ways to modify the digraph. /// The correct behavior of OutDegMap is not guarantied if these additional /// features are used. For example the functions /// features are used. For example, the functions /// \ref ListDigraph::changeSource() "changeSource()", /// \ref ListDigraph::changeTarget() "changeTarget()" and

• ## lemon/preflow.h

 r802 /// able to automatically created by the algorithm (i.e. the /// digraph and the maximum level should be passed to it). /// However an external elevator object could also be passed to the /// However, an external elevator object could also be passed to the /// algorithm with the \ref elevator(Elevator&) "elevator()" function /// before calling \ref run() or \ref init().
• ## lemon/smart_graph.h

 r827 ///only in the concept class. /// ///This class provides constant time counting for nodes and arcs. /// ///\sa concepts::Digraph ///\sa SmartGraph /// only in the concept class. /// /// This class provides constant time counting for nodes, edges and arcs. /// /// \sa concepts::Graph /// \sa SmartDigraph
• ## lemon/static_graph.h

 r826 /// only in the concept class. /// /// This class provides constant time counting for nodes and arcs. /// /// \sa concepts::Digraph class StaticDigraph : public ExtendedStaticDigraphBase {
• ## lemon/time_measure.h

 r631 ///This function returns the number of stop() exections that is ///necessary to really stop the timer. ///For example the timer ///For example, the timer ///is running if and only if the return value is \c true ///(i.e. greater than
• ## lemon/unionfind.h

 r606 /// This is a very simple but efficient implementation, providing /// only four methods: join (union), find, insert and size. /// For more features see the \ref UnionFindEnum class. /// For more features, see the \ref UnionFindEnum class. /// /// It is primarily used in Kruskal algorithm for finding minimal
Note: See TracChangeset for help on using the changeset viewer.