COIN-OR::LEMON - Graph Library

Changeset 242:b255f25ad394 in lemon-0.x for src


Ignore:
Timestamp:
03/24/04 14:06:06 (16 years ago)
Author:
Alpar Juttner
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@341
Message:

DocFixes?

Location:
src/work
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • src/work/alpar/dijkstra/bin_heap.hh

    r224 r242  
    5959#ifndef BIN_HEAP_HH
    6060#define BIN_HEAP_HH
     61
     62///\file
     63///\brief Binary Heap implementation.
    6164
    6265#include <vector>
  • src/work/alpar/dijkstra/dijkstra.h

    r229 r242  
    11// -*- C++ -*-
     2
    23/*
    34 *template <Graph, T, Heap=FibHeap, LengthMap=Graph::EdgeMap<T> >
     
    2627#ifndef HUGO_DIJKSTRA_H
    2728#define HUGO_DIJKSTRA_H
     29
     30///\file
     31///\brief Dijkstra algorithm.
    2832
    2933#include <fib_heap.h>
     
    4448  ///The type of the length is determined by the \c ValueType of the length map.
    4549  ///
    46   ///It is also posible to change the underlying priority heap.
     50  ///It is also possible to change the underlying priority heap.
    4751  ///
    4852  ///\param Graph The graph type the algorithm runs on.
    49   ///\param LengthMap This read-only EdgeMap determines the
     53  ///\param LengthMap This read-only
     54  ///EdgeMap
     55  ///determines the
    5056  ///lengths of the edges. It is read once for each edge, so the map
    5157  ///may involve in relatively time consuming process to compute the edge
    52   ///length if it is necessary.
     58  ///length if it is necessary. The default map type is
     59  ///\ref GraphSkeleton::EdgeMap "Graph::EdgeMap<int>"
    5360  ///\param Heap The heap type used by the %Dijkstra
    5461  ///algorithm. The default
    5562  ///is using \ref BinHeap "binary heap".
     63 
     64#ifdef DOXYGEN
     65  template <typename Graph,
     66            typename LengthMap,
     67            typename Heap>
     68#else
    5669  template <typename Graph,
    5770            typename LengthMap=typename Graph::EdgeMap<int>,
     
    5972                                   typename LengthMap::ValueType,
    6073                                   typename Graph::NodeMap<int> > >
     74#endif
    6175  class Dijkstra{
    6276  public:
     
    136150    //    bool reached(Node v) { return reach[v]; }
    137151
    138     ///Chechs if a node is reachable from the source.
     152    ///Checks if a node is reachable from the source.
    139153
    140154    ///Returns \c true if \c v is reachable from the source.
  • src/work/alpar/dijkstra/fib_heap.h

    r224 r242  
    5252#define FIB_HEAP_H
    5353
     54///\file
     55///\brief Fibonacci Heap implementation.
     56
    5457#include <vector>
    5558#include <functional>
     
    7477
    7578    ///\todo It is use nowhere
    76     ///\todo It doesn't conforms to the naming conventions.
     79    ///\todo It doesn't conform to the naming conventions.
    7780  public:
    7881    enum state_enum {
  • src/work/alpar/emptygraph.h

    r216 r242  
    33#define HUGO_EMPTYGRAPH_H
    44
     5///\file
     6///\brief Declaration of GraphSkeleton.
     7
    58#include <invalid.h>
    69
     
    1316  /// An empty graph class.
    1417 
    15   /// When you read this for the first time,
    16   /// please send an e-mail to alpar\@cs.elte.hu.
    17   ///
    1818  /// This class provides all the common features of a graph structure,
    1919  /// however completely without implementations and real data structures
     
    103103    };
    104104   
    105     /// This iterator goes trought the outgoing edges of a node.
    106 
    107     /// This iterator goes trought the \e outgoing edges of a certain node
     105    /// This iterator goes trough the outgoing edges of a node.
     106
     107    /// This iterator goes trough the \e outgoing edges of a certain node
    108108    /// of a graph.
    109109    /// Its usage is quite simple, for example you can count the number
     
    131131    };
    132132
    133     /// This iterator goes trought the incoming edges of a node.
    134 
    135     /// This iterator goes trought the \e incoming edges of a certain node
     133    /// This iterator goes trough the incoming edges of a node.
     134
     135    /// This iterator goes trough the \e incoming edges of a certain node
    136136    /// of a graph.
    137137    /// Its usage is quite simple, for example you can count the number
     
    179179    NodeIt &first(NodeIt &i) const { return i;}
    180180
     181    /// The first incoming edge.
     182    InEdgeIt &first(InEdgeIt &i, Node n) const { return i;}
    181183    /// The first outgoing edge.
    182     InEdgeIt &first(InEdgeIt &i, Node n) const { return i;}
    183     /// The first incoming edge.
    184184    OutEdgeIt &first(OutEdgeIt &i, Node n) const { return i;}
    185185    //  SymEdgeIt &first(SymEdgeIt &, Node) const { return i;}
     
    229229    ///Gives back the \e id of a node.
    230230
    231     ///\warning Not all graph structure provide this feature.
     231    ///\warning Not all graph structures provide this feature.
    232232    ///
    233233    int id(const Node) const { return 0;}
    234234    ///Gives back the \e id of an edge.
    235235
    236     ///\warning Not all graph structure provide this feature.
     236    ///\warning Not all graph structures provide this feature.
    237237    ///
    238238    int id(const Edge) const { return 0;}
     
    253253    Edge addEdge(Node tail, Node head) { return INVALID;}
    254254   
    255     /// Deletes a node.
    256    
    257     ///\warning Not all graph structure provide this feature.
    258     ///
    259     void erase(Node n) {}
    260     /// Deletes an edge.
    261 
    262     ///\warning Not all graph structure provide this feature.
    263     ///
    264     void erase(Edge e) {}
    265 
    266     /// Reset the graph.
     255    /// Resets the graph.
    267256
    268257    /// This function deletes all edges and nodes of the graph.
     
    272261    int nodeNum() const { return 0;}
    273262    int edgeNum() const { return 0;}
    274 
     263 
     264    /// Defalult constructor.
    275265    GraphSkeleton() {}
     266    ///Copy consructor.
    276267    GraphSkeleton(const GraphSkeleton &G) {}
    277268 
    278   
     269 
    279270
    280271    ///Read/write/reference map of the nodes to type \c T.
     
    344335  };
    345336
     337  /// An empty eraseable graph class.
     338 
     339  /// This class provides all the common features of an \e eraseable graph
     340  /// structure,
     341  /// however completely without implementations and real data structures
     342  /// behind the interface.
     343  /// All graph algorithms should compile with this class, but it will not
     344  /// run properly, of course.
     345  ///
     346  /// \todo This blabla could be replaced by a sepatate description about
     347  /// Skeletons.
     348  ///
     349  /// It can be used for checking the interface compatibility,
     350  /// or it can serve as a skeleton of a new graph structure.
     351  ///
     352  /// Also, you will find here the full documentation of a certain graph
     353  /// feature, the documentation of a real graph imlementation
     354  /// like @ref ListGraph or
     355  /// @ref SmartGraph will just refer to this structure.
     356  class EraseableGraphSkeleton : public GraphSkeleton
     357  {
     358  public:
     359    /// Deletes a node.
     360    void erase(Node n) {}
     361    /// Deletes an edge.
     362    void erase(Edge e) {}
     363
     364    /// Defalult constructor.
     365    GraphSkeleton() {}
     366    ///Copy consructor.
     367    GraphSkeleton(const GraphSkeleton &G) {}
     368  };
     369
     370 
    346371  // @}
    347372
  • src/work/alpar/invalid.h

    r184 r242  
    33#ifndef HUGO_INVALID_H
    44#define HUGO_INVALID_H
     5
     6///\file
     7///\brief Definition of INVALID.
    58
    69namespace hugo {
  • src/work/alpar/mapskeleton.h

    r209 r242  
    22#ifndef HUGO_MAPSKELETON_H
    33#define HUGO_MAPSKELETON_H
     4
     5///\file
     6///\brief Map concepts checking classes for testing and documenting.
    47
    58namespace hugo {
  • src/work/alpar/smart_graph.h

    r215 r242  
    44#define HUGO_SMART_GRAPH_H
    55
     6///\file
     7///\brief SmartGraph and SymSmartGraph classes.
     8
    69#include <vector>
    710#include <limits.h>
     
    1518  ///A smart graph class.
    1619
    17   /// When you read this for the first time,
    18   /// please send an e-mail to alpar\@cs.elte.hu.
    19   ///
    2020  ///This is a simple and fast graph implementation.
    2121  ///It is also quite memory efficient, but at the price
    2222  ///that <b> it does not support node and edge deletion</b>.
    23   ///Apart from this it conforms to the graph interface documented under
     23  ///It conforms to the graph interface documented under
    2424  ///the description of \ref GraphSkeleton.
    2525  ///\sa \ref GraphSkeleton.
  • src/work/athos/xy/boundingbox.h

    r240 r242  
    11// -*- c++ -*-
    2 /**
    3 Implementation of a bounding box of plainvectors.
    4 
    5 */
    62#ifndef HUGO_BOUNDINGBOX_H
    73#define HUGO_BOUNDINGBOX_H
     
    128namespace hugo {
    139
     10  /** \brief
     11     Implementation of a bounding box of plainvectors.
     12     
     13  */
    1414  template<typename T>
    1515    class BoundingBox {
  • src/work/athos/xy/xy.h

    r240 r242  
    11// -*- c++ -*-
    2 /**
    3 2 dimensional vector (plainvector) implementation
    4 
    5 */
    62#ifndef HUGO_XY_H
    73#define HUGO_XY_H
     
    117namespace hugo {
    128
     9/** \brief
     102 dimensional vector (plainvector) implementation
     11
     12*/
    1313  template<typename T>
    1414    class xy {
Note: See TracChangeset for help on using the changeset viewer.