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
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.