COIN-OR::LEMON - Graph Library

Changeset 631:33c6b6e755cd in lemon


Ignore:
Timestamp:
04/15/09 02:04:37 (9 years ago)
Author:
Peter Kovacs <kpeter@…>
Branch:
default
Phase:
public
Message:

Small doc improvements (#263)

Files:
19 edited

Legend:

Unmodified
Added
Removed
  • lemon/bin_heap.h

    r606 r631  
    7474    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
    7575    enum State {
    76       IN_HEAP = 0,    ///< \e
    77       PRE_HEAP = -1,  ///< \e
    78       POST_HEAP = -2  ///< \e
     76      IN_HEAP = 0,    ///< = 0.
     77      PRE_HEAP = -1,  ///< = -1.
     78      POST_HEAP = -2  ///< = -2.
    7979    };
    8080
  • lemon/concepts/graph_components.h

    r627 r631  
    603603      typedef IterableDigraphComponent Digraph;
    604604
    605       /// \name Base iteration
     605      /// \name Base Iteration
    606606      ///
    607607      /// This interface provides functions for iteration on digraph items.
     
    655655      /// @}
    656656
    657       /// \name Class based iteration
     657      /// \name Class Based Iteration
    658658      ///
    659659      /// This interface provides iterator classes for digraph items.
     
    780780      typedef IterableGraphComponent Graph;
    781781
    782       /// \name Base iteration
     782      /// \name Base Iteration
    783783      ///
    784784      /// This interface provides functions for iteration on edges.
     
    819819      /// @}
    820820
    821       /// \name Class based iteration
     821      /// \name Class Based Iteration
    822822      ///
    823823      /// This interface provides iterator classes for edges.
  • lemon/concepts/heap.h

    r606 r631  
    7272      /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
    7373      enum State {
    74         IN_HEAP = 0,    ///< The "in heap" state constant.
    75         PRE_HEAP = -1,  ///< The "pre heap" state constant.
    76         POST_HEAP = -2  ///< The "post heap" state constant.
     74        IN_HEAP = 0,    ///< = 0. The "in heap" state constant.
     75        PRE_HEAP = -1,  ///< = -1. The "pre heap" state constant.
     76        POST_HEAP = -2  ///< = -2. The "post heap" state constant.
    7777      };
    7878
  • lemon/dfs.h

    r525 r631  
    207207    typedef Dfs Create;
    208208
    209     ///\name Named template parameters
     209    ///\name Named Template Parameters
    210210
    211211    ///@{
  • lemon/dijkstra.h

    r606 r631  
    287287    typedef Dijkstra Create;
    288288
    289     ///\name Named template parameters
     289    ///\name Named Template Parameters
    290290
    291291    ///@{
  • lemon/dimacs.h

    r608 r631  
    3838  struct DimacsDescriptor
    3939  {
    40     ///File type enum
    41     enum Type
    42       {
    43         NONE, MIN, MAX, SP, MAT
    44       };
     40    ///\brief DIMACS file type enum
     41    ///
     42    ///DIMACS file type enum.
     43    enum Type {
     44      NONE,  ///< Undefined type.
     45      MIN,   ///< DIMACS file type for minimum cost flow problems.
     46      MAX,   ///< DIMACS file type for maximum flow problems.
     47      SP,    ///< DIMACS file type for shostest path problems.
     48      MAT    ///< DIMACS file type for plain graphs and matching problems.
     49    };
    4550    ///The file type
    4651    Type type;
     
    5055    int edgeNum;
    5156    int lineShift;
    52     /// Constructor. Sets the type to NONE.
     57    ///Constructor. It sets the type to \c NONE.
    5358    DimacsDescriptor() : type(NONE) {}
    5459  };
     
    5661  ///Discover the type of a DIMACS file
    5762
    58   ///It starts seeking the beginning of the file for the problem type
    59   ///and size info. The found data is returned in a special struct
    60   ///that can be evaluated and passed to the appropriate reader
    61   ///function.
     63  ///This function starts seeking the beginning of the given file for the
     64  ///problem type and size info.
     65  ///The found data is returned in a special struct that can be evaluated
     66  ///and passed to the appropriate reader function.
    6267  DimacsDescriptor dimacsType(std::istream& is)
    6368  {
     
    97102
    98103
    99 
    100   /// DIMACS minimum cost flow reader function.
     104  /// \brief DIMACS minimum cost flow reader function.
    101105  ///
    102106  /// This function reads a minimum cost flow instance from DIMACS format,
     
    254258  }
    255259
    256   /// DIMACS maximum flow reader function.
     260  /// \brief DIMACS maximum flow reader function.
    257261  ///
    258262  /// This function reads a maximum flow instance from DIMACS format,
     
    288292  }
    289293
    290   /// DIMACS shortest path reader function.
     294  /// \brief DIMACS shortest path reader function.
    291295  ///
    292296  /// This function reads a shortest path instance from DIMACS format,
     
    314318  }
    315319
    316   /// DIMACS capacitated digraph reader function.
     320  /// \brief DIMACS capacitated digraph reader function.
    317321  ///
    318322  /// This function reads an arc capacitated digraph instance from
     
    360364  }
    361365 
    362   /// DIMACS plain (di)graph reader function.
    363   ///
    364   /// This function reads a (di)graph without any designated nodes and
    365   /// maps from DIMACS format, i.e. from DIMACS files having a line
    366   /// starting with
     366  /// \brief DIMACS plain (di)graph reader function.
     367  ///
     368  /// This function reads a plain (di)graph without any designated nodes
     369  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from
     370  /// DIMACS files having a line starting with
    367371  /// \code
    368372  ///   p mat
  • lemon/graph_to_eps.h

    r606 r631  
    269269    ///\image html nodeshape_1.png
    270270    ///\image latex nodeshape_1.eps "SQUARE shape (1)" width=2cm
    271     ///
    272271    SQUARE=1,
    273272    /// = 2
    274273    ///\image html nodeshape_2.png
    275274    ///\image latex nodeshape_2.eps "DIAMOND shape (2)" width=2cm
    276     ///
    277275    DIAMOND=2,
    278276    /// = 3
    279277    ///\image html nodeshape_3.png
    280     ///\image latex nodeshape_2.eps "MALE shape (4)" width=2cm
    281     ///
     278    ///\image latex nodeshape_3.eps "MALE shape (3)" width=2cm
    282279    MALE=3,
    283280    /// = 4
    284281    ///\image html nodeshape_4.png
    285     ///\image latex nodeshape_2.eps "FEMALE shape (4)" width=2cm
    286     ///
     282    ///\image latex nodeshape_4.eps "FEMALE shape (4)" width=2cm
    287283    FEMALE=4
    288284  };
  • lemon/kruskal.h

    r463 r631  
    249249  /// \ingroup spantree
    250250  ///
    251   /// \brief Kruskal algorithm to find a minimum cost spanning tree of
     251  /// \brief Kruskal's algorithm for finding a minimum cost spanning tree of
    252252  /// a graph.
    253253  ///
    254254  /// This function runs Kruskal's algorithm to find a minimum cost
    255   /// spanning tree.
     255  /// spanning tree of a graph.
    256256  /// Due to some C++ hacking, it accepts various input and output types.
    257257  ///
     
    265265  /// It can be one of the following choices.
    266266  /// - An STL compatible 'Forward Container' with
    267   /// <tt>std::pair<GR::Arc,X></tt> or
    268   /// <tt>std::pair<GR::Edge,X></tt> as its <tt>value_type</tt>, where
    269   /// \c X is the type of the costs. The pairs indicates the arcs/edges
     267  /// <tt>std::pair<GR::Arc,C></tt> or
     268  /// <tt>std::pair<GR::Edge,C></tt> as its <tt>value_type</tt>, where
     269  /// \c C is the type of the costs. The pairs indicates the arcs/edges
    270270  /// along with the assigned cost. <em>They must be in a
    271271  /// cost-ascending order.</em>
     
    274274  ///
    275275  /// \retval out Here we also have a choice.
    276   /// - It can be a writable \c bool arc/edge map. After running the
    277   /// algorithm it will contain the found minimum cost spanning
     276  /// - It can be a writable arc/edge map with \c bool value type. After
     277  /// running the algorithm it will contain the found minimum cost spanning
    278278  /// tree: the value of an arc/edge will be set to \c true if it belongs
    279279  /// to the tree, otherwise it will be set to \c false. The value of
     
    302302
    303303#ifdef DOXYGEN
    304   template <class Graph, class In, class Out>
    305   Value kruskal(GR const& g, const In& in, Out& out)
     304  template <typename Graph, typename In, typename Out>
     305  Value kruskal(const Graph& g, const In& in, Out& out)
    306306#else
    307307  template <class Graph, class In, class Out>
     
    315315
    316316
    317 
    318 
    319317  template <class Graph, class In, class Out>
    320318  inline typename _kruskal_bits::KruskalValueSelector<In>::Value
  • lemon/lgf_reader.h

    r606 r631  
    594594  public:
    595595
    596     /// \name Reading rules
     596    /// \name Reading Rules
    597597    /// @{
    598598
     
    699699    /// @}
    700700
    701     /// \name Select section by name
     701    /// \name Select Section by Name
    702702    /// @{
    703703
     
    728728    /// @}
    729729
    730     /// \name Using previously constructed node or arc set
     730    /// \name Using Previously Constructed Node or Arc Set
    731731    /// @{
    732732
     
    11171117  public:
    11181118
    1119     /// \name Execution of the reader
     1119    /// \name Execution of the Reader
    11201120    /// @{
    11211121
     
    13901390  public:
    13911391
    1392     /// \name Reading rules
     1392    /// \name Reading Rules
    13931393    /// @{
    13941394
     
    15411541    /// @}
    15421542
    1543     /// \name Select section by name
     1543    /// \name Select Section by Name
    15441544    /// @{
    15451545
     
    15701570    /// @}
    15711571
    1572     /// \name Using previously constructed node or edge set
     1572    /// \name Using Previously Constructed Node or Edge Set
    15731573    /// @{
    15741574
     
    19601960  public:
    19611961
    1962     /// \name Execution of the reader
     1962    /// \name Execution of the Reader
    19631963    /// @{
    19641964
     
    21592159  public:
    21602160
    2161     /// \name Section readers
     2161    /// \name Section Readers
    21622162    /// @{
    21632163
     
    22582258
    22592259
    2260     /// \name Execution of the reader
     2260    /// \name Execution of the Reader
    22612261    /// @{
    22622262
     
    24402440
    24412441
    2442     /// \name Node sections
     2442    /// \name Node Sections
    24432443    /// @{
    24442444
     
    24662466    /// @}
    24672467
    2468     /// \name Arc/Edge sections
     2468    /// \name Arc/Edge Sections
    24692469    /// @{
    24702470
     
    25242524    /// @}
    25252525
    2526     /// \name Attribute sections
     2526    /// \name Attribute Sections
    25272527    /// @{
    25282528
     
    25502550    /// @}
    25512551
    2552     /// \name Extra sections
     2552    /// \name Extra Sections
    25532553    /// @{
    25542554
     
    26262626  public:
    26272627
    2628     /// \name Execution of the contents reader
     2628    /// \name Execution of the Contents Reader
    26292629    /// @{
    26302630
  • lemon/lgf_writer.h

    r606 r631  
    539539  public:
    540540
    541     /// \name Writing rules
     541    /// \name Writing Rules
    542542    /// @{
    543543
     
    642642    }
    643643
    644     /// \name Section captions
     644    /// \name Section Captions
    645645    /// @{
    646646
     
    669669    }
    670670
    671     /// \name Skipping section
     671    /// \name Skipping Section
    672672    /// @{
    673673
     
    886886  public:
    887887
    888     /// \name Execution of the writer
     888    /// \name Execution of the Writer
    889889    /// @{
    890890
     
    11071107  public:
    11081108
    1109     /// \name Writing rules
     1109    /// \name Writing Rules
    11101110    /// @{
    11111111
     
    12561256    }
    12571257
    1258     /// \name Section captions
     1258    /// \name Section Captions
    12591259    /// @{
    12601260
     
    12831283    }
    12841284
    1285     /// \name Skipping section
     1285    /// \name Skipping Section
    12861286    /// @{
    12871287
     
    15001500  public:
    15011501
    1502     /// \name Execution of the writer
     1502    /// \name Execution of the Writer
    15031503    /// @{
    15041504
     
    16521652  public:
    16531653
    1654     /// \name Section writers
     1654    /// \name Section Writers
    16551655    /// @{
    16561656
     
    17191719
    17201720
    1721     /// \name Execution of the writer
     1721    /// \name Execution of the Writer
    17221722    /// @{
    17231723
  • lemon/lp_base.h

    r623 r631  
    5353    ///Possible outcomes of an LP solving procedure
    5454    enum SolveExitStatus {
    55       ///This means that the problem has been successfully solved: either
     55      /// = 0. It means that the problem has been successfully solved: either
    5656      ///an optimal solution has been found or infeasibility/unboundedness
    5757      ///has been proved.
    5858      SOLVED = 0,
    59       ///Any other case (including the case when some user specified
    60       ///limit has been exceeded)
     59      /// = 1. Any other case (including the case when some user specified
     60      ///limit has been exceeded).
    6161      UNSOLVED = 1
    6262    };
     
    7272    ///Enum for \c messageLevel() parameter
    7373    enum MessageLevel {
    74       /// no output (default value)
     74      /// No output (default value).
    7575      MESSAGE_NOTHING,
    76       /// error messages only
     76      /// Error messages only.
    7777      MESSAGE_ERROR,
    78       /// warnings
     78      /// Warnings.
    7979      MESSAGE_WARNING,
    80       /// normal output
     80      /// Normal output.
    8181      MESSAGE_NORMAL,
    82       /// verbose output
     82      /// Verbose output.
    8383      MESSAGE_VERBOSE
    8484    };
     
    10061006    const char* solverName() const {return _solverName();}
    10071007
    1008     ///\name Build up and modify the LP
     1008    ///\name Build Up and Modify the LP
    10091009
    10101010    ///@{
     
    17891789    /// The problem types for primal and dual problems
    17901790    enum ProblemType {
    1791       ///Feasible solution hasn't been found (but may exist).
     1791      /// = 0. Feasible solution hasn't been found (but may exist).
    17921792      UNDEFINED = 0,
    1793       ///The problem has no feasible solution
     1793      /// = 1. The problem has no feasible solution.
    17941794      INFEASIBLE = 1,
    1795       ///Feasible solution found
     1795      /// = 2. Feasible solution found.
    17961796      FEASIBLE = 2,
    1797       ///Optimal solution exists and found
     1797      /// = 3. Optimal solution exists and found.
    17981798      OPTIMAL = 3,
    1799       ///The cost function is unbounded
     1799      /// = 4. The cost function is unbounded.
    18001800      UNBOUNDED = 4
    18011801    };
     
    18531853    ///@}
    18541854
    1855     ///\name Obtain the solution
     1855    ///\name Obtain the Solution
    18561856
    18571857    ///@{
     
    19751975    /// The problem types for MIP problems
    19761976    enum ProblemType {
    1977       ///Feasible solution hasn't been found (but may exist).
     1977      /// = 0. Feasible solution hasn't been found (but may exist).
    19781978      UNDEFINED = 0,
    1979       ///The problem has no feasible solution
     1979      /// = 1. The problem has no feasible solution.
    19801980      INFEASIBLE = 1,
    1981       ///Feasible solution found
     1981      /// = 2. Feasible solution found.
    19821982      FEASIBLE = 2,
    1983       ///Optimal solution exists and found
     1983      /// = 3. Optimal solution exists and found.
    19841984      OPTIMAL = 3,
    1985       ///The cost function is unbounded
    1986       ///
    1987       ///The Mip or at least the relaxed problem is unbounded
     1985      /// = 4. The cost function is unbounded.
     1986      ///The Mip or at least the relaxed problem is unbounded.
    19881987      UNBOUNDED = 4
    19891988    };
     
    20072006    ///@}
    20082007
    2009     ///\name Setting column type
     2008    ///\name Set Column Type
    20102009    ///@{
    20112010
    20122011    ///Possible variable (column) types (e.g. real, integer, binary etc.)
    20132012    enum ColTypes {
    2014       ///Continuous variable (default)
     2013      /// = 0. Continuous variable (default).
    20152014      REAL = 0,
    2016       ///Integer variable
     2015      /// = 1. Integer variable.
    20172016      INTEGER = 1
    20182017    };
     
    20352034    ///@}
    20362035
    2037     ///\name Obtain the solution
     2036    ///\name Obtain the Solution
    20382037
    20392038    ///@{
  • lemon/maps.h

    r619 r631  
    27292729  /// \brief Potential difference map
    27302730  ///
    2731   /// PotentialMap returns the difference between the potentials of the
    2732   /// source and target nodes of each arc in a digraph, i.e. it returns
     2731  /// PotentialDifferenceMap returns the difference between the potentials of
     2732  /// the source and target nodes of each arc in a digraph, i.e. it returns
    27332733  /// \code
    27342734  ///   potential[gr.target(arc)] - potential[gr.source(arc)].
  • lemon/min_cost_arborescence.h

    r628 r631  
    9191  /// \ingroup spantree
    9292  ///
    93   /// \brief %MinCostArborescence algorithm class.
     93  /// \brief Minimum Cost Arborescence algorithm class.
    9494  ///
    9595  /// This class provides an efficient implementation of
    96   /// %MinCostArborescence algorithm. The arborescence is a tree
     96  /// Minimum Cost Arborescence algorithm. The arborescence is a tree
    9797  /// which is directed from a given source node of the digraph. One or
    9898  /// more sources should be given for the algorithm and it will calculate
     
    391391  public:
    392392
    393     /// \name Named template parameters
     393    /// \name Named Template Parameters
    394394
    395395    /// @{
     
    631631    /// @}
    632632
    633     /// \name Execution control
     633    /// \name Execution Control
    634634    /// The simplest way to execute the algorithm is to use
    635635    /// one of the member functions called \c run(...). \n
  • lemon/random.h

    r606 r631  
    660660    /// @}
    661661
    662     ///\name Uniform distributions
     662    ///\name Uniform Distributions
    663663    ///
    664664    /// @{
     
    763763    /// @}
    764764
    765     ///\name Non-uniform distributions
     765    ///\name Non-uniform Distributions
    766766    ///
    767767    ///@{
     
    939939    ///@}
    940940
    941     ///\name Two dimensional distributions
     941    ///\name Two Dimensional Distributions
    942942    ///
    943943    ///@{
  • lemon/suurballe.h

    r606 r631  
    289289    }
    290290
    291     /// \name Execution control
     291    /// \name Execution Control
    292292    /// The simplest way to execute the algorithm is to call the run()
    293293    /// function.
  • lemon/time_measure.h

    r595 r631  
    288288    Timer(bool run=true) :_running(run) {_reset();}
    289289
    290     ///\name Control the state of the timer
     290    ///\name Control the State of the Timer
    291291    ///Basically a Timer can be either running or stopped,
    292292    ///but it provides a bit finer control on the execution.
     
    396396    ///@}
    397397
    398     ///\name Query Functions for the ellapsed time
     398    ///\name Query Functions for the Ellapsed Time
    399399
    400400    ///@{
  • tools/dimacs-solver.cc

    r616 r631  
    2424///
    2525/// See
    26 /// \verbatim
    27 ///  dimacs-solver --help
    28 /// \endverbatim
     26/// \code
     27///   dimacs-solver --help
     28/// \endcode
    2929/// for more info on usage.
    30 ///
    3130
    3231#include <iostream>
  • tools/dimacs-to-lgf.cc

    r608 r631  
    2525///
    2626/// See
    27 /// \verbatim
    28 ///  dimacs-to-lgf --help
    29 /// \endverbatim
    30 /// for more info on usage.
    31 ///
     27/// \code
     28///   dimacs-to-lgf --help
     29/// \endcode
     30/// for more info on the usage.
    3231
    3332#include <iostream>
  • tools/lgf-gen.cc

    r617 r631  
    2424///
    2525/// See
    26 /// \verbatim
    27 ///  lgf-gen --help
    28 /// \endverbatim
     26/// \code
     27///   lgf-gen --help
     28/// \endcode
    2929/// for more info on the usage.
    30 ///
    31 
    3230
    3331#include <algorithm>
Note: See TracChangeset for help on using the changeset viewer.