Index: doc/graphs.dox
===================================================================
--- doc/graphs.dox (revision 880)
+++ doc/graphs.dox (revision 911)
@@ -29,5 +29,5 @@
The implemented graph structures are the following.
\li \ref hugo::ListGraph "ListGraph" is the most versatile graph class. It meets
-the hugo::skeleton::ErasableGraph "ErasableGraph" concept
+the \ref hugo::skeleton::ErasableGraph "ErasableGraph" concept
and it also have some convenience features.
\li \ref hugo::SmartGraph "SmartGraph" is a more memory
@@ -46,5 +46,5 @@
are shared by the edge pairs.
\li \ref hugo::FullGraph "FullGraph"
-implements a full graph. It is a \ref ConstGraph, so you cannot
+implements a full graph. It is a \ref hugo::skeleton::StaticGraph, so you cannot
change the number of nodes once it is constructed. It is extremely memory
efficient: it uses constant amount of memory independently from the number of
Index: src/hugo/bfs.h
===================================================================
--- src/hugo/bfs.h (revision 906)
+++ src/hugo/bfs.h (revision 911)
@@ -50,11 +50,11 @@
///The type of the underlying graph.
typedef GR Graph;
- ///.
+ ///\e
typedef typename Graph::Node Node;
- ///.
+ ///\e
typedef typename Graph::NodeIt NodeIt;
- ///.
+ ///\e
typedef typename Graph::Edge Edge;
- ///.
+ ///\e
typedef typename Graph::OutEdgeIt OutEdgeIt;
@@ -109,4 +109,5 @@
///\param _G the graph the algorithm will run on.
+ ///
Bfs(const Graph& _G) :
G(&_G),
Index: src/hugo/dfs.h
===================================================================
--- src/hugo/dfs.h (revision 906)
+++ src/hugo/dfs.h (revision 911)
@@ -49,11 +49,11 @@
///The type of the underlying graph.
typedef GR Graph;
- /// .
+ ///\e
typedef typename Graph::Node Node;
- /// .
+ ///\e
typedef typename Graph::NodeIt NodeIt;
- /// .
+ ///\e
typedef typename Graph::Edge Edge;
- /// .
+ ///\e
typedef typename Graph::OutEdgeIt OutEdgeIt;
@@ -108,4 +108,5 @@
///\param _G the graph the algorithm will run on.
+ ///
Dfs(const Graph& _G) :
G(&_G),
Index: src/hugo/dijkstra.h
===================================================================
--- src/hugo/dijkstra.h (revision 906)
+++ src/hugo/dijkstra.h (revision 911)
@@ -72,11 +72,11 @@
///The type of the underlying graph.
typedef GR Graph;
- ///.
+ ///\e
typedef typename Graph::Node Node;
- ///.
+ ///\e
typedef typename Graph::NodeIt NodeIt;
- ///.
+ ///\e
typedef typename Graph::Edge Edge;
- ///.
+ ///\e
typedef typename Graph::OutEdgeIt OutEdgeIt;
Index: src/hugo/fib_heap.h
===================================================================
--- src/hugo/fib_heap.h (revision 906)
+++ src/hugo/fib_heap.h (revision 911)
@@ -36,5 +36,5 @@
///is a data structure for storing items with specified values called \e
///priorities in such a way that finding the item with minimum priority is
- ///efficient. \ref Compare specifies the ordering of the priorities. In a heap
+ ///efficient. \c Compare specifies the ordering of the priorities. In a heap
///one can change the priority of an item, add or erase an item, etc.
///
@@ -118,8 +118,8 @@
void push (Item const item, PrioType const value);
- ///Returns the item with minimum priority relative to \ref Compare.
-
- /**
- This method returns the item with minimum priority relative to \ref
+ ///Returns the item with minimum priority relative to \c Compare.
+
+ /**
+ This method returns the item with minimum priority relative to \c
Compare.
\pre The heap must be nonempty.
@@ -127,8 +127,8 @@
Item top() const { return container[minimum].name; }
- ///Returns the minimum priority relative to \ref Compare.
-
- /**
- It returns the minimum priority relative to \ref Compare.
+ ///Returns the minimum priority relative to \c Compare.
+
+ /**
+ It returns the minimum priority relative to \c Compare.
\pre The heap must be nonempty.
*/
@@ -156,8 +156,8 @@
- ///Deletes the item with minimum priority relative to \ref Compare.
-
- /**
- This method deletes the item with minimum priority relative to \ref
+ ///Deletes the item with minimum priority relative to \c Compare.
+
+ /**
+ This method deletes the item with minimum priority relative to \c
Compare from the heap.
\pre The heap must be non-empty.
@@ -178,5 +178,5 @@
This method decreases the priority of \c item to \c value.
\pre \c item must be stored in the heap with priority at least \c
- value relative to \ref Compare.
+ value relative to \c Compare.
*/
void decrease (Item item, PrioType const value);
@@ -188,5 +188,5 @@
there is no precondition on the priority of \c item, this
method should be used only if it is indeed necessary to increase
- (relative to \ref Compare) the priority of \c item, because this
+ (relative to \c Compare) the priority of \c item, because this
method is inefficient.
*/
Index: src/hugo/graph_wrapper.h
===================================================================
--- src/hugo/graph_wrapper.h (revision 910)
+++ src/hugo/graph_wrapper.h (revision 911)
@@ -606,4 +606,7 @@
/// bidirected graph made from a directed one.
///
+ /// A wrapper for composing a subgraph of a
+ /// bidirected graph made from a directed one.
+ ///
///\warning Graph wrappers are in even more experimental state than the other
///parts of the lib. Use them at you own risk.
Index: src/hugo/list_graph.h
===================================================================
--- src/hugo/list_graph.h (revision 909)
+++ src/hugo/list_graph.h (revision 911)
@@ -422,14 +422,14 @@
///of oppositely directed edges.
///There is a new edge map type called
- ///\ref SymListGraph::SymEdgeMap "SymEdgeMap"
+ ///\ref hugo::SymListGraph::SymEdgeMap "SymEdgeMap"
///that complements this
///feature by
///storing shared values for the edge pairs. The usual
- ///\ref Graph::EdgeMap "EdgeMap"
+ ///\ref hugo::skeleton::StaticGraph::EdgeMap "EdgeMap"
///can be used
///as well.
///
///The oppositely directed edge can also be obtained easily
- ///using \ref opposite.
+ ///using \ref hugo::SymListGraph::opposite() "opposite()" member function.
///
///Here erase(Edge) deletes a pair of edges.
Index: src/hugo/maps.h
===================================================================
--- src/hugo/maps.h (revision 906)
+++ src/hugo/maps.h (revision 911)
@@ -36,7 +36,7 @@
{
public:
- /// .
+ ///\e
typedef K KeyType;
- /// .
+ ///\e
typedef T ValueType;
};
@@ -75,7 +75,8 @@
/// (More exactly it will be default constructed.)
ConstMap() {}
- /// .
+ ///\e
/// \param _v The initial value of the map.
+ ///
ConstMap(const T &_v) : v(_v) {}
Index: src/hugo/preflow.h
===================================================================
--- src/hugo/preflow.h (revision 906)
+++ src/hugo/preflow.h (revision 911)
@@ -45,5 +45,6 @@
///setFlow.
///
- ///After running \ref phase1() or \ref preflow(), the actual flow
+ ///After running \ref hugo::Preflow::phase1() "phase1()"
+ ///or \ref hugo::Preflow::run() "run()", the actual flow
///value can be obtained by calling \ref flowValue(). The minimum
///value cut can be written into a bool node map by
@@ -97,6 +98,7 @@
///- \c PRE_FLOW: any preflow, i.e. the sum of the in-flows is at
///least the sum of the out-flows in every node except the \e source.
- ///- \c NO_FLOW: indicates an unspecified edge map. \ref flow will be
- ///set to the constant zero flow in the beginning of the algorithm in this case.
+ ///- \c NO_FLOW: indicates an unspecified edge map. \c flow will be
+ ///set to the constant zero flow in the beginning of
+ ///the algorithm in this case.
///
enum FlowEnum{
@@ -195,7 +197,7 @@
///minimum value cut can already be computed, though a maximum flow
///is not yet obtained. So after calling this method \ref flowValue
- ///and \ref actMinCut gives proper results.
- ///\warning \ref minCut, \ref minMinCut and \ref maxMinCut do not
- ///give minimum value cuts unless calling \ref phase2.
+ ///and \ref MinCut() gives proper results.
+ ///\warning \ref minCut(), \ref minMinCut() and \ref maxMinCut() do not
+ ///give minimum value cuts unless calling \ref phase2().
void phase1()
{
@@ -350,5 +352,5 @@
/// Returns the value of the maximum flow by returning the excess
- /// of the target node \ref t. This value equals to the value of
+ /// of the target node \c t. This value equals to the value of
/// the maximum flow already after running \ref phase1.
Num flowValue() const {
@@ -363,5 +365,5 @@
///phase1 and \ref phase2. It is much faster after
///\ref phase1. \pre M should be a bool-valued node-map. \pre
- ///If \ref mincut is called after \ref phase2 then M should
+ ///If \ref minCut() is called after \ref phase2() then M should
///be initialized to false.
template
@@ -426,5 +428,5 @@
///which is inclusionwise maximum. It is computed by processing a
///backward bfs from the target node \c t in the residual graph.
- ///\pre \ref phase2() or preflow() should already be run.
+ ///\pre \ref phase2() or run() should already be run.
template
void maxMinCut(_CutMap& M) const {
Index: src/hugo/skeletons/graph.h
===================================================================
--- src/hugo/skeletons/graph.h (revision 906)
+++ src/hugo/skeletons/graph.h (revision 911)
@@ -93,5 +93,5 @@
/// Inequality operator
- /// \sa \ref operator==(Node n)
+ /// \sa operator==(Node n)
///
bool operator!=(Node) const { return true; }
@@ -181,5 +181,5 @@
/// Inequality operator
- /// \sa \ref operator==(Node n)
+ /// \sa operator==(Node n)
///
bool operator!=(Edge) const { return true; }
@@ -383,10 +383,10 @@
int id(const Edge&) const { return 0; }
- /// .
+ ///\e
///\todo Should it be in the concept?
///
int nodeNum() const { return 0; }
- /// .
+ ///\e
///\todo Should it be in the concept?
@@ -406,7 +406,7 @@
public:
- /// .
+ ///\e
NodeMap(const StaticGraph&) { }
- /// .
+ ///\e
NodeMap(const StaticGraph&, T) { }
@@ -430,7 +430,7 @@
public:
- /// .
+ ///\e
EdgeMap(const StaticGraph&) { }
- /// .
+ ///\e
EdgeMap(const StaticGraph&, T) { }
Index: src/hugo/skeletons/sym_graph.h
===================================================================
--- src/hugo/skeletons/sym_graph.h (revision 909)
+++ src/hugo/skeletons/sym_graph.h (revision 911)
@@ -46,5 +46,5 @@
/// feature, the documentation of a real symmetric graph imlementation
/// like @ref SymListGraph or
- /// @ref SymSmartGraph will just refer to this structure.
+ /// @ref hugo::SymSmartGraph will just refer to this structure.
class StaticSymGraph
{
@@ -94,5 +94,5 @@
/// Inequality operator
- /// \sa \ref operator==(Node n)
+ /// \sa operator==(Node n)
///
bool operator!=(Node) const { return true; }
@@ -182,5 +182,5 @@
/// Inequality operator
- /// \sa \ref operator==(Node n)
+ /// \sa operator==(Node n)
///
bool operator!=(SymEdge) const { return true; }
@@ -224,5 +224,5 @@
/// Inequality operator
- /// \sa \ref operator==(Node n)
+ /// \sa operator==(Node n)
///
bool operator!=(Edge) const { return true; }
@@ -490,10 +490,10 @@
int id(const SymEdge&) const { return 0; }
- /// .
+ ///\e
///\todo Should it be in the concept?
///
int nodeNum() const { return 0; }
- /// .
+ ///\e
///\todo Should it be in the concept?
@@ -525,7 +525,7 @@
public:
- /// .
+ ///\e
NodeMap(const StaticSymGraph&) { }
- /// .
+ ///\e
NodeMap(const StaticSymGraph&, T) { }
@@ -549,7 +549,7 @@
public:
- /// .
+ ///\e
EdgeMap(const StaticSymGraph&) { }
- /// .
+ ///\e
EdgeMap(const StaticSymGraph&, T) { }
@@ -573,7 +573,7 @@
public:
- /// .
+ ///\e
SymEdgeMap(const StaticSymGraph&) { }
- /// .
+ ///\e
SymEdgeMap(const StaticSymGraph&, T) { }