LEMON/LEMON-main Changeset - r372:7b6466ed488a

Repositories » LEMON » LEMON-main

Summary
Changelog
Files
Switch To
- loading...
Options
- Lightweight changelog
- Search
Pull Requests

Changeset - r372:7b6466ed488a

« 371:164fe3

375:2d87db »

r372:7b6466ed488a

Fri, 07 Nov 2008 14:04:54

[Not Reviewed]

0 comments (0 inline)

alpar (Alpar Juttner)
alpar@cs.elte.hu

Avoid bit operator precedence warning with gcc-4.3 Some of these warnings are actually revealed real bugs

0 2 0

default

2 files changed with 24 insertions and 23 deletions:

lemon/hypercube_graph.h

test/graph_test.cc

↑ Collapse diff ↑

lemon/hypercube_graph.h

Show inline comments

@@ -47,13 +47,13 @@
 		  protected:
 		    void construct(int dim) {
 		      LEMON_ASSERT(dim >= 1, "The number of dimensions must be at least 1.");
 		      _dim = dim;
 		      _node_num = 1 << dim;
 		      _edge_num = dim * (1 << dim-1);
+		      _edge_num = dim * (1 << (dim-1));
+		    }
 		  public:
 		    typedef True NodeNumTag;
 		    typedef True EdgeNumTag;
@@ -73,21 +73,21 @@
 		    static int id(Node node) { return node._id; }
 		    static int id(Edge edge) { return edge._id; }
 		    static int id(Arc arc) { return arc._id; }
 		    Node u(Edge edge) const {
 		      int base = edge._id & ((1 << _dim-1) - 1);
 		      int k = edge._id >> _dim-1;
-		      return ((base >> k) << k+1) | (base & ((1 << k) - 1));
+		      int base = edge._id & ((1 << (_dim-1)) - 1);
 		      int k = edge._id >> (_dim-1);
 		      return ((base >> k) << (k+1)) | (base & ((1 << k) - 1));
+		    }
 		    Node v(Edge edge) const {
 		      int base = edge._id & ((1 << _dim-1) - 1);
 		      int k = edge._id >> _dim-1;
-		      return ((base >> k) << k+1) | (base & ((1 << k) - 1)) | (1 << k);
+		      int base = edge._id & ((1 << (_dim-1)) - 1);
 		      int k = edge._id >> (_dim-1);
 		      return ((base >> k) << (k+1)) | (base & ((1 << k) - 1)) | (1 << k);
+		    }
 		    Node source(Arc arc) const {
 		      return (arc._id & 1) == 1 ? u(arc) : v(arc);
+		    }
@@ -102,19 +102,20 @@
 		      if (prev != INVALID) return INVALID;
 		      int d = u._id ^ v._id;
 		      int k = 0;
 		      if (d == 0) return INVALID;
 		      for ( ; (d & 1) == 0; d >>= 1) ++k;
 		      if (d >> 1 != 0) return INVALID;
-		      return (k << _dim-1) | ((u._id >> k+1) << k) | (u._id & ((1 << k) - 1));
+		      return (k << (_dim-1)) | ((u._id >> (k+1)) << k) |
 		        (u._id & ((1 << k) - 1));
