betweenness_centrality.hpp 24 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Copyright 2004 The Trustees of Indiana University.

// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

//  Authors: Douglas Gregor
//           Andrew Lumsdaine

// Hacked by Tiago Peixoto, to enable openmp support for graph-tool

#ifndef BOOST_GRAPH_BRANDES_BETWEENNESS_CENTRALITY_HPP
#define BOOST_GRAPH_BRANDES_BETWEENNESS_CENTRALITY_HPP

#include <stack>
#include <vector>
#include <boost/graph/dijkstra_shortest_paths.hpp>
#include <boost/graph/breadth_first_search.hpp>
#include <boost/graph/relax.hpp>
#include <boost/graph/graph_traits.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/if.hpp>
25
26
27
28
29
30
31
32
#include <boost/version.hpp>
#if (BOOST_VERSION >= 104000)
#   include <boost/property_map/property_map.hpp>
#   include <boost/property_map/vector_property_map.hpp>
#else
#   include <boost/property_map.hpp>
#   include <boost/vector_property_map.hpp>
#endif
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <boost/graph/named_function_params.hpp>
#include <algorithm>

namespace boost {

namespace detail { namespace graph {

  /**
   * Customized visitor passed to Dijkstra's algorithm by Brandes'
   * betweenness centrality algorithm. This visitor is responsible for
   * keeping track of the order in which vertices are discovered, the
   * predecessors on the shortest path(s) to a vertex, and the number
   * of shortest paths.
   */
  template<typename Graph, typename WeightMap, typename IncomingMap,
           typename DistanceMap, typename PathCountMap>
  struct brandes_dijkstra_visitor : public bfs_visitor<>
  {
    typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
    typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;

54
55
56
57
58
59
60
61
    brandes_dijkstra_visitor(std::stack<vertex_descriptor>& iordered_vertices,
                             WeightMap iweight,
                             IncomingMap iincoming,
                             DistanceMap idistance,
                             PathCountMap ipath_count)
      : ordered_vertices(iordered_vertices), weight(iweight),
        incoming(iincoming), distance(idistance),
        path_count(ipath_count)
62
63
64
65
66
67
68
    { }

    /**
     * Whenever an edge e = (v, w) is relaxed, the incoming edge list
     * for w is set to {(v, w)} and the shortest path count of w is set to
     * the number of paths that reach {v}.
     */
69
70
    void edge_relaxed(edge_descriptor e, const Graph& g)
    {
71
72
73
74
75
76
77
78
79
80
81
82
      vertex_descriptor v = source(e, g), w = target(e, g);
      incoming[w].clear();
      incoming[w].push_back(e);
      put(path_count, w, get(path_count, v));
    }

    /**
     * If an edge e = (v, w) was not relaxed, it may still be the case
     * that we've found more equally-short paths, so include {(v, w)} in the
     * incoming edges of w and add all of the shortest paths to v to the
     * shortest path count of w.
     */
83
    void edge_not_relaxed(edge_descriptor e, const Graph& g)
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
    {
      typedef typename property_traits<WeightMap>::value_type weight_type;
      typedef typename property_traits<DistanceMap>::value_type distance_type;
      vertex_descriptor v = source(e, g), w = target(e, g);
      distance_type d_v = get(distance, v), d_w = get(distance, w);
      weight_type w_e = get(weight, e);

      closed_plus<distance_type> combine;
      if (d_w == combine(d_v, w_e)) {
        put(path_count, w, get(path_count, w) + get(path_count, v));
        incoming[w].push_back(e);
      }
    }

    /// Keep track of vertices as they are reached
99
100
    void examine_vertex(vertex_descriptor w, const Graph&)
    {
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
      ordered_vertices.push(w);
    }

  private:
    std::stack<vertex_descriptor>& ordered_vertices;
    WeightMap weight;
    IncomingMap incoming;
    DistanceMap distance;
    PathCountMap path_count;
  };

