COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changeset 1221:1c978b5bcc65 in lemon


Ignore:
Timestamp:
03/18/13 17:41:19 (11 years ago)
Author:
Alpar Juttner <alpar@…>
Branch:
default
Phase:
public
Message:

Use doxygen's own bibtex support (#456)

Files:
1 deleted
14 edited

Legend:

Unmodified
Added
Removed

  • doc/CMakeLists.txt

    r1218 r1221  
    5252    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r8 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps
    5353    COMMAND ${CMAKE_COMMAND} -E remove_directory html
    54     COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/scripts/bib2dox.py ${CMAKE_CURRENT_SOURCE_DIR}/references.bib >references.dox
    5554    COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile
    5655    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}

  • doc/Doxyfile.in

    r1208 r1221  
    7878FILE_VERSION_FILTER    =
    7979LAYOUT_FILE            = "@abs_top_srcdir@/doc/DoxygenLayout.xml"
     80CITE_BIB_FILES         = "@abs_top_srcdir@/doc/references.bib"
    8081#---------------------------------------------------------------------------
    8182# configuration options related to warning and progress messages

  • doc/groups.dox

    r1219 r1221  
    318318This group contains the common graph search algorithms, namely
    319319\e breadth-first \e search (BFS) and \e depth-first \e search (DFS)
    320 \ref clrs01algorithms.
     320\cite clrs01algorithms.
    321321*/
    322322
    … …  
    327327
    328328This group contains the algorithms for finding shortest paths in digraphs
    329 \ref clrs01algorithms.
     329\cite clrs01algorithms.
    330330
    331331 - \ref Dijkstra algorithm for finding shortest paths from a source node
    … …  
    349349
    350350This group contains the algorithms for finding minimum cost spanning
    351 trees and arborescences \ref clrs01algorithms.
     351trees and arborescences \cite clrs01algorithms.
    352352*/
    353353
    … …  
    358358
    359359This group contains the algorithms for finding maximum flows and
    360 feasible circulations \ref clrs01algorithms, \ref amo93networkflows.
     360feasible circulations \cite clrs01algorithms, \cite amo93networkflows.
    361361
    362362The \e maximum \e flow \e problem is to find a flow of maximum value between
    … …  
    374374LEMON contains several algorithms for solving maximum flow problems:
    375375- \ref EdmondsKarp Edmonds-Karp algorithm
    376   \ref edmondskarp72theoretical.
     376  \cite edmondskarp72theoretical.
    377377- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm
    378   \ref goldberg88newapproach.
     378  \cite goldberg88newapproach.
    379379- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees
    380   \ref dinic70algorithm, \ref sleator83dynamic.
     380  \cite dinic70algorithm, \cite sleator83dynamic.
    381381- \ref GoldbergTarjan !Preflow push-relabel algorithm with dynamic trees
    382   \ref goldberg88newapproach, \ref sleator83dynamic.
     382  \cite goldberg88newapproach, \cite sleator83dynamic.
    383383
    384384In most cases the \ref Preflow algorithm provides the
    … …  
    400400
    401401This group contains the algorithms for finding minimum cost flows and
    402 circulations \ref amo93networkflows. For more information about this
     402circulations \cite amo93networkflows. For more information about this
    403403problem and its dual solution, see: \ref min_cost_flow
    404404"Minimum Cost Flow Problem".
    … …  
    406406LEMON contains several algorithms for this problem.
    407407 - \ref NetworkSimplex Primal Network Simplex algorithm with various
    408    pivot strategies \ref dantzig63linearprog, \ref kellyoneill91netsimplex.
     408   pivot strategies \cite dantzig63linearprog, \cite kellyoneill91netsimplex.
    409409 - \ref CostScaling Cost Scaling algorithm based on push/augment and
    410    relabel operations \ref goldberg90approximation, \ref goldberg97efficient,
    411    \ref bunnagel98efficient.
     410   relabel operations \cite goldberg90approximation, \cite goldberg97efficient,
     411   \cite bunnagel98efficient.
    412412 - \ref CapacityScaling Capacity Scaling algorithm based on the successive
    413    shortest path method \ref edmondskarp72theoretical.
     413   shortest path method \cite edmondskarp72theoretical.
    414414 - \ref CycleCanceling Cycle-Canceling algorithms, two of which are
    415    strongly polynomial \ref klein67primal, \ref goldberg89cyclecanceling.
     415   strongly polynomial \cite klein67primal, \cite goldberg89cyclecanceling.
    416416
    417417In general, \ref NetworkSimplex and \ref CostScaling are the most efficient
    … …  
    431431
    432432For more details about these implementations and for a comprehensive
    433 experimental study, see the paper \ref KiralyKovacs12MCF.
     433experimental study, see the paper \cite KiralyKovacs12MCF.
    434434It also compares these codes to other publicly available
    435435minimum cost flow solvers.
    … …  
    472472
    473473This group contains the algorithms for finding minimum mean cycles
    474 \ref amo93networkflows, \ref karp78characterization.
     474\cite amo93networkflows, \cite karp78characterization.
    475475
    476476The \e minimum \e mean \e cycle \e problem is to find a directed cycle
    … …  
    488488
    489489LEMON contains three algorithms for solving the minimum mean cycle problem:
    490 - \ref KarpMmc Karp's original algorithm \ref karp78characterization.
     490- \ref KarpMmc Karp's original algorithm \cite karp78characterization.
    491491- \ref HartmannOrlinMmc Hartmann-Orlin's algorithm, which is an improved
    492   version of Karp's algorithm \ref hartmann93finding.
     492  version of Karp's algorithm \cite hartmann93finding.
    493493- \ref HowardMmc Howard's policy iteration algorithm
    494   \ref dasdan98minmeancycle, \ref dasdan04experimental.
     494  \cite dasdan98minmeancycle, \cite dasdan04experimental.
    495495
    496496In practice, the \ref HowardMmc "Howard" algorithm turned out to be by far the
    … …  
    648648high-level interface.
    649649
    650 The currently supported solvers are \ref glpk, \ref clp, \ref cbc,
    651 \ref cplex, \ref soplex.
     650The currently supported solvers are \cite glpk, \cite clp, \cite cbc,
     651\cite cplex, \cite soplex.
    652652*/
    653653

  • doc/mainpage.dox.in

    r1219 r1221  
    2626It is a C++ template library providing efficient implementations of common
    2727data structures and algorithms with focus on combinatorial optimization
    28 tasks connected mainly with graphs and networks \ref DezsoJuttnerKovacs11Lemon.
     28tasks connected mainly with graphs and networks \cite DezsoJuttnerKovacs11Lemon.
    2929
    3030<b>
    … …  
    3838The project is maintained by the
    3939<a href="http://www.cs.elte.hu/egres/">Egerv&aacute;ry Research Group on
    40 Combinatorial Optimization</a> \ref egres
     40Combinatorial Optimization</a> \cite egres
    4141at the Operations Research Department of the
    4242<a href="http://www.elte.hu/en/">E&ouml;tv&ouml;s Lor&aacute;nd University</a>,
    4343Budapest, Hungary.
    4444LEMON is also a member of the <a href="http://www.coin-or.org/">COIN-OR</a>
    45 initiative \ref coinor.
     45initiative \cite coinor.
    4646
    4747\section howtoread How to Read the Documentation

  • doc/min_cost_flow.dox

    r1164 r1221  
    2727minimum total cost from a set of supply nodes to a set of demand nodes
    2828in a network with capacity constraints (lower and upper bounds)
    29 and arc costs \ref amo93networkflows.
     29and arc costs \cite amo93networkflows.
    3030
    3131Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$,

  • lemon/capacity_scaling.h

    r1217 r1221  
    6767  /// \ref CapacityScaling implements the capacity scaling version
    6868  /// of the successive shortest path algorithm for finding a
    69   /// \ref min_cost_flow "minimum cost flow" \ref amo93networkflows,
    70   /// \ref edmondskarp72theoretical. It is an efficient dual
     69  /// \ref min_cost_flow "minimum cost flow" \cite amo93networkflows,
     70  /// \cite edmondskarp72theoretical. It is an efficient dual
    7171  /// solution method, which runs in polynomial time
    7272  /// \f$O(e\log U (n+e)\log n)\f$, where <i>U</i> denotes the maximum

  • lemon/cost_scaling.h

    r1217 r1221  
    9292  /// \ref CostScaling implements a cost scaling algorithm that performs
    9393  /// push/augment and relabel operations for finding a \ref min_cost_flow
    94   /// "minimum cost flow" \ref amo93networkflows, \ref goldberg90approximation,
    95   /// \ref goldberg97efficient, \ref bunnagel98efficient.
     94  /// "minimum cost flow" \cite amo93networkflows, \cite goldberg90approximation,
     95  /// \cite goldberg97efficient, \cite bunnagel98efficient.
    9696  /// It is a highly efficient primal-dual solution method, which
    9797  /// can be viewed as the generalization of the \ref Preflow

  • lemon/cycle_canceling.h

    r1217 r1221  
    4848  /// \ref CycleCanceling implements three different cycle-canceling
    4949  /// algorithms for finding a \ref min_cost_flow "minimum cost flow"
    50   /// \ref amo93networkflows, \ref klein67primal,
    51   /// \ref goldberg89cyclecanceling.
     50  /// \cite amo93networkflows, \cite klein67primal,
     51  /// \cite goldberg89cyclecanceling.
    5252  /// The most efficent one is the \ref CANCEL_AND_TIGHTEN
    5353  /// "Cancel-and-Tighten" algorithm, thus it is the default method.
    … …  
    132132      /// The "Minimum Mean Cycle-Canceling" algorithm, which is a
    133133      /// well-known strongly polynomial method
    134       /// \ref goldberg89cyclecanceling. It improves along a
     134      /// \cite goldberg89cyclecanceling. It improves along a
    135135      /// \ref min_mean_cycle "minimum mean cycle" in each iteration.
    136136      /// Its running time complexity is O(n<sup>2</sup>e<sup>3</sup>log(n)).
    … …  
    138138      /// The "Cancel-and-Tighten" algorithm, which can be viewed as an
    139139      /// improved version of the previous method
    140       /// \ref goldberg89cyclecanceling.
     140      /// \cite goldberg89cyclecanceling.
    141141      /// It is faster both in theory and in practice, its running time
    142142      /// complexity is O(n<sup>2</sup>e<sup>2</sup>log(n)).

  • lemon/grosso_locatelli_pullan_mc.h

    r1022 r1221  
    4141  /// \ref GrossoLocatelliPullanMc implements the iterated local search
    4242  /// algorithm of Grosso, Locatelli, and Pullan for solving the \e maximum
    43   /// \e clique \e problem \ref grosso08maxclique.
     43  /// \e clique \e problem \cite grosso08maxclique.
    4444  /// It is to find the largest complete subgraph (\e clique) in an
    4545  /// undirected graph, i.e., the largest set of nodes where each

  • lemon/hartmann_orlin_mmc.h

    r1217 r1221  
    9999  /// This class implements the Hartmann-Orlin algorithm for finding
    100100  /// a directed cycle of minimum mean cost in a digraph
    101   /// \ref hartmann93finding, \ref dasdan98minmeancycle.
     101  /// \cite hartmann93finding, \cite dasdan98minmeancycle.
    102102  /// This method is based on \ref KarpMmc "Karp"'s original algorithm, but
    103103  /// applies an early termination scheme. It makes the algorithm

  • lemon/howard_mmc.h

    r1217 r1221  
    9999  /// This class implements Howard's policy iteration algorithm for finding
    100100  /// a directed cycle of minimum mean cost in a digraph
    101   /// \ref dasdan98minmeancycle, \ref dasdan04experimental.
     101  /// \cite dasdan98minmeancycle, \cite dasdan04experimental.
    102102  /// This class provides the most efficient algorithm for the
    103103  /// minimum mean cycle problem, though the best known theoretical

  • lemon/karp_mmc.h

    r1217 r1221  
    9999  /// This class implements Karp's algorithm for finding a directed
    100100  /// cycle of minimum mean cost in a digraph
    101   /// \ref karp78characterization, \ref dasdan98minmeancycle.
     101  /// \cite karp78characterization, \cite dasdan98minmeancycle.
    102102  /// It runs in time O(ne) and uses space O(n<sup>2</sup>+e).
    103103  ///

  • lemon/network_simplex.h

    r1217 r1221  
    4242  /// \ref NetworkSimplex implements the primal Network Simplex algorithm
    4343  /// for finding a \ref min_cost_flow "minimum cost flow"
    44   /// \ref amo93networkflows, \ref dantzig63linearprog,
    45   /// \ref kellyoneill91netsimplex.
     44  /// \cite amo93networkflows, \cite dantzig63linearprog,
     45  /// \cite kellyoneill91netsimplex.
    4646  /// This algorithm is a highly efficient specialized version of the
    4747  /// linear programming simplex method directly for the minimum cost

  • lemon/preflow.h

    r1111 r1221  
    103103  /// This class provides an implementation of Goldberg-Tarjan's \e preflow
    104104  /// \e push-relabel algorithm producing a \ref max_flow
    105   /// "flow of maximum value" in a digraph \ref clrs01algorithms,
    106   /// \ref amo93networkflows, \ref goldberg88newapproach.
     105  /// "flow of maximum value" in a digraph \cite clrs01algorithms,
     106  /// \cite amo93networkflows, \cite goldberg88newapproach.
    107107  /// The preflow algorithms are the fastest known maximum
    108108  /// flow algorithms. The current implementation uses a mixture of the
Note: See TracChangeset for help on using the changeset viewer.