+		    }
 		    Arc findArc(Node u, Node v, Arc prev = INVALID) const {
 		      Edge edge = findEdge(u, v, prev);
 		      if (edge == INVALID) return INVALID;
 		      int k = edge._id >> _dim-1;
+		      int k = edge._id >> (_dim-1);
 		      return ((u._id >> k) & 1) == 1 ? edge._id << 1 : (edge._id << 1) | 1;
+		    }
 		    class Node {
 		      friend class HypercubeGraphBase;
@@ -191,16 +192,16 @@
 		      edge._id = node._id >> 1;
 		      dir = (node._id & 1) == 0;
+		    }
 		    void nextInc(Edge& edge, bool& dir) const {
 		      Node n = dir ? u(edge) : v(edge);
 		      int k = (edge._id >> _dim-1) + 1;
+		      int k = (edge._id >> (_dim-1)) + 1;
 		      if (k < _dim) {
 		        edge._id = (k << _dim-1) |
 		                   ((n._id >> k+1) << k) | (n._id & ((1 << k) - 1));
 		        edge._id = (k << (_dim-1)) |
 		          ((n._id >> (k+1)) << k) | (n._id & ((1 << k) - 1));
 		        dir = ((n._id >> k) & 1) == 0;
 		      } else {
 		        edge._id = -1;
 		        dir = true;
+		      }
+		    }
@@ -210,14 +211,14 @@
+		    }
 		    void nextOut(Arc& arc) const {
 		      Node n = (arc._id & 1) == 1 ? u(arc) : v(arc);
 		      int k = (arc._id >> _dim) + 1;
 		      if (k < _dim) {
 		        arc._id = (k << _dim-1) |
 		                  ((n._id >> k+1) << k) | (n._id & ((1 << k) - 1));
 		        arc._id = (k << (_dim-1)) |
 		          ((n._id >> (k+1)) << k) | (n._id & ((1 << k) - 1));
 		        arc._id = (arc._id << 1) | (~(n._id >> k) & 1);
 		      } else {
 		        arc._id = -1;
+		      }
+		    }
@@ -226,14 +227,14 @@
+		    }
 		    void nextIn(Arc& arc) const {
 		      Node n = (arc._id & 1) == 1 ? v(arc) : u(arc);
 		      int k = (arc._id >> _dim) + 1;
 		      if (k < _dim) {
 		        arc._id = (k << _dim-1) |
 		                  ((n._id >> k+1) << k) | (n._id & ((1 << k) - 1));
 		        arc._id = (k << (_dim-1)) |
 		          ((n._id >> (k+1)) << k) | (n._id & ((1 << k) - 1));
 		        arc._id = (arc._id << 1) | ((n._id >> k) & 1);
 		      } else {
 		        arc._id = -1;
+		      }
+		    }
@@ -251,13 +252,13 @@
 		    bool projection(Node node, int n) const {
 		      return static_cast<bool>(node._id & (1 << n));
+		    }
 		    int dimension(Edge edge) const {
 		      return edge._id >> _dim-1;
+		      return edge._id >> (_dim-1);
+		    }
 		    int dimension(Arc arc) const {
 		      return arc._id >> _dim;
+		    }

test/graph_test.cc

Show inline comments

@@ -318,44 +318,44 @@
 		void checkHypercubeGraph(int dim) {
 		  GRAPH_TYPEDEFS(HypercubeGraph);
 		  HypercubeGraph G(dim);
 		  checkGraphNodeList(G, 1 << dim);
 		  checkGraphEdgeList(G, dim * (1 << dim-1));
+		  checkGraphEdgeList(G, dim * (1 << (dim-1)));
 		  checkGraphArcList(G, dim * (1 << dim));
 		  Node n = G.nodeFromId(dim);
 		  for (NodeIt n(G); n != INVALID; ++n) {
 		    checkGraphIncEdgeList(G, n, dim);
 		    for (IncEdgeIt e(G, n); e != INVALID; ++e) {
 		      check( (G.u(e) == n &&
 		              G.id(G.v(e)) == G.id(n) ^ (1 << G.dimension(e))) ||
+		              G.id(G.v(e)) == (G.id(n) ^ (1 << G.dimension(e)))) ||
 		             (G.v(e) == n &&
 		              G.id(G.u(e)) == G.id(n) ^ (1 << G.dimension(e))),
+		              G.id(G.u(e)) == (G.id(n) ^ (1 << G.dimension(e)))),
 		             "Wrong edge or wrong dimension");
+		    }
 		    checkGraphOutArcList(G, n, dim);
 		    for (OutArcIt a(G, n); a != INVALID; ++a) {
 		      check(G.source(a) == n &&
 		            G.id(G.target(a)) == G.id(n) ^ (1 << G.dimension(a)),
+		            G.id(G.target(a)) == (G.id(n) ^ (1 << G.dimension(a))),
 		            "Wrong arc or wrong dimension");
+		    }
 		    checkGraphInArcList(G, n, dim);
 		    for (InArcIt a(G, n); a != INVALID; ++a) {
 		      check(G.target(a) == n &&
 		            G.id(G.source(a)) == G.id(n) ^ (1 << G.dimension(a)),
+		            G.id(G.source(a)) == (G.id(n) ^ (1 << G.dimension(a))),
 		            "Wrong arc or wrong dimension");
+		    }
+		  }
 		  checkGraphConArcList(G, (1 << dim) * dim);
 		  checkGraphConEdgeList(G, dim * (1 << dim-1));
+		  checkGraphConEdgeList(G, dim * (1 << (dim-1)));
 		  checkArcDirections(G);
 		  checkNodeIds(G);
 		  checkArcIds(G);
 		  checkEdgeIds(G);

0 comments (0 inline)

RhodeCode

Login to your account