  /**
   * Function object that calls Dijkstra's shortest paths algorithm
   * using the Dijkstra visitor for the Brandes betweenness centrality
   * algorithm.
   */
  template<typename WeightMap>
  struct brandes_dijkstra_shortest_paths
  {
120
121
    brandes_dijkstra_shortest_paths(WeightMap iweight_map)
      : weight_map(iweight_map) { }
122

123
    template<typename Graph, typename IncomingMap, typename DistanceMap,
124
             typename PathCountMap, typename VertexIndexMap>
125
126
    void
    operator()(Graph& g,
127
128
129
130
131
132
133
               typename graph_traits<Graph>::vertex_descriptor s,
               std::stack<typename graph_traits<Graph>::vertex_descriptor>& ov,
               IncomingMap incoming,
               DistanceMap distance,
               PathCountMap path_count,
               VertexIndexMap vertex_index)
    {
134
      typedef brandes_dijkstra_visitor<Graph, WeightMap, IncomingMap,
135
136
137
                                       DistanceMap, PathCountMap> visitor_type;
      visitor_type visitor(ov, weight_map, incoming, distance, path_count);

138
      dijkstra_shortest_paths(g, s,
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
                              boost::weight_map(weight_map)
                              .vertex_index_map(vertex_index)
                              .distance_map(distance)
                              .visitor(visitor));
    }

  private:
    WeightMap weight_map;
  };

  /**
   * Function object that invokes breadth-first search for the
   * unweighted form of the Brandes betweenness centrality algorithm.
   */
  struct brandes_unweighted_shortest_paths
  {
    /**
     * Customized visitor passed to breadth-first search, which
     * records predecessor and the number of shortest paths to each
     * vertex.
     */
160
    template<typename Graph, typename IncomingMap, typename DistanceMap,
161
162
163
164
             typename PathCountMap>
    struct visitor_type : public bfs_visitor<>
    {
      typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
165
      typedef typename graph_traits<Graph>::vertex_descriptor
166
        vertex_descriptor;
167

168
169
170
171
172
      visitor_type(IncomingMap iincoming, DistanceMap idistance,
                   PathCountMap ipath_count,
                   std::stack<vertex_descriptor>& iordered_vertices)
        : incoming(iincoming), distance(idistance),
          path_count(ipath_count), ordered_vertices(iordered_vertices) { }
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189

      /// Keep track of vertices as they are reached
      void examine_vertex(vertex_descriptor v, Graph&)
      {
        ordered_vertices.push(v);
      }

      /**
       * Whenever an edge e = (v, w) is labelled a tree edge, the
       * incoming edge list for w is set to {(v, w)} and the shortest
       * path count of w is set to the number of paths that reach {v}.
       */
      void tree_edge(edge_descriptor e, Graph& g)
      {
        vertex_descriptor v = source(e, g);
        vertex_descriptor w = target(e, g);
        put(distance, w, get(distance, v) + 1);
190

191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
        put(path_count, w, get(path_count, v));
        incoming[w].push_back(e);
      }

      /**
       * If an edge e = (v, w) is not a tree edge, it may still be the
       * case that we've found more equally-short paths, so include (v, w)
       * in the incoming edge list of w and add all of the shortest
       * paths to v to the shortest path count of w.
       */
      void non_tree_edge(edge_descriptor e, Graph& g)
      {
        vertex_descriptor v = source(e, g);
        vertex_descriptor w = target(e, g);
        if (get(distance, w) == get(distance, v) + 1) {
          put(path_count, w, get(path_count, w) + get(path_count, v));
          incoming[w].push_back(e);
        }
      }

