[Lemon-commits] Alpar Juttner: Use doxygen's own bibtex support ...
Lemon HG
hg at lemon.cs.elte.hu
Tue Mar 19 15:42:33 CET 2013
details: http://lemon.cs.elte.hu/hg/lemon/rev/1c978b5bcc65
changeset: 1221:1c978b5bcc65
user: Alpar Juttner <alpar [at] cs.elte.hu>
date: Mon Mar 18 17:41:19 2013 +0100
description:
Use doxygen's own bibtex support (#456)
diffstat:
doc/CMakeLists.txt | 1 -
doc/Doxyfile.in | 1 +
doc/groups.dox | 42 +-
doc/mainpage.dox.in | 6 +-
doc/min_cost_flow.dox | 2 +-
lemon/capacity_scaling.h | 4 +-
lemon/cost_scaling.h | 4 +-
lemon/cycle_canceling.h | 8 +-
lemon/grosso_locatelli_pullan_mc.h | 2 +-
lemon/hartmann_orlin_mmc.h | 2 +-
lemon/howard_mmc.h | 2 +-
lemon/karp_mmc.h | 2 +-
lemon/network_simplex.h | 4 +-
lemon/preflow.h | 4 +-
scripts/bib2dox.py | 816 -------------------------------------
15 files changed, 42 insertions(+), 858 deletions(-)
diffs (truncated from 1144 to 300 lines):
diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt
--- a/doc/CMakeLists.txt
+++ b/doc/CMakeLists.txt
@@ -51,7 +51,6 @@
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r8 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps
COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r8 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps
COMMAND ${CMAKE_COMMAND} -E remove_directory html
- COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/scripts/bib2dox.py ${CMAKE_CURRENT_SOURCE_DIR}/references.bib >references.dox
COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
)
diff --git a/doc/Doxyfile.in b/doc/Doxyfile.in
--- a/doc/Doxyfile.in
+++ b/doc/Doxyfile.in
@@ -77,6 +77,7 @@
SHOW_NAMESPACES = YES
FILE_VERSION_FILTER =
LAYOUT_FILE = "@abs_top_srcdir@/doc/DoxygenLayout.xml"
+CITE_BIB_FILES = "@abs_top_srcdir@/doc/references.bib"
#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------
diff --git a/doc/groups.dox b/doc/groups.dox
--- a/doc/groups.dox
+++ b/doc/groups.dox
@@ -317,7 +317,7 @@
This group contains the common graph search algorithms, namely
\e breadth-first \e search (BFS) and \e depth-first \e search (DFS)
-\ref clrs01algorithms.
+\cite clrs01algorithms.
*/
/**
@@ -326,7 +326,7 @@
\brief Algorithms for finding shortest paths.
This group contains the algorithms for finding shortest paths in digraphs
-\ref clrs01algorithms.
+\cite clrs01algorithms.
- \ref Dijkstra algorithm for finding shortest paths from a source node
when all arc lengths are non-negative.
@@ -348,7 +348,7 @@
\brief Algorithms for finding minimum cost spanning trees and arborescences.
This group contains the algorithms for finding minimum cost spanning
-trees and arborescences \ref clrs01algorithms.
+trees and arborescences \cite clrs01algorithms.
*/
/**
@@ -357,7 +357,7 @@
\brief Algorithms for finding maximum flows.
This group contains the algorithms for finding maximum flows and
-feasible circulations \ref clrs01algorithms, \ref amo93networkflows.
+feasible circulations \cite clrs01algorithms, \cite amo93networkflows.
The \e maximum \e flow \e problem is to find a flow of maximum value between
a single source and a single target. Formally, there is a \f$G=(V,A)\f$
@@ -373,13 +373,13 @@
LEMON contains several algorithms for solving maximum flow problems:
- \ref EdmondsKarp Edmonds-Karp algorithm
- \ref edmondskarp72theoretical.
+ \cite edmondskarp72theoretical.
- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm
- \ref goldberg88newapproach.
+ \cite goldberg88newapproach.
- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees
- \ref dinic70algorithm, \ref sleator83dynamic.
+ \cite dinic70algorithm, \cite sleator83dynamic.
- \ref GoldbergTarjan !Preflow push-relabel algorithm with dynamic trees
- \ref goldberg88newapproach, \ref sleator83dynamic.
+ \cite goldberg88newapproach, \cite sleator83dynamic.
In most cases the \ref Preflow algorithm provides the
fastest method for computing a maximum flow. All implementations
@@ -399,20 +399,20 @@
\brief Algorithms for finding minimum cost flows and circulations.
This group contains the algorithms for finding minimum cost flows and
-circulations \ref amo93networkflows. For more information about this
+circulations \cite amo93networkflows. For more information about this
problem and its dual solution, see: \ref min_cost_flow
"Minimum Cost Flow Problem".
LEMON contains several algorithms for this problem.
- \ref NetworkSimplex Primal Network Simplex algorithm with various
- pivot strategies \ref dantzig63linearprog, \ref kellyoneill91netsimplex.
+ pivot strategies \cite dantzig63linearprog, \cite kellyoneill91netsimplex.
- \ref CostScaling Cost Scaling algorithm based on push/augment and
- relabel operations \ref goldberg90approximation, \ref goldberg97efficient,
- \ref bunnagel98efficient.
+ relabel operations \cite goldberg90approximation, \cite goldberg97efficient,
+ \cite bunnagel98efficient.
- \ref CapacityScaling Capacity Scaling algorithm based on the successive
- shortest path method \ref edmondskarp72theoretical.
+ shortest path method \cite edmondskarp72theoretical.
- \ref CycleCanceling Cycle-Canceling algorithms, two of which are
- strongly polynomial \ref klein67primal, \ref goldberg89cyclecanceling.
+ strongly polynomial \cite klein67primal, \cite goldberg89cyclecanceling.
In general, \ref NetworkSimplex and \ref CostScaling are the most efficient
implementations.
@@ -430,7 +430,7 @@
data are required to be integer).
For more details about these implementations and for a comprehensive
-experimental study, see the paper \ref KiralyKovacs12MCF.
+experimental study, see the paper \cite KiralyKovacs12MCF.
It also compares these codes to other publicly available
minimum cost flow solvers.
*/
@@ -471,7 +471,7 @@
\brief Algorithms for finding minimum mean cycles.
This group contains the algorithms for finding minimum mean cycles
-\ref amo93networkflows, \ref karp78characterization.
+\cite amo93networkflows, \cite karp78characterization.
The \e minimum \e mean \e cycle \e problem is to find a directed cycle
of minimum mean length (cost) in a digraph.
@@ -487,11 +487,11 @@
function.
LEMON contains three algorithms for solving the minimum mean cycle problem:
-- \ref KarpMmc Karp's original algorithm \ref karp78characterization.
+- \ref KarpMmc Karp's original algorithm \cite karp78characterization.
- \ref HartmannOrlinMmc Hartmann-Orlin's algorithm, which is an improved
- version of Karp's algorithm \ref hartmann93finding.
+ version of Karp's algorithm \cite hartmann93finding.
- \ref HowardMmc Howard's policy iteration algorithm
- \ref dasdan98minmeancycle, \ref dasdan04experimental.
+ \cite dasdan98minmeancycle, \cite dasdan04experimental.
In practice, the \ref HowardMmc "Howard" algorithm turned out to be by far the
most efficient one, though the best known theoretical bound on its running
@@ -647,8 +647,8 @@
Various LP solvers could be used in the same manner with this
high-level interface.
-The currently supported solvers are \ref glpk, \ref clp, \ref cbc,
-\ref cplex, \ref soplex.
+The currently supported solvers are \cite glpk, \cite clp, \cite cbc,
+\cite cplex, \cite soplex.
*/
/**
diff --git a/doc/mainpage.dox.in b/doc/mainpage.dox.in
--- a/doc/mainpage.dox.in
+++ b/doc/mainpage.dox.in
@@ -25,7 +25,7 @@
and <b>O</b>ptimization in <b>N</b>etworks</i>.
It is a C++ template library providing efficient implementations of common
data structures and algorithms with focus on combinatorial optimization
-tasks connected mainly with graphs and networks \ref DezsoJuttnerKovacs11Lemon.
+tasks connected mainly with graphs and networks \cite DezsoJuttnerKovacs11Lemon.
<b>
LEMON is an <a class="el" href="http://opensource.org/">open source</a>
@@ -37,12 +37,12 @@
The project is maintained by the
<a href="http://www.cs.elte.hu/egres/">Egerváry Research Group on
-Combinatorial Optimization</a> \ref egres
+Combinatorial Optimization</a> \cite egres
at the Operations Research Department of the
<a href="http://www.elte.hu/en/">Eötvös Loránd University</a>,
Budapest, Hungary.
LEMON is also a member of the <a href="http://www.coin-or.org/">COIN-OR</a>
-initiative \ref coinor.
+initiative \cite coinor.
\section howtoread How to Read the Documentation
diff --git a/doc/min_cost_flow.dox b/doc/min_cost_flow.dox
--- a/doc/min_cost_flow.dox
+++ b/doc/min_cost_flow.dox
@@ -26,7 +26,7 @@
The \e minimum \e cost \e flow \e problem is to find a feasible flow of
minimum total cost from a set of supply nodes to a set of demand nodes
in a network with capacity constraints (lower and upper bounds)
-and arc costs \ref amo93networkflows.
+and arc costs \cite amo93networkflows.
Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$,
\f$upper: A\rightarrow\mathbf{R}\cup\{+\infty\}\f$ denote the lower and
diff --git a/lemon/capacity_scaling.h b/lemon/capacity_scaling.h
--- a/lemon/capacity_scaling.h
+++ b/lemon/capacity_scaling.h
@@ -66,8 +66,8 @@
///
/// \ref CapacityScaling implements the capacity scaling version
/// of the successive shortest path algorithm for finding a
- /// \ref min_cost_flow "minimum cost flow" \ref amo93networkflows,
- /// \ref edmondskarp72theoretical. It is an efficient dual
+ /// \ref min_cost_flow "minimum cost flow" \cite amo93networkflows,
+ /// \cite edmondskarp72theoretical. It is an efficient dual
/// solution method, which runs in polynomial time
/// \f$O(e\log U (n+e)\log n)\f$, where <i>U</i> denotes the maximum
/// of node supply and arc capacity values.
diff --git a/lemon/cost_scaling.h b/lemon/cost_scaling.h
--- a/lemon/cost_scaling.h
+++ b/lemon/cost_scaling.h
@@ -91,8 +91,8 @@
///
/// \ref CostScaling implements a cost scaling algorithm that performs
/// push/augment and relabel operations for finding a \ref min_cost_flow
- /// "minimum cost flow" \ref amo93networkflows, \ref goldberg90approximation,
- /// \ref goldberg97efficient, \ref bunnagel98efficient.
+ /// "minimum cost flow" \cite amo93networkflows, \cite goldberg90approximation,
+ /// \cite goldberg97efficient, \cite bunnagel98efficient.
/// It is a highly efficient primal-dual solution method, which
/// can be viewed as the generalization of the \ref Preflow
/// "preflow push-relabel" algorithm for the maximum flow problem.
diff --git a/lemon/cycle_canceling.h b/lemon/cycle_canceling.h
--- a/lemon/cycle_canceling.h
+++ b/lemon/cycle_canceling.h
@@ -47,8 +47,8 @@
///
/// \ref CycleCanceling implements three different cycle-canceling
/// algorithms for finding a \ref min_cost_flow "minimum cost flow"
- /// \ref amo93networkflows, \ref klein67primal,
- /// \ref goldberg89cyclecanceling.
+ /// \cite amo93networkflows, \cite klein67primal,
+ /// \cite goldberg89cyclecanceling.
/// The most efficent one is the \ref CANCEL_AND_TIGHTEN
/// "Cancel-and-Tighten" algorithm, thus it is the default method.
/// It runs in strongly polynomial time O(n<sup>2</sup>e<sup>2</sup>log(n)),
@@ -131,13 +131,13 @@
SIMPLE_CYCLE_CANCELING,
/// The "Minimum Mean Cycle-Canceling" algorithm, which is a
/// well-known strongly polynomial method
- /// \ref goldberg89cyclecanceling. It improves along a
+ /// \cite goldberg89cyclecanceling. It improves along a
/// \ref min_mean_cycle "minimum mean cycle" in each iteration.
/// Its running time complexity is O(n<sup>2</sup>e<sup>3</sup>log(n)).
MINIMUM_MEAN_CYCLE_CANCELING,
/// The "Cancel-and-Tighten" algorithm, which can be viewed as an
/// improved version of the previous method
- /// \ref goldberg89cyclecanceling.
+ /// \cite goldberg89cyclecanceling.
/// It is faster both in theory and in practice, its running time
/// complexity is O(n<sup>2</sup>e<sup>2</sup>log(n)).
CANCEL_AND_TIGHTEN
diff --git a/lemon/grosso_locatelli_pullan_mc.h b/lemon/grosso_locatelli_pullan_mc.h
--- a/lemon/grosso_locatelli_pullan_mc.h
+++ b/lemon/grosso_locatelli_pullan_mc.h
@@ -40,7 +40,7 @@
///
/// \ref GrossoLocatelliPullanMc implements the iterated local search
/// algorithm of Grosso, Locatelli, and Pullan for solving the \e maximum
- /// \e clique \e problem \ref grosso08maxclique.
+ /// \e clique \e problem \cite grosso08maxclique.
/// It is to find the largest complete subgraph (\e clique) in an
/// undirected graph, i.e., the largest set of nodes where each
/// pair of nodes is connected.
diff --git a/lemon/hartmann_orlin_mmc.h b/lemon/hartmann_orlin_mmc.h
--- a/lemon/hartmann_orlin_mmc.h
+++ b/lemon/hartmann_orlin_mmc.h
@@ -98,7 +98,7 @@
///
/// This class implements the Hartmann-Orlin algorithm for finding
/// a directed cycle of minimum mean cost in a digraph
- /// \ref hartmann93finding, \ref dasdan98minmeancycle.
+ /// \cite hartmann93finding, \cite dasdan98minmeancycle.
/// This method is based on \ref KarpMmc "Karp"'s original algorithm, but
/// applies an early termination scheme. It makes the algorithm
/// significantly faster for some problem instances, but slower for others.
diff --git a/lemon/howard_mmc.h b/lemon/howard_mmc.h
--- a/lemon/howard_mmc.h
+++ b/lemon/howard_mmc.h
@@ -98,7 +98,7 @@
///
/// This class implements Howard's policy iteration algorithm for finding
/// a directed cycle of minimum mean cost in a digraph
- /// \ref dasdan98minmeancycle, \ref dasdan04experimental.
+ /// \cite dasdan98minmeancycle, \cite dasdan04experimental.
/// This class provides the most efficient algorithm for the
/// minimum mean cycle problem, though the best known theoretical
/// bound on its running time is exponential.
diff --git a/lemon/karp_mmc.h b/lemon/karp_mmc.h
--- a/lemon/karp_mmc.h
+++ b/lemon/karp_mmc.h
@@ -98,7 +98,7 @@
///
/// This class implements Karp's algorithm for finding a directed
/// cycle of minimum mean cost in a digraph
- /// \ref karp78characterization, \ref dasdan98minmeancycle.
+ /// \cite karp78characterization, \cite dasdan98minmeancycle.
/// It runs in time O(ne) and uses space O(n<sup>2</sup>+e).
///
/// \tparam GR The type of the digraph the algorithm runs on.
diff --git a/lemon/network_simplex.h b/lemon/network_simplex.h
--- a/lemon/network_simplex.h
+++ b/lemon/network_simplex.h
@@ -41,8 +41,8 @@
///
More information about the Lemon-commits
mailing list