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
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
13 #include <boost/graph/graph_traits.hpp>
14 #include <boost/random/uniform_int.hpp>
15 #include <boost/random/variate_generator.hpp>
17 #include <boost/pending/property.hpp>
18 #include <boost/graph/properties.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>
29 // grab a random vertex from the graph's vertex set
30 template <class Graph, class RandomNumGen>
31 typename graph_traits<Graph>::vertex_descriptor
32 random_vertex(Graph& g, RandomNumGen& gen)
34 if (num_vertices(g) > 1) {
35 #if BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581))
36 std::size_t n = std::random( num_vertices(g) );
38 uniform_int<> distrib(0, num_vertices(g)-1);
39 variate_generator<RandomNumGen&, uniform_int<> > rand_gen(gen, distrib);
40 std::size_t n = rand_gen();
42 typename graph_traits<Graph>::vertex_iterator
43 i = vertices(g).first;
44 while (n-- > 0) ++i; // std::advance not VC++ portable
47 return *vertices(g).first;
50 template <class Graph, class RandomNumGen>
51 typename graph_traits<Graph>::edge_descriptor
52 random_edge(Graph& g, RandomNumGen& gen) {
53 if (num_edges(g) > 1) {
54 #if BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581))
55 typename graph_traits<Graph>::edges_size_type
56 n = std::random( num_edges(g) );
58 uniform_int<> distrib(0, num_edges(g)-1);
59 variate_generator<RandomNumGen&, uniform_int<> > rand_gen(gen, distrib);
60 typename graph_traits<Graph>::edges_size_type
63 typename graph_traits<Graph>::edge_iterator
65 while (n-- > 0) ++i; // std::advance not VC++ portable
68 return *edges(g).first;
72 class dummy_property_copier {
74 template<class V1, class V2>
75 void operator()(const V1&, const V2&) const {}
79 template <typename MutableGraph, class RandNumGen>
80 void generate_random_graph1
82 typename graph_traits<MutableGraph>::vertices_size_type V,
83 typename graph_traits<MutableGraph>::vertices_size_type E,
85 bool allow_parallel = true,
86 bool self_edges = false)
88 typedef graph_traits<MutableGraph> Traits;
89 typedef typename Traits::vertices_size_type v_size_t;
90 typedef typename Traits::edges_size_type e_size_t;
91 typedef typename Traits::vertex_descriptor vertex_descriptor;
93 // When parallel edges are not allowed, we create a new graph which
94 // does not allow parallel edges, construct it and copy back.
95 // This is not efficient if 'g' already disallow parallel edges,
96 // but that's task for later.
97 if (!allow_parallel) {
99 typedef typename boost::graph_traits<MutableGraph>::directed_category dir;
100 typedef typename mpl::if_<is_convertible<dir, directed_tag>,
101 directedS, undirectedS>::type select;
102 adjacency_list<setS, vecS, select> g2;
103 generate_random_graph1(g2, V, E, gen, true, self_edges);
105 copy_graph(g2, g, vertex_copy(detail::dummy_property_copier()).
106 edge_copy(detail::dummy_property_copier()));
110 for (v_size_t i = 0; i < V; ++i)
113 for (e_size_t j = 0; j < E; ++j) {
114 vertex_descriptor a = random_vertex(g, gen), b;
116 b = random_vertex(g, gen);
117 } while (self_edges == false && a == b);
123 template <typename MutableGraph, class RandNumGen>
124 void generate_random_graph
126 typename graph_traits<MutableGraph>::vertices_size_type V,
127 typename graph_traits<MutableGraph>::vertices_size_type E,
129 bool allow_parallel = true,
130 bool self_edges = false)
132 generate_random_graph1(g, V, E, gen, allow_parallel, self_edges);
135 template <typename MutableGraph, typename RandNumGen,
136 typename VertexOutputIterator, typename EdgeOutputIterator>
137 void generate_random_graph
139 typename graph_traits<MutableGraph>::vertices_size_type V,
140 typename graph_traits<MutableGraph>::vertices_size_type E,
142 VertexOutputIterator vertex_out,
143 EdgeOutputIterator edge_out,
144 bool self_edges = false)
146 typedef graph_traits<MutableGraph> Traits;
147 typedef typename Traits::vertices_size_type v_size_t;
148 typedef typename Traits::edges_size_type e_size_t;
149 typedef typename Traits::vertex_descriptor vertex_t;
150 typedef typename Traits::edge_descriptor edge_t;
152 for (v_size_t i = 0; i < V; ++i)
153 *vertex_out++ = add_vertex(g);
155 for (e_size_t j = 0; j < E; ++j) {
156 vertex_t a = random_vertex(g, gen), b;
158 b = random_vertex(g, gen);
159 } while (self_edges == false && a == b);
160 edge_t e; bool inserted;
161 tie(e, inserted) = add_edge(a, b, g);
163 *edge_out++ = std::make_pair(source(e, g), target(e, g));
169 template<class Property, class G, class RandomGenerator>
170 void randomize_property(G& g, RandomGenerator& rg,
171 Property, vertex_property_tag)
173 typename property_map<G, Property>::type pm = get(Property(), g);
174 typename graph_traits<G>::vertex_iterator vi, ve;
175 for (tie(vi, ve) = vertices(g); vi != ve; ++vi) {
180 template<class Property, class G, class RandomGenerator>
181 void randomize_property(G& g, RandomGenerator& rg,
182 Property, edge_property_tag)
184 typename property_map<G, Property>::type pm = get(Property(), g);
185 typename graph_traits<G>::edge_iterator ei, ee;
186 for (tie(ei, ee) = edges(g); ei != ee; ++ei) {
192 template<class Property, class G, class RandomGenerator>
193 void randomize_property(G& g, RandomGenerator& rg)
195 detail::randomize_property
196 (g, rg, Property(), typename property_kind<Property>::type());