    private:
      IncomingMap incoming;
      DistanceMap distance;
      PathCountMap path_count;
      std::stack<vertex_descriptor>& ordered_vertices;
    };

218
    template<typename Graph, typename IncomingMap, typename DistanceMap,
219
             typename PathCountMap, typename VertexIndexMap>
220
221
    void
    operator()(Graph& g,
222
223
224
225
226
227
228
229
230
231
232
233
               typename graph_traits<Graph>::vertex_descriptor s,
               std::stack<typename graph_traits<Graph>::vertex_descriptor>& ov,
               IncomingMap incoming,
               DistanceMap distance,
               PathCountMap path_count,
               VertexIndexMap vertex_index)
    {
      typedef typename graph_traits<Graph>::vertex_descriptor
        vertex_descriptor;

      visitor_type<Graph, IncomingMap, DistanceMap, PathCountMap>
        visitor(incoming, distance, path_count, ov);
234
235

      std::vector<default_color_type>
236
237
        colors(num_vertices(g), color_traits<default_color_type>::white());
      boost::queue<vertex_descriptor> Q;
238
239
      breadth_first_visit(g, s, Q, visitor,
                          make_iterator_property_map(colors.begin(),
240
241
242
243
244
245
246
                                                     vertex_index));
    }
  };

  // When the edge centrality map is a dummy property map, no
  // initialization is needed.
  template<typename Iter>
247
  inline void
248
249
250
251
252
  init_centrality_map(std::pair<Iter, Iter>, dummy_property_map) { }

  // When we have a real edge centrality map, initialize all of the
  // centralities to zero.
  template<typename Iter, typename Centrality>
253
  void
254
255
  init_centrality_map(std::pair<Iter, Iter> keys, Centrality centrality_map)
  {
256
    typedef typename property_traits<Centrality>::value_type
257
258
259
260
261
262
263
264
265
266
      centrality_type;
    while (keys.first != keys.second) {
      put(centrality_map, *keys.first, centrality_type(0));
      ++keys.first;
    }
  }

  // When the edge centrality map is a dummy property map, no update
  // is performed.
  template<typename Key, typename T>
267
  inline void
268
269
270
271
  update_centrality(dummy_property_map, const Key&, const T&) { }

  // When we have a real edge centrality map, add the value to the map
  template<typename CentralityMap, typename Key, typename T>
272
  inline void
273
274
275
276
  update_centrality(CentralityMap centrality_map, Key k, const T& x)
  { put(centrality_map, k, get(centrality_map, k) + x); }

  template<typename Iter>
277
  inline void
278
279
280
281
  divide_centrality_by_two(std::pair<Iter, Iter>, dummy_property_map) {}

  template<typename Iter, typename CentralityMap>
  inline void
282
  divide_centrality_by_two(std::pair<Iter, Iter> keys,
283
284
285
286
287
288
289
290
291
292
                           CentralityMap centrality_map)
  {
    typename property_traits<CentralityMap>::value_type two(2);
    while (keys.first != keys.second) {
      put(centrality_map, *keys.first, get(centrality_map, *keys.first) / two);
      ++keys.first;
    }
  }

