COIN-OR::LEMON - Graph Library

Changeset 1221:1c978b5bcc65 in lemon for lemon


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

Use doxygen's own bibtex support (#456)

Location:
lemon
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • 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.