COIN-OR::LEMON - Graph Library

Ticket #149: e7f8647ce760.patch

File e7f8647ce760.patch, 12.3 KB (added by Alpar Juttner, 12 years ago)
  • lemon/bfs.h

    # HG changeset patch
    # User Alpar Juttner <alpar@cs.elte.hu>
    # Date 1216045391 -3600
    # Node ID e7f8647ce76038dda8a0dc30daae11ecd11ad81b
    # Parent  7abfb55f1ecc813ea33ff03ec3f5e909d1e738b2
    Remove todo-s and convert them to trac tickets
    
    diff --git a/lemon/bfs.h b/lemon/bfs.h
    a b  
    5353    ///This function instantiates a \ref PredMap.
    5454    ///\param g is the digraph, to which we would like to define the
    5555    ///\ref PredMap.
    56     ///\todo The digraph alone may be insufficient to initialize
    5756    static PredMap *createPredMap(const Digraph &g)
    5857    {
    5958      return new PredMap(g);
     
    6362
    6463    ///The type of the map that indicates which nodes are processed.
    6564    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    66     ///By default it is a NullMap.
    6765    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    6866    ///Instantiates a \ref ProcessedMap.
    6967
     
    195193    int _queue_head,_queue_tail,_queue_next_dist;
    196194    int _curr_dist;
    197195
    198     ///Creates the maps if necessary.
    199     ///\todo Better memory allocation (instead of new).
     196    //Creates the maps if necessary.
    200197    void create_maps()
    201198    {
    202199      if(!_pred) {
     
    847844    ///This function instantiates a \ref PredMap.
    848845    ///\param g is the digraph, to which we would like to define the
    849846    ///\ref PredMap.
    850     ///\todo The digraph alone may be insufficient to initialize
    851847#ifdef DOXYGEN
    852848    static PredMap *createPredMap(const Digraph &g)
    853849#else
     
    13321328    std::vector<typename Digraph::Node> _list;
    13331329    int _list_front, _list_back;
    13341330
    1335     ///Creates the maps if necessary.
    1336     ///\todo Better memory allocation (instead of new).
     1331    //Creates the maps if necessary.
    13371332    void create_maps() {
    13381333      if(!_reached) {
    13391334        local_reached = true;
  • lemon/bits/base_extender.h

    diff --git a/lemon/bits/base_extender.h b/lemon/bits/base_extender.h
    a b  
    105105
    106106    /// Returns whether the given directed arc has the same orientation
    107107    /// as the corresponding edge.
    108     ///
    109     /// \todo reference to the corresponding point of the undirected digraph
    110     /// concept. "What does the direction of an edge mean?"
    111108    static bool direction(const Arc &a) { return a.forward; }
    112109
    113110    using Parent::first;
  • lemon/bits/vector_map.h

    diff --git a/lemon/bits/vector_map.h b/lemon/bits/vector_map.h
    a b  
    4242  /// automatically updates the map when a key is added to or erased from
    4343  /// the map. This map type uses the std::vector to store the values.
    4444  ///
    45   /// \tparam _Notifier The AlterationNotifier that will notify this map.
     45  /// \tparam _Graph The graph this map is attached to.
    4646  /// \tparam _Item The item type of the graph items.
    4747  /// \tparam _Value The value type of the map.
    48   /// \todo Fix the doc: there is _Graph parameter instead of _Notifier.
    4948  template <typename _Graph, typename _Item, typename _Value>
    5049  class VectorMap
    5150    : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {
  • lemon/concept_check.h

    diff --git a/lemon/concept_check.h b/lemon/concept_check.h
    a b  
    3636///\file
    3737///\brief Basic utilities for concept checking.
    3838///
    39 ///\todo Are we still using BOOST concept checking utility?
    40 ///Is the BOOST copyright notice necessary?
    4139
    4240#ifndef LEMON_CONCEPT_CHECK_H
    4341#define LEMON_CONCEPT_CHECK_H
  • lemon/concepts/path.h

    diff --git a/lemon/concepts/path.h b/lemon/concepts/path.h
    a b  
    2020///\file
    2121///\brief Classes for representing paths in digraphs.
    2222///
    23 ///\todo Iterators have obsolete style
    2423
    2524#ifndef LEMON_CONCEPT_PATH_H
    2625#define LEMON_CONCEPT_PATH_H
  • lemon/dfs.h

    diff --git a/lemon/dfs.h b/lemon/dfs.h
    a b  
    5454    ///This function instantiates a \ref PredMap.
    5555    ///\param g is the digraph, to which we would like to define the
    5656    ///\ref PredMap.
    57     ///\todo The digraph alone may be insufficient to initialize
    5857    static PredMap *createPredMap(const Digraph &g)
    5958    {
    6059      return new PredMap(g);
     
    6463
    6564    ///The type of the map that indicates which nodes are processed.
    6665    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    67     ///By default it is a NullMap.
    6866    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    6967    ///Instantiates a \ref ProcessedMap.
    7068
     
    195193    std::vector<typename Digraph::OutArcIt> _stack;
    196194    int _stack_head;
    197195
    198     ///Creates the maps if necessary.
    199     ///\todo Better memory allocation (instead of new).
     196    //Creates the maps if necessary.
    200197    void create_maps()
    201198    {
    202199      if(!_pred) {
     
    782779    ///This function instantiates a \ref PredMap.
    783780    ///\param g is the digraph, to which we would like to define the
    784781    ///\ref PredMap.
    785     ///\todo The digraph alone may be insufficient to initialize
    786782#ifdef DOXYGEN
    787783    static PredMap *createPredMap(const Digraph &g)
    788784#else
     
    12791275    std::vector<typename Digraph::Arc> _stack;
    12801276    int _stack_head;
    12811277
    1282     ///Creates the maps if necessary.
    1283     ///\todo Better memory allocation (instead of new).
     1278    //Creates the maps if necessary.
    12841279    void create_maps() {
    12851280      if(!_reached) {
    12861281        local_reached = true;
  • lemon/dijkstra.h

    diff --git a/lemon/dijkstra.h b/lemon/dijkstra.h
    a b  
    143143    ///This function instantiates a \ref PredMap.
    144144    ///\param g is the digraph, to which we would like to define the
    145145    ///\ref PredMap.
    146     ///\todo The digraph alone may be insufficient for the initialization
    147146    static PredMap *createPredMap(const Digraph &g)
    148147    {
    149148      return new PredMap(g);
     
    154153    ///The type of the map that indicates which nodes are processed.
    155154    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    156155    ///By default it is a NullMap.
    157     ///\todo If it is set to a real map,
    158     ///Dijkstra::processed() should read this.
    159156    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    160157    ///Instantiates a \ref ProcessedMap.
    161158
     
    296293    //Indicates if _heap is locally allocated (true) or not.
    297294    bool local_heap;
    298295
    299     ///Creates the maps if necessary.
    300     ///\todo Better memory allocation (instead of new).
     296    //Creates the maps if necessary.
    301297    void create_maps()
    302298    {
    303299      if(!_pred) {
     
    957953    ///This function instantiates a \ref HeapCrossRef.
    958954    /// \param g is the digraph, to which we would like to define the
    959955    /// HeapCrossRef.
    960     /// \todo The digraph alone may be insufficient for the initialization
    961956    static HeapCrossRef *createHeapCrossRef(const Digraph &g)
    962957    {
    963958      return new HeapCrossRef(g);
     
    993988    ///This function instantiates a \ref PredMap.
    994989    ///\param g is the digraph, to which we would like to define the
    995990    ///\ref PredMap.
    996     ///\todo The digraph alone may be insufficient to initialize
    997991#ifdef DOXYGEN
    998992    static PredMap *createPredMap(const Digraph &g)
    999993#else
     
    10081002    ///The type of the map that indicates which nodes are processed.
    10091003    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    10101004    ///By default it is a NullMap.
    1011     ///\todo If it is set to a real map,
    1012     ///Dijkstra::processed() should read this.
    1013     ///\todo named parameter to set this type, function to read and write.
    10141005    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    10151006    ///Instantiates a \ref ProcessedMap.
    10161007
     
    10541045  /// as well as the \ref Dijkstra class.
    10551046  /// The \ref DijkstraWizardBase is a class to be the default traits of the
    10561047  /// \ref DijkstraWizard class.
    1057   /// \todo More named parameters are required...
    10581048  template<class GR,class LM>
    10591049  class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LM>
    10601050  {
  • lemon/error.h

    diff --git a/lemon/error.h b/lemon/error.h
    a b  
    102102  protected:
    103103    ///\e
    104104
    105     ///\todo The good solution is boost::shared_ptr...
    106     ///
    107105    mutable std::auto_ptr<std::ostringstream> buf;
    108106
    109107    ///\e
  • lemon/graph_to_eps.h

    diff --git a/lemon/graph_to_eps.h b/lemon/graph_to_eps.h
    a b  
    666666  ///this function calls the algorithm itself, i.e. in this case
    667667  ///it draws the graph.
    668668  void run() {
    669     //\todo better 'epsilon' would be nice here.
    670669    const double EPSILON=1e-9;
    671670    if(dontPrint) return;
    672671
     
    707706      double max_w=0;
    708707      for(ArcIt e(g);e!=INVALID;++e)
    709708        max_w=std::max(double(_arcWidths[e]),max_w);
    710       //\todo better 'epsilon' would be nice here.
    711709      if(max_w>EPSILON) {
    712710        _arcWidthScale/=max_w;
    713711      }
     
    717715      double max_s=0;
    718716      for(NodeIt n(g);n!=INVALID;++n)
    719717        max_s=std::max(double(_nodeSizes[n]),max_s);
    720       //\todo better 'epsilon' would be nice here.
    721718      if(max_s>EPSILON) {
    722719        _nodeScale/=max_s;
    723720      }
     
    873870           << -bb.left() << ' ' << -bb.bottom() << " translate\n";
    874871      }
    875872      else {
    876         //\todo Verify centering
    877873        double sc= std::min((A4HEIGHT-2*A4BORDER)/bb.width(),
    878874                  (A4WIDTH-2*A4BORDER)/bb.height());
    879875        os << ((A4WIDTH -2*A4BORDER)-sc*bb.height())/2 + A4BORDER << ' '
     
    906902          dim2::Point<double>
    907903            dvec(mycoords[g.target(*i)]-mycoords[g.source(*i)]);
    908904          double l=std::sqrt(dvec.normSquare());
    909           //\todo better 'epsilon' would be nice here.
    910905          dim2::Point<double> d(dvec/std::max(l,EPSILON));
    911906          dim2::Point<double> m;
    912907//           m=dim2::Point<double>(mycoords[g.target(*i)]+
  • lemon/list_graph.h

    diff --git a/lemon/list_graph.h b/lemon/list_graph.h
    a b  
    501501    ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s may
    502502    ///be invalidated.
    503503    ///
    504     ///\warning This functionality cannot be used together with the
     504    ///\warning This functionality cannot be used in conjunction with the
    505505    ///Snapshot feature.
    506     ///
    507     ///\todo It could be implemented in a bit faster way.
    508506    Node split(Node n, bool connect = true) {
    509507      Node b = addNode();
    510508      for(OutArcIt e(*this,n);e!=INVALID;) {
  • lemon/maps.h

    diff --git a/lemon/maps.h b/lemon/maps.h
    a b  
    484484  /// function.
    485485  ///
    486486  /// \sa CombineMap
    487   ///
    488   /// \todo Check the requirements.
    489487  template <typename M1, typename M2>
    490488  class ComposeMap : public MapBase<typename M2::Key, typename M1::Value> {
    491489    const M1 &_m1;
     
    540538  /// function.
    541539  ///
    542540  /// \sa ComposeMap
    543   ///
    544   /// \todo Check the requirements.
    545541  template<typename M1, typename M2, typename F,
    546542           typename V = typename F::result_type>
    547543  class CombineMap : public MapBase<typename M1::Key, V> {
  • lemon/random.h

    diff --git a/lemon/random.h b/lemon/random.h
    a b  
    821821    /// Standard Gauss distribution.
    822822    /// \note The Cartesian form of the Box-Muller
    823823    /// transformation is used to generate a random normal distribution.
    824     /// \todo Consider using the "ziggurat" method instead.
    825824    double gauss()
    826825    {
    827826      double V1,V2,S;
  • lemon/smart_graph.h

    diff --git a/lemon/smart_graph.h b/lemon/smart_graph.h
    a b  
    300300    ///may be invalidated.
    301301    ///\warning This functionality cannot be used together with the Snapshot
    302302    ///feature.
    303     ///\todo It could be implemented in a bit faster way.
    304303    Node split(Node n, bool connect = true)
    305304    {
    306305      Node b = addNode();
  • lemon/time_measure.h

    diff --git a/lemon/time_measure.h b/lemon/time_measure.h
    a b  
    292292  ///\note If you want to measure the running time of the execution of a certain
    293293  ///function, consider the usage of \ref TimeReport instead.
    294294  ///
    295   ///\todo This shouldn't be Unix (Linux) specific.
    296295  ///\sa TimeReport
    297296  class Timer
    298297  {
     
    487486  ///
    488487  ///\sa Timer
    489488  ///\sa NoTimeReport
    490   ///\todo There is no test case for this
    491489  class TimeReport : public Timer
    492490  {
    493491    std::string _title;
  • lemon/tolerance.h

    diff --git a/lemon/tolerance.h b/lemon/tolerance.h
    a b  
    2424///\brief A basic tool to handle the anomalies of calculation with
    2525///floating point numbers.
    2626///
    27 ///\todo It should be in a module like "Basic tools"
    28 
    2927
    3028namespace lemon {
    3129