  template<typename Graph, typename CentralityMap, typename EdgeCentralityMap,
293
           typename IncomingMap, typename DistanceMap,
294
295
           typename DependencyMap, typename PathCountMap,
           typename VertexIndexMap, typename ShortestPaths>
296
297
  void
  brandes_betweenness_centrality_impl(const Graph& g,
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
                                      CentralityMap centrality,     // C_B
                                      EdgeCentralityMap edge_centrality_map,
                                      IncomingMap, //incoming, // P
                                      DistanceMap, //distance,         // d
                                      DependencyMap, //dependency,     // delta
                                      PathCountMap, //path_count,      // sigma
                                      VertexIndexMap vertex_index,
                                      ShortestPaths shortest_paths)
  {
    typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator;
    typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;

    // Initialize centrality
    init_centrality_map(vertices(g), centrality);
    init_centrality_map(edges(g), edge_centrality_map);

    int i, N = num_vertices(g);
315
    #pragma omp parallel for default(shared) private(i) schedule(dynamic)
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
    for (i = 0; i < N; ++i)
    {
      typename graph_traits<Graph>::vertex_descriptor s = vertex(i, g);
      if (s == graph_traits<Graph>::null_vertex())
          continue;

      std::stack<vertex_descriptor> ordered_vertices;

      vector_property_map<typename property_traits<IncomingMap>::value_type,VertexIndexMap> incoming(vertex_index);
      vector_property_map<typename property_traits<DistanceMap>::value_type,VertexIndexMap> distance(vertex_index);
      vector_property_map<typename property_traits<DependencyMap>::value_type,VertexIndexMap> dependency(vertex_index);
      vector_property_map<typename property_traits<PathCountMap>::value_type,VertexIndexMap> path_count(vertex_index);

      // Initialize for this iteration
      vertex_iterator w, w_end;
      for (tie(w, w_end) = vertices(g); w != w_end; ++w) {
        incoming[*w].clear();
        put(path_count, *w, 0);
        put(dependency, *w, 0);
      }
      put(path_count, s, 1);
337

338
339
340
341
342
      // Execute the shortest paths algorithm. This will be either
      // Dijkstra's algorithm or a customized breadth-first search,
      // depending on whether the graph is weighted or unweighted.
      shortest_paths(g, s, ordered_vertices, incoming, distance,
                     path_count, vertex_index);
343

344
      #pragma omp critical
345
      {
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
          while (!ordered_vertices.empty())
          {
              vertex_descriptor u = ordered_vertices.top();
              ordered_vertices.pop();

              typedef typename property_traits<IncomingMap>::value_type
                  incoming_type;
              typedef typename incoming_type::iterator incoming_iterator;
              typedef typename property_traits<DependencyMap>::value_type
                  dependency_type;

              for (incoming_iterator vw = incoming[u].begin();
                   vw != incoming[u].end(); ++vw) {
                  vertex_descriptor v = source(*vw, g);
                  dependency_type factor = dependency_type(get(path_count, v))
                      / dependency_type(get(path_count, u));
                  factor *= (dependency_type(1) + get(dependency, u));
                  put(dependency, v, get(dependency, v) + factor);
                  update_centrality(edge_centrality_map, *vw, factor);
              }

              if (u != s) {
                  update_centrality(centrality, u, get(dependency, u));
              }
370
          }
371
      }
372
373

    }
374

375
376

    typedef typename graph_traits<Graph>::directed_category directed_category;
377
    const bool is_undirected =
378
379
380
381
382
383
384
385
386
387
      is_convertible<directed_category*, undirected_tag*>::value;
    if (is_undirected) {
      divide_centrality_by_two(vertices(g), centrality);
      divide_centrality_by_two(edges(g), edge_centrality_map);
    }
  }

} } // end namespace detail::graph

template<typename Graph, typename CentralityMap, typename EdgeCentralityMap,
388
389
         typename IncomingMap, typename DistanceMap,
         typename DependencyMap, typename PathCountMap,
390
         typename VertexIndexMap>
391
392
void
brandes_betweenness_centrality(const Graph& g,
393
394
395
396
397
398
399
400
401
402
                               CentralityMap centrality,     // C_B
                               EdgeCentralityMap edge_centrality_map,
                               IncomingMap incoming, // P
                               DistanceMap distance,         // d
                               DependencyMap dependency,     // delta
                               PathCountMap path_count,      // sigma
                               VertexIndexMap vertex_index)
{
  detail::graph::brandes_unweighted_shortest_paths shortest_paths;

403
  detail::graph::brandes_betweenness_centrality_impl(g, centrality,
404
405
406
                                                     edge_centrality_map,
                                                     incoming, distance,
                                                     dependency, path_count,
407
                                                     vertex_index,
408
409
410
                                                     shortest_paths);
}

411
412
413
414
415
416
template<typename Graph, typename CentralityMap, typename EdgeCentralityMap,
         typename IncomingMap, typename DistanceMap,
         typename DependencyMap, typename PathCountMap,
         typename VertexIndexMap, typename WeightMap>
void
brandes_betweenness_centrality(const Graph& g,
417
418
419
420
421
422
423
424
425
426
427
428
                               CentralityMap centrality,     // C_B
                               EdgeCentralityMap edge_centrality_map,
                               IncomingMap incoming, // P
                               DistanceMap distance,         // d
                               DependencyMap dependency,     // delta
                               PathCountMap path_count,      // sigma
                               VertexIndexMap vertex_index,
                               WeightMap weight_map)
{
  detail::graph::brandes_dijkstra_shortest_paths<WeightMap>
    shortest_paths(weight_map);

429
  detail::graph::brandes_betweenness_centrality_impl(g, centrality,
430
431
432
                                                     edge_centrality_map,
                                                     incoming, distance,
                                                     dependency, path_count,
433
                                                     vertex_index,
434
435
436
437
438
439
                                                     shortest_paths);
}

namespace detail { namespace graph {
  template<typename Graph, typename CentralityMap, typename EdgeCentralityMap,
           typename WeightMap, typename VertexIndexMap>
440
  void
441
442
443
444
445
446
447
448
  brandes_betweenness_centrality_dispatch2(const Graph& g,
                                           CentralityMap centrality,
                                           EdgeCentralityMap edge_centrality_map,
                                           WeightMap weight_map,
                                           VertexIndexMap vertex_index)
  {
    typedef typename graph_traits<Graph>::degree_size_type degree_size_type;
    typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
449
    typedef typename mpl::if_c<(is_same<CentralityMap,
450
                                        dummy_property_map>::value),
451
                                         EdgeCentralityMap,
452
                               CentralityMap>::type a_centrality_map;
453
    typedef typename property_traits<a_centrality_map>::value_type
454
455
456
      centrality_type;

    typename graph_traits<Graph>::vertices_size_type V = num_vertices(g);
457

458
459
460
461
462
463
464
465
466
467
468
469
470
471
    std::vector<std::vector<edge_descriptor> > incoming(V);
    std::vector<centrality_type> distance(V);
    std::vector<centrality_type> dependency(V);
    std::vector<degree_size_type> path_count(V);

    brandes_betweenness_centrality(
      g, centrality, edge_centrality_map,
      make_iterator_property_map(incoming.begin(), vertex_index),
      make_iterator_property_map(distance.begin(), vertex_index),
      make_iterator_property_map(dependency.begin(), vertex_index),
      make_iterator_property_map(path_count.begin(), vertex_index),
      vertex_index,
      weight_map);
  }
472

473
474
475

