/Src/Dependencies/Boost/boost/graph/random.hpp

http://hadesmem.googlecode.com/ · C++ Header · 266 lines · 221 code · 31 blank · 14 comment · 28 complexity · 905de3575f028d1b32a513236c084a07 MD5 · raw file

  1. //=======================================================================
  2. // Copyright 1997, 1998, 1999, 2000 University of Notre Dame.
  3. // Copyright (C) Vladimir Prus 2003
  4. // Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek
  5. //
  6. // Distributed under the Boost Software License, Version 1.0. (See
  7. // accompanying file LICENSE_1_0.txt or copy at
  8. // http://www.boost.org/LICENSE_1_0.txt)
  9. //=======================================================================
  10. #ifndef BOOST_GRAPH_RANDOM_HPP
  11. #define BOOST_GRAPH_RANDOM_HPP
  12. #include <boost/graph/graph_traits.hpp>
  13. #include <boost/random/uniform_int.hpp>
  14. #include <boost/random/uniform_real.hpp>
  15. #include <boost/random/variate_generator.hpp>
  16. #include <boost/pending/property.hpp>
  17. #include <boost/graph/properties.hpp>
  18. #include <boost/graph/iteration_macros.hpp>
  19. #include <boost/next_prior.hpp>
  20. #include <boost/graph/adjacency_list.hpp>
  21. #include <boost/graph/copy.hpp>
  22. #include <boost/mpl/if.hpp>
  23. #include <boost/type_traits/is_convertible.hpp>
  24. #include <iostream>
  25. #include <boost/assert.hpp>
  26. namespace boost {
  27. // grab a random vertex from the graph's vertex set
  28. template <class Graph, class RandomNumGen>
  29. typename graph_traits<Graph>::vertex_descriptor
  30. random_vertex(Graph& g, RandomNumGen& gen)
  31. {
  32. if (num_vertices(g) > 1) {
  33. #if BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581))
  34. std::size_t n = std::random( num_vertices(g) );
  35. #else
  36. uniform_int<> distrib(0, num_vertices(g)-1);
  37. variate_generator<RandomNumGen&, uniform_int<> > rand_gen(gen, distrib);
  38. std::size_t n = rand_gen();
  39. #endif
  40. typename graph_traits<Graph>::vertex_iterator
  41. i = vertices(g).first;
  42. return *(boost::next(i, n));
  43. } else
  44. return *vertices(g).first;
  45. }
  46. template <class Graph, class RandomNumGen>
  47. typename graph_traits<Graph>::edge_descriptor
  48. random_edge(Graph& g, RandomNumGen& gen) {
  49. if (num_edges(g) > 1) {
  50. #if BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581))
  51. typename graph_traits<Graph>::edges_size_type
  52. n = std::random( num_edges(g) );
  53. #else
  54. uniform_int<> distrib(0, num_edges(g)-1);
  55. variate_generator<RandomNumGen&, uniform_int<> > rand_gen(gen, distrib);
  56. typename graph_traits<Graph>::edges_size_type
  57. n = rand_gen();
  58. #endif
  59. typename graph_traits<Graph>::edge_iterator
  60. i = edges(g).first;
  61. return *(boost::next(i, n));
  62. } else
  63. return *edges(g).first;
  64. }
  65. template <typename Graph, typename RandomNumGen>
  66. typename graph_traits<Graph>::edge_descriptor
  67. random_out_edge(Graph& g, typename graph_traits<Graph>::vertex_descriptor src, RandomNumGen& gen) {
  68. typedef typename graph_traits<Graph>::degree_size_type degree_size_type;
  69. typedef boost::uniform_int<degree_size_type> ui_type;
  70. ui_type ui(0, out_degree(src, g) - 1);
  71. boost::variate_generator<RandomNumGen&, ui_type>
  72. variate(gen, ui);
  73. typename graph_traits<Graph>::out_edge_iterator it = out_edges(src, g).first;
  74. std::advance(it, variate());
  75. return *it;
  76. }
  77. template <typename Graph, typename WeightMap, typename RandomNumGen>
  78. typename graph_traits<Graph>::edge_descriptor
  79. weighted_random_out_edge(Graph& g, typename graph_traits<Graph>::vertex_descriptor src, WeightMap weight, RandomNumGen& gen) {
  80. typedef graph_traits<Graph> gt;
  81. typedef typename gt::vertex_descriptor vertex_descriptor;
  82. typedef typename property_traits<WeightMap>::value_type weight_type;
  83. weight_type weight_sum(0);
  84. BGL_FORALL_OUTEDGES_T(src, e, g, Graph) {weight_sum += get(weight, e);}
  85. typedef boost::uniform_real<> ur_type;
  86. ur_type ur(0, weight_sum);
  87. boost::variate_generator<RandomNumGen&, ur_type>
  88. variate(gen, ur);
  89. weight_type chosen_weight = variate();
  90. BGL_FORALL_OUTEDGES_T(src, e, g, Graph) {
  91. weight_type w = get(weight, e);
  92. if (chosen_weight < w) {
  93. return e;
  94. } else {
  95. chosen_weight -= w;
  96. }
  97. }
  98. BOOST_ASSERT (false); // Should not get here
  99. }
  100. namespace detail {
  101. class dummy_property_copier {
  102. public:
  103. template<class V1, class V2>
  104. void operator()(const V1&, const V2&) const {}
  105. };
  106. }
  107. template <typename MutableGraph, class RandNumGen>
  108. void generate_random_graph1
  109. (MutableGraph& g,
  110. typename graph_traits<MutableGraph>::vertices_size_type V,
  111. typename graph_traits<MutableGraph>::vertices_size_type E,
  112. RandNumGen& gen,
  113. bool allow_parallel = true,
  114. bool self_edges = false)
  115. {
  116. typedef graph_traits<MutableGraph> Traits;
  117. typedef typename Traits::edge_descriptor edge_t;
  118. typedef typename Traits::vertices_size_type v_size_t;
  119. typedef typename Traits::edges_size_type e_size_t;
  120. typedef typename Traits::vertex_descriptor vertex_descriptor;
  121. // When parallel edges are not allowed, we create a new graph which
  122. // does not allow parallel edges, construct it and copy back.
  123. // This is not efficient if 'g' already disallow parallel edges,
  124. // but that's task for later.
  125. if (!allow_parallel) {
  126. typedef typename boost::graph_traits<MutableGraph>::directed_category dir;
  127. typedef typename mpl::if_<is_convertible<dir, directed_tag>,
  128. directedS, undirectedS>::type select;
  129. adjacency_list<setS, vecS, select> g2;
  130. generate_random_graph1(g2, V, E, gen, true, self_edges);
  131. copy_graph(g2, g, vertex_copy(detail::dummy_property_copier()).
  132. edge_copy(detail::dummy_property_copier()));
  133. } else {
  134. for (v_size_t i = 0; i < V; ++i)
  135. add_vertex(g);
  136. e_size_t not_inserted_counter = 0; /* Number of edge insertion failures */
  137. e_size_t num_vertices_squared = num_vertices(g) * num_vertices(g);
  138. for (e_size_t j = 0; j < E; /* Increment in body */) {
  139. vertex_descriptor a = random_vertex(g, gen), b;
  140. do {
  141. b = random_vertex(g, gen);
  142. } while (self_edges == false && a == b);
  143. edge_t e; bool inserted;
  144. boost::tie(e, inserted) = add_edge(a, b, g);
  145. if (inserted) {
  146. ++j;
  147. } else {
  148. ++not_inserted_counter;
  149. }
  150. if (not_inserted_counter >= num_vertices_squared) {
  151. return; /* Rather than looping forever on complete graph */
  152. }
  153. }
  154. }
  155. }
  156. template <typename MutableGraph, class RandNumGen>
  157. void generate_random_graph
  158. (MutableGraph& g,
  159. typename graph_traits<MutableGraph>::vertices_size_type V,
  160. typename graph_traits<MutableGraph>::vertices_size_type E,
  161. RandNumGen& gen,
  162. bool allow_parallel = true,
  163. bool self_edges = false)
  164. {
  165. generate_random_graph1(g, V, E, gen, allow_parallel, self_edges);
  166. }
  167. template <typename MutableGraph, typename RandNumGen,
  168. typename VertexOutputIterator, typename EdgeOutputIterator>
  169. void generate_random_graph
  170. (MutableGraph& g,
  171. typename graph_traits<MutableGraph>::vertices_size_type V,
  172. typename graph_traits<MutableGraph>::vertices_size_type E,
  173. RandNumGen& gen,
  174. VertexOutputIterator vertex_out,
  175. EdgeOutputIterator edge_out,
  176. bool self_edges = false)
  177. {
  178. typedef graph_traits<MutableGraph> Traits;
  179. typedef typename Traits::vertices_size_type v_size_t;
  180. typedef typename Traits::edges_size_type e_size_t;
  181. typedef typename Traits::vertex_descriptor vertex_t;
  182. typedef typename Traits::edge_descriptor edge_t;
  183. for (v_size_t i = 0; i < V; ++i)
  184. *vertex_out++ = add_vertex(g);
  185. e_size_t not_inserted_counter = 0; /* Number of edge insertion failures */
  186. e_size_t num_vertices_squared = num_vertices(g) * num_vertices(g);
  187. for (e_size_t j = 0; j < E; /* Increment in body */) {
  188. vertex_t a = random_vertex(g, gen), b;
  189. do {
  190. b = random_vertex(g, gen);
  191. } while (self_edges == false && a == b);
  192. edge_t e; bool inserted;
  193. boost::tie(e, inserted) = add_edge(a, b, g);
  194. if (inserted) {
  195. *edge_out++ = std::make_pair(source(e, g), target(e, g));
  196. ++j;
  197. } else {
  198. ++not_inserted_counter;
  199. }
  200. if (not_inserted_counter >= num_vertices_squared) {
  201. return; /* Rather than looping forever on complete graph */
  202. }
  203. }
  204. }
  205. namespace detail {
  206. template<class Property, class G, class RandomGenerator>
  207. void randomize_property(G& g, RandomGenerator& rg,
  208. Property, vertex_property_tag)
  209. {
  210. typename property_map<G, Property>::type pm = get(Property(), g);
  211. typename graph_traits<G>::vertex_iterator vi, ve;
  212. for (boost::tie(vi, ve) = vertices(g); vi != ve; ++vi) {
  213. pm[*vi] = rg();
  214. }
  215. }
  216. template<class Property, class G, class RandomGenerator>
  217. void randomize_property(G& g, RandomGenerator& rg,
  218. Property, edge_property_tag)
  219. {
  220. typename property_map<G, Property>::type pm = get(Property(), g);
  221. typename graph_traits<G>::edge_iterator ei, ee;
  222. for (boost::tie(ei, ee) = edges(g); ei != ee; ++ei) {
  223. pm[*ei] = rg();
  224. }
  225. }
  226. }
  227. template<class Property, class G, class RandomGenerator>
  228. void randomize_property(G& g, RandomGenerator& rg)
  229. {
  230. detail::randomize_property
  231. (g, rg, Property(), typename property_kind<Property>::type());
  232. }
  233. }
  234. #include <boost/graph/iteration_macros_undef.hpp>
  235. #endif