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