COIN-OR::LEMON - Graph Library

Ticket #119: 64f8f7cc6168.patch

File 64f8f7cc6168.patch, 15.2 KB (added by Peter Kovacs, 12 years ago)
  • demo/graph_to_eps_demo.cc

    # HG changeset patch
    # User Peter Kovacs <kpeter@inf.elte.hu>
    # Date 1223539784 -7200
    # Node ID 64f8f7cc6168b86c88ad05e447aecb9b1428c61e
    # Parent  e57e10a8ea1b3b89a3350af00e85ca51d7ad1dfc
    Fix several doxygen warnings
    
    diff --git a/demo/graph_to_eps_demo.cc b/demo/graph_to_eps_demo.cc
    a b  
    2626/// graphToEps(), and showing how to draw directed graphs,
    2727/// how to handle parallel egdes, how to change the properties (like
    2828/// color, shape, size, title etc.) of nodes and arcs individually
    29 /// using appropriate \ref maps-page "graph maps".
     29/// using appropriate graph maps.
    3030///
    3131/// \include graph_to_eps_demo.cc
    3232
  • doc/lgf.dox

    diff --git a/doc/lgf.dox b/doc/lgf.dox
    a b  
    7878 2   3   18
    7979\endcode
    8080
    81 The \c \@edges is just a synonym of \c \@arcs. The @arcs section can
     81The \c \@edges is just a synonym of \c \@arcs. The \@arcs section can
    8282also store the edge set of an undirected graph. In such case there is
    8383a conventional method for store arc maps in the file, if two columns
    8484has the same caption with \c '+' and \c '-' prefix, then these columns
  • lemon/bits/alteration_notifier.h

    diff --git a/lemon/bits/alteration_notifier.h b/lemon/bits/alteration_notifier.h
    a b  
    7979  /// observeres will not be notified and the fulfilled additions will
    8080  /// be rolled back by calling the \e erase() or \e clear()
    8181  /// functions. Thence the \e erase() and \e clear() should not throw
    82   /// exception. Actullay, it can be throw only
    83   /// \ref AlterationObserver::ImmediateDetach ImmediateDetach
     82  /// exception. Actullay, it can be throw only \ref ImmediateDetach
    8483  /// exception which detach the observer from the notifier.
    8584  ///
    8685  /// There are some place when the alteration observing is not completly
  • lemon/bits/default_map.h

    diff --git a/lemon/bits/default_map.h b/lemon/bits/default_map.h
    a b  
    149149
    150150// #endif
    151151
    152   /// \e
     152  /// DefaultMap class
    153153  template <typename _Graph, typename _Item, typename _Value>
    154154  class DefaultMap
    155155    : public DefaultMapSelector<_Graph, _Item, _Value>::Map {
  • lemon/color.h

    diff --git a/lemon/color.h b/lemon/color.h
    a b  
    9292  /// Dark cyan color constant
    9393  extern const Color DARK_CYAN;
    9494
    95   ///Map <tt>int</tt>s to different \ref Color "Color"s
     95  ///Map <tt>int</tt>s to different <tt>Color</tt>s
    9696
    9797  ///This map assigns one of the predefined \ref Color "Color"s to
    9898  ///each <tt>int</tt>. It is possible to change the colors as well as
  • lemon/concepts/graph_components.h

    diff --git a/lemon/concepts/graph_components.h b/lemon/concepts/graph_components.h
    a b  
    982982    /// \brief Class describing the concept of graph maps
    983983    ///
    984984    /// This class describes the common interface of the graph maps
    985     /// (NodeMap, ArcMap), that is \ref maps-page "maps" which can be used to
     985    /// (NodeMap, ArcMap), that is maps that can be used to
    986986    /// associate data to graph descriptors (nodes or arcs).
    987987    template <typename _Graph, typename _Item, typename _Value>
    988988    class GraphMap : public ReadWriteMap<_Item, _Value> {
  • lemon/core.h

    diff --git a/lemon/core.h b/lemon/core.h
    a b  
    15541554    ///\note This is a dynamic data structure, therefore the data
    15551555    ///structure is updated after each graph alteration. Thus although
    15561556    ///this data structure is theoretically faster than \ref ArcLookUp
    1557     ///and \ref AllArcLookup, it often provides worse performance than
     1557    ///and \ref AllArcLookUp, it often provides worse performance than
    15581558    ///them.
    15591559    Arc operator()(Node s, Node t, Arc p = INVALID) const  {
    15601560      if (p == INVALID) {
     
    16991699
    17001700    ///Find an arc between two nodes.
    17011701
    1702     ///Find an arc between two nodes in time <em>O</em>(log<em>d</em>), where
    1703     ///<em>d</em> is the number of outgoing arcs of \c s.
     1702    ///Find an arc between two nodes in time <em>O</em>(log<em>d</em>),
     1703    ///where <em>d</em> is the number of outgoing arcs of \c s.
    17041704    ///\param s The source node.
    17051705    ///\param t The target node.
    17061706    ///\return An arc from \c s to \c t if there exists,
     
    18171817    ///for(Arc a = ae(u,v); a != INVALID; a=ae(u,v,a)) n++;
    18181818    ///\endcode
    18191819    ///
    1820     ///Finding the first arc take <em>O</em>(log<em>d</em>) time, where
    1821     ///<em>d</em> is the number of outgoing arcs of \c s. Then, the
     1820    ///Finding the first arc take <em>O</em>(log<em>d</em>) time,
     1821    ///where <em>d</em> is the number of outgoing arcs of \c s. Then the
    18221822    ///consecutive arcs are found in constant time.
    18231823    ///
    18241824    ///\warning If you change the digraph, refresh() must be called before using
  • lemon/dfs.h

    diff --git a/lemon/dfs.h b/lemon/dfs.h
    a b  
    835835    typedef lemon::Path<Digraph> Path;
    836836  };
    837837
    838   /// Default traits class used by \ref DfsWizard
     838  /// Default traits class used by DfsWizard
    839839
    840840  /// To make it easier to use Dfs algorithm
    841841  /// we have created a wizard class.
  • lemon/dijkstra.h

    diff --git a/lemon/dijkstra.h b/lemon/dijkstra.h
    a b  
    453453    };
    454454
    455455    /// \brief \ref named-templ-param "Named parameter" for setting
    456     ///\ref OperationTraits type
     456    ///\c OperationTraits type
    457457    ///
    458458    ///\ref named-templ-param "Named parameter" for setting
    459459    ///\ref OperationTraits type.
     
    10381038    typedef lemon::Path<Digraph> Path;
    10391039  };
    10401040
    1041   /// Default traits class used by \ref DijkstraWizard
     1041  /// Default traits class used by DijkstraWizard
    10421042
    10431043  /// To make it easier to use Dijkstra algorithm
    10441044  /// we have created a wizard class.
  • lemon/dim2.h

    diff --git a/lemon/dim2.h b/lemon/dim2.h
    a b  
    259259
    260260
    261261
    262   /// Bounding box of plain vectors (\ref Point points).
     262  /// Bounding box of plain vectors (points).
    263263
    264264  /// A class to calculate or store the bounding box of plain vectors
    265   /// (\ref Point points).
     265  /// (\ref Point "points").
    266266  template<typename T>
    267267  class Box {
    268268      Point<T> _bottom_left, _top_right;
     
    573573    return os;
    574574  }
    575575
    576   ///Map of x-coordinates of a \ref Point "Point"-map
     576  ///Map of x-coordinates of a <tt>Point</tt>-map
    577577
     578  ///Map of x-coordinates of a \ref Point "Point"-map.
    578579  ///\ingroup maps
    579   ///Map of x-coordinates of a \ref Point "Point"-map.
    580   ///
    581580  template<class M>
    582581  class XMap
    583582  {
     
    592591    void set(Key k,Value v) {_map.set(k,typename M::Value(v,_map[k].y));}
    593592  };
    594593
    595   ///Returns an \ref XMap class
     594  ///Returns an XMap class
    596595
    597   ///This function just returns an \ref XMap class.
     596  ///This function just returns an XMap class.
    598597  ///
    599598  ///\ingroup maps
    600599  ///\relates XMap
     
    610609    return XMap<M>(m);
    611610  }
    612611
    613   ///Constant (read only) version of \ref XMap
     612  ///Constant (read only) version of XMap
    614613
     614  ///Constant (read only) version of XMap.
    615615  ///\ingroup maps
    616   ///Constant (read only) version of \ref XMap
    617   ///
    618616  template<class M>
    619617  class ConstXMap
    620618  {
     
    628626    Value operator[](Key k) const {return _map[k].x;}
    629627  };
    630628
    631   ///Returns a \ref ConstXMap class
     629  ///Returns a ConstXMap class
    632630
    633   ///This function just returns a \ref ConstXMap class.
     631  ///This function just returns a ConstXMap class.
    634632  ///
    635633  ///\ingroup maps
    636634  ///\relates ConstXMap
     
    640638    return ConstXMap<M>(m);
    641639  }
    642640
    643   ///Map of y-coordinates of a \ref Point "Point"-map
     641  ///Map of y-coordinates of a <tt>Point</tt>-map
    644642
     643  ///Map of y-coordinates of a \ref Point "Point"-map.
    645644  ///\ingroup maps
    646   ///Map of y-coordinates of a \ref Point "Point"-map.
    647   ///
    648645  template<class M>
    649646  class YMap
    650647  {
     
    659656    void set(Key k,Value v) {_map.set(k,typename M::Value(_map[k].x,v));}
    660657  };
    661658
    662   ///Returns a \ref YMap class
     659  ///Returns a YMap class
    663660
    664   ///This function just returns a \ref YMap class.
     661  ///This function just returns a YMap class.
    665662  ///
    666663  ///\ingroup maps
    667664  ///\relates YMap
     
    677674    return YMap<M>(m);
    678675  }
    679676
    680   ///Constant (read only) version of \ref YMap
     677  ///Constant (read only) version of YMap
    681678
     679  ///Constant (read only) version of YMap.
    682680  ///\ingroup maps
    683   ///Constant (read only) version of \ref YMap
    684   ///
    685681  template<class M>
    686682  class ConstYMap
    687683  {
     
    695691    Value operator[](Key k) const {return _map[k].y;}
    696692  };
    697693
    698   ///Returns a \ref ConstYMap class
     694  ///Returns a ConstYMap class
    699695
    700   ///This function just returns a \ref ConstYMap class.
     696  ///This function just returns a ConstYMap class.
    701697  ///
    702698  ///\ingroup maps
    703699  ///\relates ConstYMap
     
    708704  }
    709705
    710706
    711   ///\brief Map of the \ref Point::normSquare() "normSquare()"
    712   ///of a \ref Point "Point"-map
     707  ///\brief Map of the normSquare() of a <tt>Point</tt>-map
    713708  ///
    714709  ///Map of the \ref Point::normSquare() "normSquare()"
    715710  ///of a \ref Point "Point"-map.
     
    727722    Value operator[](Key k) const {return _map[k].normSquare();}
    728723  };
    729724
    730   ///Returns a \ref NormSquareMap class
     725  ///Returns a NormSquareMap class
    731726
    732   ///This function just returns a \ref NormSquareMap class.
     727  ///This function just returns a NormSquareMap class.
    733728  ///
    734729  ///\ingroup maps
    735730  ///\relates NormSquareMap
  • lemon/graph_to_eps.h

    diff --git a/lemon/graph_to_eps.h b/lemon/graph_to_eps.h
    a b  
    6262    };
    6363  }
    6464
    65 ///Default traits class of \ref GraphToEps
     65///Default traits class of GraphToEps
    6666
    6767///Default traits class of \ref GraphToEps.
    6868///
  • lemon/list_graph.h

    diff --git a/lemon/list_graph.h b/lemon/list_graph.h
    a b  
    413413    /// Change the source of \c a to \c n
    414414    ///
    415415    ///\note The <tt>InArcIt</tt>s referencing the changed arc remain
    416     ///valid. However the <tt>ArcIt<tt>s and <tt>OutArcIt</tt>s are
     416    ///valid. However the <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s are
    417417    ///invalidated.
    418418    ///
    419419    ///\warning This functionality cannot be used together with the Snapshot
  • lemon/maps.h

    diff --git a/lemon/maps.h b/lemon/maps.h
    a b  
    4343  template<typename K, typename V>
    4444  class MapBase {
    4545  public:
    46     /// \biref The key type of the map.
     46    /// \brief The key type of the map.
    4747    typedef K Key;
    4848    /// \brief The value type of the map.
    4949    /// (The type of objects associated with the keys).
     
    22662266    /// \brief Constructor
    22672267    ///
    22682268    /// Constructor
    2269     /// \param _digraph The digraph that the map belongs to.
     2269    /// \param digraph The digraph that the map belongs to.
    22702270    explicit SourceMap(const Digraph& digraph) : _digraph(digraph) {}
    22712271
    22722272    /// \brief The subscript operator.
     
    23052305    /// \brief Constructor
    23062306    ///
    23072307    /// Constructor
    2308     /// \param _digraph The digraph that the map belongs to.
     2308    /// \param digraph The digraph that the map belongs to.
    23092309    explicit TargetMap(const Digraph& digraph) : _digraph(digraph) {}
    23102310
    23112311    /// \brief The subscript operator.
     
    23442344    /// \brief Constructor
    23452345    ///
    23462346    /// Constructor
    2347     /// \param _graph The graph that the map belongs to.
     2347    /// \param graph The graph that the map belongs to.
    23482348    explicit ForwardMap(const Graph& graph) : _graph(graph) {}
    23492349
    23502350    /// \brief The subscript operator.
     
    23832383    /// \brief Constructor
    23842384    ///
    23852385    /// Constructor
    2386     /// \param _graph The graph that the map belongs to.
     2386    /// \param graph The graph that the map belongs to.
    23872387    explicit BackwardMap(const Graph& graph) : _graph(graph) {}
    23882388
    23892389    /// \brief The subscript operator.
  • lemon/path.h

    diff --git a/lemon/path.h b/lemon/path.h
    a b  
    849849    /// \brief Return true when the path is empty.
    850850    int empty() const { return len == 0; }
    851851
    852     /// \break Erase all arcs in the digraph.
     852    /// \brief Erase all arcs in the digraph.
    853853    void clear() {
    854854      len = 0;
    855855      if (arcs) delete[] arcs;
  • lemon/smart_graph.h

    diff --git a/lemon/smart_graph.h b/lemon/smart_graph.h
    a b  
    365365      ///Constructor that immediately makes a snapshot
    366366
    367367      ///This constructor immediately makes a snapshot of the digraph.
    368       ///\param _g The digraph we make a snapshot of.
     368      ///\param graph The digraph we make a snapshot of.
    369369      Snapshot(SmartDigraph &graph) : _graph(&graph) {
    370370        node_num=_graph->nodes.size();
    371371        arc_num=_graph->arcs.size();
     
    377377      ///
    378378      ///This function can be called more than once. In case of a repeated
    379379      ///call, the previous snapshot gets lost.
    380       ///\param _g The digraph we make the snapshot of.
     380      ///\param graph The digraph we make the snapshot of.
    381381      void save(SmartDigraph &graph)
    382382      {
    383383        _graph=&graph;
     
    775775      ///Constructor that immediately makes a snapshot
    776776
    777777      ///This constructor immediately makes a snapshot of the digraph.
    778       ///\param g The digraph we make a snapshot of.
     778      ///\param graph The digraph we make a snapshot of.
    779779      Snapshot(SmartGraph &graph) {
    780780        graph.saveSnapshot(*this);
    781781      }
     
    786786      ///
    787787      ///This function can be called more than once. In case of a repeated
    788788      ///call, the previous snapshot gets lost.
    789       ///\param g The digraph we make the snapshot of.
     789      ///\param graph The digraph we make the snapshot of.
    790790      void save(SmartGraph &graph)
    791791      {
    792792        graph.saveSnapshot(*this);
  • lemon/time_measure.h

    diff --git a/lemon/time_measure.h b/lemon/time_measure.h
    a b  
    311311    ///\name Control the state of the timer
    312312    ///Basically a Timer can be either running or stopped,
    313313    ///but it provides a bit finer control on the execution.
    314     ///The \ref Timer also counts the number of \ref start()
    315     ///executions, and is stops only after the same amount (or more)
    316     ///\ref stop() "stop()"s. This can be useful e.g. to compute
    317     ///the running time
     314    ///The \ref lemon::Timer "Timer" also counts the number of
     315    ///\ref lemon::Timer::start() "start()" executions, and it stops
     316    ///only after the same amount (or more) \ref lemon::Timer::stop()
     317    ///"stop()"s. This can be useful e.g. to compute the running time
    318318    ///of recursive functions.
    319     ///
    320319
    321320    ///@{
    322321
     
    472471    ///@}
    473472  };
    474473
    475   ///Same as \ref Timer but prints a report on destruction.
     474  ///Same as Timer but prints a report on destruction.
    476475
    477476  ///Same as \ref Timer but prints a report on destruction.
    478477  ///This example shows its usage.
     
    491490    std::string _title;
    492491    std::ostream &_os;
    493492  public:
    494     ///\e
     493    ///Constructor
    495494
     495    ///Constructor.
    496496    ///\param title This text will be printed before the ellapsed time.
    497497    ///\param os The stream to print the report to.
    498498    ///\param run Sets whether the timer should start immediately.
    499 
    500499    TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true)
    501500      : Timer(run), _title(title), _os(os){}
    502     ///\e Prints the ellapsed time on destruction.
     501    ///Destructor that prints the ellapsed time
    503502    ~TimeReport()
    504503    {
    505504      _os << _title << *this << std::endl;
    506505    }
    507506  };
    508507
    509   ///'Do nothing' version of \ref TimeReport
     508  ///'Do nothing' version of TimeReport
    510509
    511510  ///\sa TimeReport
    512511  ///