  template<typename Graph, typename CentralityMap, typename EdgeCentralityMap,
           typename VertexIndexMap>
476
  void
477
478
479
480
481
482
483
  brandes_betweenness_centrality_dispatch2(const Graph& g,
                                           CentralityMap centrality,
                                           EdgeCentralityMap edge_centrality_map,
                                           VertexIndexMap vertex_index)
  {
    typedef typename graph_traits<Graph>::degree_size_type degree_size_type;
    typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
484
    typedef typename mpl::if_c<(is_same<CentralityMap,
485
                                        dummy_property_map>::value),
486
                                         EdgeCentralityMap,
487
                               CentralityMap>::type a_centrality_map;
488
    typedef typename property_traits<a_centrality_map>::value_type
489
490
491
      centrality_type;

    typename graph_traits<Graph>::vertices_size_type V = num_vertices(g);
492

493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
    std::vector<std::vector<edge_descriptor> > incoming(V);
    std::vector<centrality_type> distance(V);
    std::vector<centrality_type> dependency(V);
    std::vector<degree_size_type> path_count(V);

    brandes_betweenness_centrality(
      g, centrality, edge_centrality_map,
      make_iterator_property_map(incoming.begin(), vertex_index),
      make_iterator_property_map(distance.begin(), vertex_index),
      make_iterator_property_map(dependency.begin(), vertex_index),
      make_iterator_property_map(path_count.begin(), vertex_index),
      vertex_index);
  }

  template<typename WeightMap>
  struct brandes_betweenness_centrality_dispatch1
  {
510
    template<typename Graph, typename CentralityMap,
511
             typename EdgeCentralityMap, typename VertexIndexMap>
512
513
    static void
    run(const Graph& g, CentralityMap centrality,
514
515
516
517
518
519
520
521
522
523
524
        EdgeCentralityMap edge_centrality_map, VertexIndexMap vertex_index,
        WeightMap weight_map)
    {
      brandes_betweenness_centrality_dispatch2(g, centrality, edge_centrality_map,
                                               weight_map, vertex_index);
    }
  };

