COIN-OR::LEMON - Graph Library

Changeset 1221:1c978b5bcc65 in lemon


Ignore:
Timestamp:
03/18/13 17:41:19 (5 years ago)
Author:
Alpar Juttner <alpar@…>
Branch:
default
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.