gravatar
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:
↑ Collapse diff ↑
Ignore white space 6 line context
... ...
@@ -50,7 +50,7 @@
50 50
      LEMON_ASSERT(dim >= 1, "The number of dimensions must be at least 1.");
51 51
      _dim = dim;
52 52
      _node_num = 1 << dim;
53
      _edge_num = dim * (1 << dim-1);
53
      _edge_num = dim * (1 << (dim-1));
54 54
    }
55 55

	
56 56
  public:
... ...
@@ -76,15 +76,15 @@
76 76
    static int id(Arc arc) { return arc._id; }
77 77

	
78 78
    Node u(Edge edge) const {
79
      int base = edge._id & ((1 << _dim-1) - 1);
80
      int k = edge._id >> _dim-1;
81
      return ((base >> k) << k+1) | (base & ((1 << k) - 1));
79
      int base = edge._id & ((1 << (_dim-1)) - 1);
80
      int k = edge._id >> (_dim-1);
81
      return ((base >> k) << (k+1)) | (base & ((1 << k) - 1));
82 82
    }
83 83

	
84 84
    Node v(Edge edge) const {
85
      int base = edge._id & ((1 << _dim-1) - 1);
86
      int k = edge._id >> _dim-1;
87
      return ((base >> k) << k+1) | (base & ((1 << k) - 1)) | (1 << k);
85
      int base = edge._id & ((1 << (_dim-1)) - 1);
86
      int k = edge._id >> (_dim-1);
87
      return ((base >> k) << (k+1)) | (base & ((1 << k) - 1)) | (1 << k);
88 88
    }
89 89

	
90 90
    Node source(Arc arc) const {
... ...
@@ -105,13 +105,14 @@
105 105
      if (d == 0) return INVALID;
106 106
      for ( ; (d & 1) == 0; d >>= 1) ++k;
107 107
      if (d >> 1 != 0) return INVALID;
108
      return (k << _dim-1) | ((u._id >> k+1) << k) | (u._id & ((1 << k) - 1));
108
      return (k << (_dim-1)) | ((u._id >> (k+1)) << k) |
109
        (u._id & ((1 << k) - 1));
109 110
    }
110 111

	
111 112
    Arc findArc(Node u, Node v, Arc prev = INVALID) const {
112 113
      Edge edge = findEdge(u, v, prev);
113 114
      if (edge == INVALID) return INVALID;
114
      int k = edge._id >> _dim-1;
115
      int k = edge._id >> (_dim-1);
115 116
      return ((u._id >> k) & 1) == 1 ? edge._id << 1 : (edge._id << 1) | 1;
116 117
    }
117 118

	
... ...
@@ -194,10 +195,10 @@
194 195

	
195 196
    void nextInc(Edge& edge, bool& dir) const {
196 197
      Node n = dir ? u(edge) : v(edge);
197
      int k = (edge._id >> _dim-1) + 1;
198
      int k = (edge._id >> (_dim-1)) + 1;
198 199
      if (k < _dim) {
199
        edge._id = (k << _dim-1) |
200
                   ((n._id >> k+1) << k) | (n._id & ((1 << k) - 1));
200
        edge._id = (k << (_dim-1)) |
201
          ((n._id >> (k+1)) << k) | (n._id & ((1 << k) - 1));
201 202
        dir = ((n._id >> k) & 1) == 0;
202 203
      } else {
203 204
        edge._id = -1;
... ...
@@ -213,8 +214,8 @@
213 214
      Node n = (arc._id & 1) == 1 ? u(arc) : v(arc);
214 215
      int k = (arc._id >> _dim) + 1;
215 216
      if (k < _dim) {
216
        arc._id = (k << _dim-1) |
217
                  ((n._id >> k+1) << k) | (n._id & ((1 << k) - 1));
217
        arc._id = (k << (_dim-1)) |
218
          ((n._id >> (k+1)) << k) | (n._id & ((1 << k) - 1));
218 219
        arc._id = (arc._id << 1) | (~(n._id >> k) & 1);
219 220
      } else {
220 221
        arc._id = -1;
... ...
@@ -229,8 +230,8 @@
229 230
      Node n = (arc._id & 1) == 1 ? v(arc) : u(arc);
230 231
      int k = (arc._id >> _dim) + 1;
231 232
      if (k < _dim) {
232
        arc._id = (k << _dim-1) |
233
                  ((n._id >> k+1) << k) | (n._id & ((1 << k) - 1));
233
        arc._id = (k << (_dim-1)) |
234
          ((n._id >> (k+1)) << k) | (n._id & ((1 << k) - 1));
234 235
        arc._id = (arc._id << 1) | ((n._id >> k) & 1);
235 236
      } else {
236 237
        arc._id = -1;
... ...
@@ -254,7 +255,7 @@
254 255
    }
255 256

	
256 257
    int dimension(Edge edge) const {
257
      return edge._id >> _dim-1;
258
      return edge._id >> (_dim-1);
258 259
    }
259 260

	
260 261
    int dimension(Arc arc) const {
Ignore white space 6 line context
... ...
@@ -321,7 +321,7 @@
321 321

	
322 322
  HypercubeGraph G(dim);
323 323
  checkGraphNodeList(G, 1 << dim);
324
  checkGraphEdgeList(G, dim * (1 << dim-1));
324
  checkGraphEdgeList(G, dim * (1 << (dim-1)));
325 325
  checkGraphArcList(G, dim * (1 << dim));
326 326

	
327 327
  Node n = G.nodeFromId(dim);
... ...
@@ -330,29 +330,29 @@
330 330
    checkGraphIncEdgeList(G, n, dim);
331 331
    for (IncEdgeIt e(G, n); e != INVALID; ++e) {
332 332
      check( (G.u(e) == n &&
333
              G.id(G.v(e)) == G.id(n) ^ (1 << G.dimension(e))) ||
333
              G.id(G.v(e)) == (G.id(n) ^ (1 << G.dimension(e)))) ||
334 334
             (G.v(e) == n &&
335
              G.id(G.u(e)) == G.id(n) ^ (1 << G.dimension(e))),
335
              G.id(G.u(e)) == (G.id(n) ^ (1 << G.dimension(e)))),
336 336
             "Wrong edge or wrong dimension");
337 337
    }
338 338

	
339 339
    checkGraphOutArcList(G, n, dim);
340 340
    for (OutArcIt a(G, n); a != INVALID; ++a) {
341 341
      check(G.source(a) == n &&
342
            G.id(G.target(a)) == G.id(n) ^ (1 << G.dimension(a)),
342
            G.id(G.target(a)) == (G.id(n) ^ (1 << G.dimension(a))),
343 343
            "Wrong arc or wrong dimension");
344 344
    }
345 345

	
346 346
    checkGraphInArcList(G, n, dim);
347 347
    for (InArcIt a(G, n); a != INVALID; ++a) {
348 348
      check(G.target(a) == n &&
349
            G.id(G.source(a)) == G.id(n) ^ (1 << G.dimension(a)),
349
            G.id(G.source(a)) == (G.id(n) ^ (1 << G.dimension(a))),
350 350
            "Wrong arc or wrong dimension");
351 351
    }
352 352
  }
353 353

	
354 354
  checkGraphConArcList(G, (1 << dim) * dim);
355
  checkGraphConEdgeList(G, dim * (1 << dim-1));
355
  checkGraphConEdgeList(G, dim * (1 << (dim-1)));
356 356

	
357 357
  checkArcDirections(G);
358 358

	
0 comments (0 inline)