  template<>
  struct brandes_betweenness_centrality_dispatch1<error_property_not_found>
  {
525
    template<typename Graph, typename CentralityMap,
526
             typename EdgeCentralityMap, typename VertexIndexMap>
527
528
    static void
    run(const Graph& g, CentralityMap centrality,
529
530
531
532
533
534
535
536
537
538
539
        EdgeCentralityMap edge_centrality_map, VertexIndexMap vertex_index,
        error_property_not_found)
    {
      brandes_betweenness_centrality_dispatch2(g, centrality, edge_centrality_map,
                                               vertex_index);
    }
  };

} } // end namespace detail::graph

template<typename Graph, typename Param, typename Tag, typename Rest>
540
541
void
brandes_betweenness_centrality(const Graph& g,
542
543
544
545
546
547
                               const bgl_named_params<Param,Tag,Rest>& params)
{
  typedef bgl_named_params<Param,Tag,Rest> named_params;

  typedef typename property_value<named_params, edge_weight_t>::type ew;
  detail::graph::brandes_betweenness_centrality_dispatch1<ew>::run(
548
549
    g,
    choose_param(get_param(params, vertex_centrality),
550
                 dummy_property_map()),
551
    choose_param(get_param(params, edge_centrality),
552
553
554
555
556
557
                 dummy_property_map()),
    choose_const_pmap(get_param(params, vertex_index), g, vertex_index),
    get_param(params, edge_weight));
}

template<typename Graph, typename CentralityMap>
558
void
559
560
561
562
563
564
565
brandes_betweenness_centrality(const Graph& g, CentralityMap centrality)
{
  detail::graph::brandes_betweenness_centrality_dispatch2(
    g, centrality, dummy_property_map(), get(vertex_index, g));
}

template<typename Graph, typename CentralityMap, typename EdgeCentralityMap>
566
void
567
568
569
570
571
572
573
574
575
576
577
578
579
580
brandes_betweenness_centrality(const Graph& g, CentralityMap centrality,
                               EdgeCentralityMap edge_centrality_map)
{
  detail::graph::brandes_betweenness_centrality_dispatch2(
    g, centrality, edge_centrality_map, get(vertex_index, g));
}

/**
 * Converts "absolute" betweenness centrality (as computed by the
 * brandes_betweenness_centrality algorithm) in the centrality map
 * into "relative" centrality. The result is placed back into the
 * given centrality map.
 */
template<typename Graph, typename CentralityMap>
581
void
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
relative_betweenness_centrality(const Graph& g, CentralityMap centrality)
{
  typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator;
  typedef typename property_traits<CentralityMap>::value_type centrality_type;

  typename graph_traits<Graph>::vertices_size_type n = num_vertices(g);
  centrality_type factor = centrality_type(2)/centrality_type(n*n - 3*n + 2);
  vertex_iterator v, v_end;
  for (tie(v, v_end) = vertices(g); v != v_end; ++v) {
    put(centrality, *v, factor * get(centrality, *v));
  }
}

// Compute the central point dominance of a graph.
template<typename Graph, typename CentralityMap>
typename property_traits<CentralityMap>::value_type
central_point_dominance(const Graph& g, CentralityMap centrality)
{
  using std::max;

  typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator;
  typedef typename property_traits<CentralityMap>::value_type centrality_type;

  typename graph_traits<Graph>::vertices_size_type n = num_vertices(g);

  // Find max centrality
  centrality_type max_centrality(0);
  vertex_iterator v, v_end;
  for (tie(v, v_end) = vertices(g); v != v_end; ++v) {
    max_centrality = (max)(max_centrality, get(centrality, *v));
  }

  // Compute central point dominance
  centrality_type sum(0);
  for (tie(v, v_end) = vertices(g); v != v_end; ++v) {
    sum += (max_centrality - get(centrality, *v));
  }
  return sum/(n-1);
}

} // end namespace boost

#endif // BOOST_GRAPH_BRANDES_BETWEENNESS_CENTRALITY_HPP