COIN-OR::LEMON - Graph Library

Changeset 2618:6aa6fcaeaea5 in lemon-0.x


Ignore:
Timestamp:
09/19/08 17:14:41 (11 years ago)
Author:
Balazs Dezso
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3503
Message:

G++-4.3 compatibility changes

Files:
14 edited

Legend:

Unmodified
Added
Removed
  • lemon/bits/bezier.h

    r2553 r2618  
    3535class BezierBase {
    3636public:
    37   typedef Point<double> Point;
     37  typedef lemon::dim2::Point<double> Point;
    3838protected:
    3939  static Point conv(Point x,Point y,double t) {return (1-t)*x+t*y;}
  • lemon/bits/traits.h

    r2553 r2618  
    225225    typedef typename Map::Value Value;
    226226
    227     typedef const Value ConstReturnValue;
    228     typedef const Value ReturnValue;
     227    typedef Value ConstReturnValue;
     228    typedef Value ReturnValue;
    229229  };
    230230
     
    253253    typedef typename MatrixMap::Value Value;
    254254
    255     typedef const Value ConstReturnValue;
    256     typedef const Value ReturnValue;
     255    typedef Value ConstReturnValue;
     256    typedef Value ReturnValue;
    257257  };
    258258
  • lemon/circulation.h

    r2553 r2618  
    8989    /// \sa Elevator
    9090    /// \sa LinkedElevator
    91     typedef Elevator<Graph, typename Graph::Node> Elevator;
     91    typedef lemon::Elevator<Graph, typename Graph::Node> Elevator;
    9292   
    9393    /// \brief Instantiates an Elevator.
     
    103103    ///
    104104    /// The tolerance used by the algorithm to handle inexact computation.
    105     typedef Tolerance<Value> Tolerance;
     105    typedef lemon::Tolerance<Value> Tolerance;
    106106
    107107  };
  • lemon/dijkstra.h

    r2553 r2618  
    3131#include <lemon/error.h>
    3232#include <lemon/maps.h>
     33
     34#include <limits>
    3335
    3436
  • lemon/edge_set.h

    r2553 r2618  
    155155      Node node;
    156156      for (first(node); node != INVALID && (*nodes)[node].first_in == -1;
    157            next(node));
     157           next(node)) { }
    158158      edge.id = (node == INVALID) ? -1 : (*nodes)[node].first_in;
    159159    }
     
    165165        Node node = edges[edge.id].target;
    166166        for (next(node); node != INVALID && (*nodes)[node].first_in == -1;
    167              next(node));
     167             next(node)) { }
    168168        edge.id = (node == INVALID) ? -1 : (*nodes)[node].first_in;
    169169      }     
  • lemon/graph_to_eps.h

    r2569 r2618  
    10021002      else for(EdgeIt e(g);e!=INVALID;++e)
    10031003        if((!_undirected||g.source(e)<g.target(e))&&_edgeWidths[e]>0
    1004            &&g.source(e)!=g.target(e))
     1004           &&g.source(e)!=g.target(e)) {
    10051005          if(_drawArrows) {
    10061006            dim2::Point<double> d(mycoords[g.target(e)]-mycoords[g.source(e)]);
     
    10311031                  << _edgeColors[e].blue() << ' '
    10321032                  << _edgeWidths[e]*_edgeWidthScale << " l\n";
     1033        }
    10331034      os << "grestore\n";
    10341035    }
  • lemon/lemon_reader.h

    r2553 r2618  
    34733473        maps.push_back(name);
    34743474      }
    3475       while (getline(is, line));
     3475      while (getline(is, line)) { }
    34763476    }
    34773477
  • lemon/list_graph.h

    r2553 r2618  
    119119      for(n = first_node;
    120120          n!=-1 && nodes[n].first_in == -1;
    121           n = nodes[n].next);
     121          n = nodes[n].next) { }
    122122      e.id = (n == -1) ? -1 : nodes[n].first_in;
    123123    }
     
    129129        int n;
    130130        for(n = nodes[edges[edge.id].target].next;
    131           n!=-1 && nodes[n].first_in == -1;
    132           n = nodes[n].next);
     131            n!=-1 && nodes[n].first_in == -1;
     132            n = nodes[n].next) { }
    133133        edge.id = (n == -1) ? -1 : nodes[n].first_in;
    134134      }     
  • lemon/lp_base.h

    r2609 r2618  
    4444  {
    4545    typedef std::numeric_limits<T> Lim;
    46     if (Lim::has_infinity && (value == Lim::infinity() || value ==
    47           -Lim::infinity()) ||
    48         (Lim::has_quiet_NaN || Lim::has_signaling_NaN) && value != value)
     46    if ((Lim::has_infinity && (value == Lim::infinity() || value ==
     47                               -Lim::infinity())) ||
     48        ((Lim::has_quiet_NaN || Lim::has_signaling_NaN) && value != value))
    4949    {
    5050      return false;
  • lemon/min_mean_cycle.h

    r2588 r2618  
    5656
    5757    typedef typename LengthMap::Value Length;
    58     typedef Path<Graph> Path;
     58    typedef lemon::Path<Graph> Path;
    5959
    6060  private:
  • lemon/preflow.h

    r2553 r2618  
    8787    ///
    8888    /// The tolerance used by the algorithm to handle inexact computation.
    89     typedef Tolerance<Value> Tolerance;
     89    typedef lemon::Tolerance<Value> Tolerance;
    9090
    9191  };
  • lemon/random.h

    r2608 r2618  
    6868
    6969#include <ctime>
     70#include <limits>
    7071
    7172#include <lemon/math.h>
  • test/bipartite_matching_test.cc

    r2571 r2618  
    196196
    197197    bpmatch.greedyInit();
    198     while (bpmatch.simpleAugment());
     198    while (bpmatch.simpleAugment()) { }
    199199   
    200200    Graph::UEdgeMap<bool> mm(graph);
  • tools/lgf-gen.cc

    r2569 r2618  
    121121  do {
    122122    Node n;
    123     for(IncEdgeIt e(g,v2);(n=g.runningNode(e))==u2;++e);
     123    for(IncEdgeIt e(g,v2);(n=g.runningNode(e))==u2;++e) { }
    124124    u2=v2;
    125125    v2=n;
Note: See TracChangeset for help on using the changeset viewer.