FM / graph

/usr/include/boost/graph

Name	Size	Mode	Actions
detail/	-	0755	rm
distributed/	-	0755	rm
parallel/	-	0755	rm
planar_detail/	-	0755	rm
property_maps/	-	0755	rm
accounting.hpp	876	0644	edit dl rm
adjacency_iterator.hpp	2899	0644	edit dl rm
adjacency_list.hpp	13692	0644	edit dl rm
adjacency_list_io.hpp	11849	0644	edit dl rm
adjacency_matrix.hpp	45743	0644	edit dl rm
adj_list_serialize.hpp	4523	0644	edit dl rm
astar_search.hpp	26736	0644	edit dl rm
bandwidth.hpp	2992	0644	edit dl rm
bc_clustering.hpp	5937	0644	edit dl rm
bellman_ford_shortest_paths.hpp	8229	0644	edit dl rm
betweenness_centrality.hpp	26290	0644	edit dl rm
biconnected_components.hpp	16701	0644	edit dl rm
bipartite.hpp	13492	0644	edit dl rm
boyer_myrvold_planar_test.hpp	9849	0644	edit dl rm
boykov_kolmogorov_max_flow.hpp	47342	0644	edit dl rm
breadth_first_search.hpp	14751	0644	edit dl rm
bron_kerbosch_all_cliques.hpp	11736	0644	edit dl rm
buffer_concepts.hpp	2429	0644	edit dl rm
chrobak_payne_drawing.hpp	8641	0644	edit dl rm
circle_layout.hpp	1924	0644	edit dl rm
closeness_centrality.hpp	6057	0644	edit dl rm
clustering_coefficient.hpp	5726	0644	edit dl rm
compressed_sparse_row_graph.hpp	69887	0644	edit dl rm
connected_components.hpp	4134	0644	edit dl rm
copy.hpp	21225	0644	edit dl rm
core_numbers.hpp	13663	0644	edit dl rm
create_condensation_graph.hpp	3159	0644	edit dl rm
cuthill_mckee_ordering.hpp	5992	0644	edit dl rm
cycle_canceling.hpp	6645	0644	edit dl rm
dag_shortest_paths.hpp	6064	0644	edit dl rm
degree_centrality.hpp	4236	0644	edit dl rm
depth_first_search.hpp	15430	0644	edit dl rm
dijkstra_shortest_paths.hpp	23687	0644	edit dl rm
dijkstra_shortest_paths_no_color_map.hpp	9620	0644	edit dl rm
dimacs.hpp	10448	0644	edit dl rm
directed_graph.hpp	24214	0644	edit dl rm
dll_import_export.hpp	892	0644	edit dl rm
dominator_tree.hpp	17553	0644	edit dl rm
eccentricity.hpp	4611	0644	edit dl rm
edge_coloring.hpp	6809	0644	edit dl rm
edge_connectivity.hpp	6796	0644	edit dl rm
edge_list.hpp	9948	0644	edit dl rm
edmonds_karp_max_flow.hpp	10177	0644	edit dl rm
edmunds_karp_max_flow.hpp	982	0644	edit dl rm
erdos_renyi_generator.hpp	7257	0644	edit dl rm
exception.hpp	1466	0644	edit dl rm
exterior_property.hpp	4289	0644	edit dl rm
filtered_graph.hpp	20098	0644	edit dl rm
find_flow_cost.hpp	1859	0644	edit dl rm
floyd_warshall_shortest.hpp	8510	0644	edit dl rm
fruchterman_reingold.hpp	17325	0644	edit dl rm
geodesic_distance.hpp	8015	0644	edit dl rm
graphml.hpp	13460	0644	edit dl rm
graphviz.hpp	33503	0644	edit dl rm
graph_archetypes.hpp	11008	0644	edit dl rm
graph_as_tree.hpp	4532	0644	edit dl rm
graph_concepts.hpp	19785	0644	edit dl rm
graph_mutability_traits.hpp	4995	0644	edit dl rm
graph_selectors.hpp	1274	0644	edit dl rm
graph_stats.hpp	4394	0644	edit dl rm
graph_traits.hpp	13065	0644	edit dl rm
graph_utility.hpp	16182	0644	edit dl rm
grid_graph.hpp	33830	0644	edit dl rm
gursoy_atun_layout.hpp	13248	0644	edit dl rm
hawick_circuits.hpp	14593	0644	edit dl rm
howard_cycle_ratio.hpp	23107	0644	edit dl rm
incremental_components.hpp	8224	0644	edit dl rm
isomorphism.hpp	26308	0644	edit dl rm
is_kuratowski_subgraph.hpp	10260	0644	edit dl rm
is_straight_line_drawing.hpp	7230	0644	edit dl rm
iteration_macros.hpp	11659	0644	edit dl rm
iteration_macros_undef.hpp	673	0644	edit dl rm
johnson_all_pairs_shortest.hpp	7646	0644	edit dl rm
kamada_kawai_spring_layout.hpp	28048	0644	edit dl rm
king_ordering.hpp	12101	0644	edit dl rm
kruskal_min_spanning_tree.hpp	5743	0644	edit dl rm
labeled_graph.hpp	30914	0644	edit dl rm
leda_graph.hpp	28789	0644	edit dl rm
lookup_edge.hpp	1894	0644	edit dl rm
loop_erased_random_walk.hpp	4436	0644	edit dl rm
make_biconnected_planar.hpp	3513	0644	edit dl rm
make_connected.hpp	2645	0644	edit dl rm
make_maximal_planar.hpp	7578	0644	edit dl rm
matrix_as_graph.hpp	7227	0644	edit dl rm
maximum_adjacency_search.hpp	15125	0644	edit dl rm
maximum_weighted_matching.hpp	49722	0644	edit dl rm
max_cardinality_matching.hpp	31000	0644	edit dl rm
mcgregor_common_subgraphs.hpp	43470	0644	edit dl rm
mesh_graph_generator.hpp	5616	0644	edit dl rm
metis.hpp	10982	0644	edit dl rm
metric_tsp_approx.hpp	10809	0644	edit dl rm
minimum_degree_ordering.hpp	27087	0644	edit dl rm
named_function_params.hpp	39639	0644	edit dl rm
named_graph.hpp	20614	0644	edit dl rm
neighbor_bfs.hpp	11763	0644	edit dl rm
numeric_values.hpp	1814	0644	edit dl rm
one_bit_color_map.hpp	3277	0644	edit dl rm
overloading.hpp	1584	0644	edit dl rm
page_rank.hpp	6164	0644	edit dl rm
planar_canonical_ordering.hpp	7203	0644	edit dl rm
planar_face_traversal.hpp	6020	0644	edit dl rm
plod_generator.hpp	7708	0644	edit dl rm
point_traits.hpp	782	0644	edit dl rm
prim_minimum_spanning_tree.hpp	2960	0644	edit dl rm
profile.hpp	1327	0644	edit dl rm
properties.hpp	12417	0644	edit dl rm
property_iter_range.hpp	4345	0644	edit dl rm
push_relabel_max_flow.hpp	34737	0644	edit dl rm
random.hpp	9672	0644	edit dl rm
random_layout.hpp	988	0644	edit dl rm
random_spanning_tree.hpp	5775	0644	edit dl rm
read_dimacs.hpp	12080	0644	edit dl rm
relax.hpp	4400	0644	edit dl rm
reverse_graph.hpp	22402	0644	edit dl rm
rmat_graph_generator.hpp	19291	0644	edit dl rm
r_c_shortest_paths.hpp	30673	0644	edit dl rm
sequential_vertex_coloring.hpp	4562	0644	edit dl rm
simple_point.hpp	628	0644	edit dl rm
sloan_ordering.hpp	15540	0644	edit dl rm
smallest_last_ordering.hpp	5458	0644	edit dl rm
small_world_generator.hpp	3670	0644	edit dl rm
ssca_graph_generator.hpp	6564	0644	edit dl rm
stanford_graph.hpp	20126	0644	edit dl rm
stoer_wagner_min_cut.hpp	12415	0644	edit dl rm
strong_components.hpp	13009	0644	edit dl rm
st_connected.hpp	2852	0644	edit dl rm
subgraph.hpp	39996	0644	edit dl rm
successive_shortest_path_nonnegative_weights.hpp	10413	0644	edit dl rm
tiernan_all_cycles.hpp	12547	0644	edit dl rm
topological_sort.hpp	2611	0644	edit dl rm
topology.hpp	20389	0644	edit dl rm
transitive_closure.hpp	14260	0644	edit dl rm
transitive_reduction.hpp	5326	0644	edit dl rm
transpose_graph.hpp	1198	0644	edit dl rm
tree_traits.hpp	1338	0644	edit dl rm
two_bit_color_map.hpp	3510	0644	edit dl rm
two_graphs_common_spanning_trees.hpp	34996	0644	edit dl rm
undirected_dfs.hpp	10672	0644	edit dl rm
undirected_graph.hpp	25276	0644	edit dl rm
use_mpi.hpp	437	0644	edit dl rm
vector_as_graph.hpp	10474	0644	edit dl rm
vertex_and_edge_range.hpp	5528	0644	edit dl rm
vf2_sub_graph_iso.hpp	48585	0644	edit dl rm
visitors.hpp	11318	0644	edit dl rm
wavefront.hpp	3932	0644	edit dl rm
write_dimacs.hpp	2889	0644	edit dl rm

Edit: /usr/include/boost/graph/rmat_graph_generator.hpp (19291B)

// Use, modification and distribution is subject to 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: Nick Edmonds
//           Andrew Lumsdaine
#ifndef BOOST_GRAPH_RMAT_GENERATOR_HPP
#define BOOST_GRAPH_RMAT_GENERATOR_HPP

#include <math.h>
#include <iterator>
#include <utility>
#include <vector>
#include <queue>
#include <map>
#include <boost/shared_ptr.hpp>
#include <boost/assert.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/random/uniform_01.hpp>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/detail/mpi_include.hpp>
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/type_traits/is_same.hpp>
// #include <boost/test/floating_point_comparison.hpp>

using boost::shared_ptr;
using boost::uniform_01;

// Returns floor(log_2(n)), and -1 when n is 0
template < typename IntegerType > inline int int_log2(IntegerType n)
{
    int l = 0;
    while (n > 0)
    {
        ++l;
        n >>= 1;
    }
    return l - 1;
}

struct keep_all_edges
{
    template < typename T > bool operator()(const T&, const T&) { return true; }
};

template < typename Distribution, typename ProcessId > struct keep_local_edges
{

keep_local_edges(const Distribution& distrib, const ProcessId& id)
    : distrib(distrib), id(id)
    {
    }

template < typename T > bool operator()(const T& x, const T& y)
    {
        return distrib(x) == id || distrib(y) == id;
    }

private:
    const Distribution& distrib;
    const ProcessId& id;
};

template < typename RandomGenerator, typename T >
void generate_permutation_vector(
    RandomGenerator& gen, std::vector< T >& vertexPermutation, T n)
{
    using boost::uniform_int;

vertexPermutation.resize(n);

// Generate permutation map of vertex numbers
    uniform_int< T > rand_vertex(0, n - 1);
    for (T i = 0; i < n; ++i)
        vertexPermutation[i] = i;

// Can't use std::random_shuffle unless we create another (synchronized)
    // PRNG
    for (T i = 0; i < n; ++i)
        std::swap(vertexPermutation[i], vertexPermutation[rand_vertex(gen)]);
}

template < typename RandomGenerator, typename T >
std::pair< T, T > generate_edge(
    shared_ptr< uniform_01< RandomGenerator > > prob, T n, unsigned int SCALE,
    double a, double b, double c, double d)
{
    T u = 0, v = 0;
    T step = n / 2;
    for (unsigned int j = 0; j < SCALE; ++j)
    {
        double p = (*prob)();

if (p < a)
            ;
        else if (p >= a && p < a + b)
            v += step;
        else if (p >= a + b && p < a + b + c)
            u += step;
        else
        { // p > a + b + c && p < a + b + c + d
            u += step;
            v += step;
        }

step /= 2;

// 0.2 and 0.9 are hardcoded in the reference SSCA implementation.
        // The maximum change in any given value should be less than 10%
        a *= 0.9 + 0.2 * (*prob)();
        b *= 0.9 + 0.2 * (*prob)();
        c *= 0.9 + 0.2 * (*prob)();
        d *= 0.9 + 0.2 * (*prob)();

double S = a + b + c + d;

a /= S;
        b /= S;
        c /= S;
        // d /= S;
        // Ensure all values add up to 1, regardless of floating point errors
        d = 1. - a - b - c;
    }

return std::make_pair(u, v);
}

namespace boost
{

/*
  Chakrabarti's R-MAT scale free generator.

For all flavors of the R-MAT iterator a+b+c+d must equal 1 and for the
  unique_rmat_iterator 'm' << 'n^2'.  If 'm' is too close to 'n^2' the
  generator may be unable to generate sufficient unique edges

To get a true scale free distribution {a, b, c, d : a > b, a > c, a > d}
*/

template < typename RandomGenerator, typename Graph > class rmat_iterator
{
    typedef typename graph_traits< Graph >::directed_category directed_category;
    typedef
        typename graph_traits< Graph >::vertices_size_type vertices_size_type;
    typedef typename graph_traits< Graph >::edges_size_type edges_size_type;

public:
    typedef std::input_iterator_tag iterator_category;
    typedef std::pair< vertices_size_type, vertices_size_type > value_type;
    typedef const value_type& reference;
    typedef const value_type* pointer;
    typedef std::ptrdiff_t difference_type; // Not used

// No argument constructor, set to terminating condition
    rmat_iterator() : gen(), edge(0) {}

// Initialize for edge generation
    rmat_iterator(RandomGenerator& gen, vertices_size_type n, edges_size_type m,
        double a, double b, double c, double d, bool permute_vertices = true)
    : gen()
    , n(n)
    , a(a)
    , b(b)
    , c(c)
    , d(d)
    , edge(m)
    , permute_vertices(permute_vertices)
    , SCALE(int_log2(n))

{
        this->gen.reset(new uniform_01< RandomGenerator >(gen));

// BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c +
        // d, 1., 1.e-5));

if (permute_vertices)
            generate_permutation_vector(gen, vertexPermutation, n);

// TODO: Generate the entire adjacency matrix then "Clip and flip" if
        // undirected graph

// Generate the first edge
        vertices_size_type u, v;
        boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);

if (permute_vertices)
            current
                = std::make_pair(vertexPermutation[u], vertexPermutation[v]);
        else
            current = std::make_pair(u, v);

--edge;
    }

reference operator*() const { return current; }
    pointer operator->() const { return &current; }

rmat_iterator& operator++()
    {
        vertices_size_type u, v;
        boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);

if (permute_vertices)
            current
                = std::make_pair(vertexPermutation[u], vertexPermutation[v]);
        else
            current = std::make_pair(u, v);

--edge;

return *this;
    }

rmat_iterator operator++(int)
    {
        rmat_iterator temp(*this);
        ++(*this);
        return temp;
    }

bool operator==(const rmat_iterator& other) const
    {
        return edge == other.edge;
    }

bool operator!=(const rmat_iterator& other) const
    {
        return !(*this == other);
    }

private:
    // Parameters
    shared_ptr< uniform_01< RandomGenerator > > gen;
    vertices_size_type n;
    double a, b, c, d;
    int edge;
    bool permute_vertices;
    int SCALE;

// Internal data structures
    std::vector< vertices_size_type > vertexPermutation;
    value_type current;
};

// Sorted version for CSR
template < typename T > struct sort_pair
{
    bool operator()(const std::pair< T, T >& x, const std::pair< T, T >& y)
    {
        if (x.first == y.first)
            return x.second > y.second;
        else
            return x.first > y.first;
    }
};

template < typename RandomGenerator, typename Graph,
    typename EdgePredicate = keep_all_edges >
class sorted_rmat_iterator
{
    typedef typename graph_traits< Graph >::directed_category directed_category;
    typedef
        typename graph_traits< Graph >::vertices_size_type vertices_size_type;
    typedef typename graph_traits< Graph >::edges_size_type edges_size_type;

// No argument constructor, set to terminating condition
    sorted_rmat_iterator()
    : gen(), values(sort_pair< vertices_size_type >()), done(true)
    {
    }

// Initialize for edge generation
    sorted_rmat_iterator(RandomGenerator& gen, vertices_size_type n,
        edges_size_type m, double a, double b, double c, double d,
        bool permute_vertices = true, EdgePredicate ep = keep_all_edges())
    : gen()
    , permute_vertices(permute_vertices)
    , values(sort_pair< vertices_size_type >())
    , done(false)

{
        // BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c +
        // d, 1., 1.e-5));

this->gen.reset(new uniform_01< RandomGenerator >(gen));

std::vector< vertices_size_type > vertexPermutation;
        if (permute_vertices)
            generate_permutation_vector(gen, vertexPermutation, n);

// TODO: "Clip and flip" if undirected graph
        int SCALE = int_log2(n);

for (edges_size_type i = 0; i < m; ++i)
        {

vertices_size_type u, v;
            boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);

if (permute_vertices)
            {
                if (ep(vertexPermutation[u], vertexPermutation[v]))
                    values.push(std::make_pair(
                        vertexPermutation[u], vertexPermutation[v]));
            }
            else
            {
                if (ep(u, v))
                    values.push(std::make_pair(u, v));
            }
        }

current = values.top();
        values.pop();
    }

reference operator*() const { return current; }
    pointer operator->() const { return &current; }

sorted_rmat_iterator& operator++()
    {
        if (!values.empty())
        {
            current = values.top();
            values.pop();
        }
        else
            done = true;

return *this;
    }

sorted_rmat_iterator operator++(int)
    {
        sorted_rmat_iterator temp(*this);
        ++(*this);
        return temp;
    }

bool operator==(const sorted_rmat_iterator& other) const
    {
        return values.empty() && other.values.empty() && done && other.done;
    }

bool operator!=(const sorted_rmat_iterator& other) const
    {
        return !(*this == other);
    }

private:
    // Parameters
    shared_ptr< uniform_01< RandomGenerator > > gen;
    bool permute_vertices;

// Internal data structures
    std::priority_queue< value_type, std::vector< value_type >,
        sort_pair< vertices_size_type > >
        values;
    value_type current;
    bool done;
};

// This version is slow but guarantees unique edges
template < typename RandomGenerator, typename Graph,
    typename EdgePredicate = keep_all_edges >
class unique_rmat_iterator
{
    typedef typename graph_traits< Graph >::directed_category directed_category;
    typedef
        typename graph_traits< Graph >::vertices_size_type vertices_size_type;
    typedef typename graph_traits< Graph >::edges_size_type edges_size_type;

// No argument constructor, set to terminating condition
    unique_rmat_iterator() : gen(), done(true) {}

// Initialize for edge generation
    unique_rmat_iterator(RandomGenerator& gen, vertices_size_type n,
        edges_size_type m, double a, double b, double c, double d,
        bool permute_vertices = true, EdgePredicate ep = keep_all_edges())
    : gen(), done(false)

{
        // BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c +
        // d, 1., 1.e-5));

this->gen.reset(new uniform_01< RandomGenerator >(gen));

std::vector< vertices_size_type > vertexPermutation;
        if (permute_vertices)
            generate_permutation_vector(gen, vertexPermutation, n);

int SCALE = int_log2(n);

std::map< value_type, bool > edge_map;

edges_size_type edges = 0;
        do
        {
            vertices_size_type u, v;
            boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);

// Lowest vertex number always comes first
            // (this means we don't have to worry about i->j and j->i being in
            // the edge list)
            if (u > v && is_same< directed_category, undirected_tag >::value)
                std::swap(u, v);

if (edge_map.find(std::make_pair(u, v)) == edge_map.end())
            {
                edge_map[std::make_pair(u, v)] = true;

if (permute_vertices)
                {
                    if (ep(vertexPermutation[u], vertexPermutation[v]))
                        values.push_back(std::make_pair(
                            vertexPermutation[u], vertexPermutation[v]));
                }
                else
                {
                    if (ep(u, v))
                        values.push_back(std::make_pair(u, v));
                }

edges++;
            }
        } while (edges < m);
        // NGE - Asking for more than n^2 edges will result in an infinite loop
        // here
        //       Asking for a value too close to n^2 edges may as well

current = values.back();
        values.pop_back();
    }

reference operator*() const { return current; }
    pointer operator->() const { return &current; }

unique_rmat_iterator& operator++()
    {
        if (!values.empty())
        {
            current = values.back();
            values.pop_back();
        }
        else
            done = true;

return *this;
    }

unique_rmat_iterator operator++(int)
    {
        unique_rmat_iterator temp(*this);
        ++(*this);
        return temp;
    }

bool operator==(const unique_rmat_iterator& other) const
    {
        return values.empty() && other.values.empty() && done && other.done;
    }

bool operator!=(const unique_rmat_iterator& other) const
    {
        return !(*this == other);
    }

private:
    // Parameters
    shared_ptr< uniform_01< RandomGenerator > > gen;

// Internal data structures
    std::vector< value_type > values;
    value_type current;
    bool done;
};

// This version is slow but guarantees unique edges
template < typename RandomGenerator, typename Graph,
    typename EdgePredicate = keep_all_edges >
class sorted_unique_rmat_iterator
{
    typedef typename graph_traits< Graph >::directed_category directed_category;
    typedef
        typename graph_traits< Graph >::vertices_size_type vertices_size_type;
    typedef typename graph_traits< Graph >::edges_size_type edges_size_type;

// No argument constructor, set to terminating condition
    sorted_unique_rmat_iterator()
    : gen(), values(sort_pair< vertices_size_type >()), done(true)
    {
    }

// Initialize for edge generation
    sorted_unique_rmat_iterator(RandomGenerator& gen, vertices_size_type n,
        edges_size_type m, double a, double b, double c, double d,
        bool bidirectional = false, bool permute_vertices = true,
        EdgePredicate ep = keep_all_edges())
    : gen()
    , bidirectional(bidirectional)
    , values(sort_pair< vertices_size_type >())
    , done(false)

{
        // BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c +
        // d, 1., 1.e-5));

this->gen.reset(new uniform_01< RandomGenerator >(gen));

std::vector< vertices_size_type > vertexPermutation;
        if (permute_vertices)
            generate_permutation_vector(gen, vertexPermutation, n);

int SCALE = int_log2(n);

std::map< value_type, bool > edge_map;

edges_size_type edges = 0;
        do
        {

vertices_size_type u, v;
            boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);

if (bidirectional)
            {
                if (edge_map.find(std::make_pair(u, v)) == edge_map.end())
                {
                    edge_map[std::make_pair(u, v)] = true;
                    edge_map[std::make_pair(v, u)] = true;

if (ep(u, v))
                    {
                        if (permute_vertices)
                        {
                            values.push(std::make_pair(
                                vertexPermutation[u], vertexPermutation[v]));
                            values.push(std::make_pair(
                                vertexPermutation[v], vertexPermutation[u]));
                        }
                        else
                        {
                            values.push(std::make_pair(u, v));
                            values.push(std::make_pair(v, u));
                        }
                    }

++edges;
                }
            }
            else
            {
                // Lowest vertex number always comes first
                // (this means we don't have to worry about i->j and j->i being
                // in the edge list)
                if (u > v
                    && is_same< directed_category, undirected_tag >::value)
                    std::swap(u, v);

if (edge_map.find(std::make_pair(u, v)) == edge_map.end())
                {
                    edge_map[std::make_pair(u, v)] = true;

if (permute_vertices)
                    {
                        if (ep(vertexPermutation[u], vertexPermutation[v]))
                            values.push(std::make_pair(
                                vertexPermutation[u], vertexPermutation[v]));
                    }
                    else
                    {
                        if (ep(u, v))
                            values.push(std::make_pair(u, v));
                    }

++edges;
                }
            }

} while (edges < m);
        // NGE - Asking for more than n^2 edges will result in an infinite loop
        // here
        //       Asking for a value too close to n^2 edges may as well

current = values.top();
        values.pop();
    }

reference operator*() const { return current; }
    pointer operator->() const { return &current; }

sorted_unique_rmat_iterator& operator++()
    {
        if (!values.empty())
        {
            current = values.top();
            values.pop();
        }
        else
            done = true;

return *this;
    }

sorted_unique_rmat_iterator operator++(int)
    {
        sorted_unique_rmat_iterator temp(*this);
        ++(*this);
        return temp;
    }

bool operator==(const sorted_unique_rmat_iterator& other) const
    {
        return values.empty() && other.values.empty() && done && other.done;
    }

bool operator!=(const sorted_unique_rmat_iterator& other) const
    {
        return !(*this == other);
    }

private:
    // Parameters
    shared_ptr< uniform_01< RandomGenerator > > gen;
    bool bidirectional;

// Internal data structures
    std::priority_queue< value_type, std::vector< value_type >,
        sort_pair< vertices_size_type > >
        values;
    value_type current;
    bool done;
};

} // end namespace boost

#include BOOST_GRAPH_MPI_INCLUDE(<boost/graph/distributed/rmat_graph_generator.hpp>)

#endif // BOOST_GRAPH_RMAT_GENERATOR_HPP

// Copyright 2004, 2005 The Trustees of Indiana University. // Use, modification and distribution is subject to 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: Nick Edmonds // Andrew Lumsdaine #ifndef BOOST_GRAPH_RMAT_GENERATOR_HPP #define BOOST_GRAPH_RMAT_GENERATOR_HPP #include #include #include #include #include #include #include #include #include #include #include #include #include #include // #include using boost::shared_ptr; using boost::uniform_01; // Returns floor(log_2(n)), and -1 when n is 0 template < typename IntegerType > inline int int_log2(IntegerType n) { int l = 0; while (n > 0) { ++l; n >>= 1; } return l - 1; } struct keep_all_edges { template < typename T > bool operator()(const T&, const T&) { return true; } }; template < typename Distribution, typename ProcessId > struct keep_local_edges { keep_local_edges(const Distribution& distrib, const ProcessId& id) : distrib(distrib), id(id) { } template < typename T > bool operator()(const T& x, const T& y) { return distrib(x) == id || distrib(y) == id; } private: const Distribution& distrib; const ProcessId& id; }; template < typename RandomGenerator, typename T > void generate_permutation_vector( RandomGenerator& gen, std::vector< T >& vertexPermutation, T n) { using boost::uniform_int; vertexPermutation.resize(n); // Generate permutation map of vertex numbers uniform_int< T > rand_vertex(0, n - 1); for (T i = 0; i < n; ++i) vertexPermutation[i] = i; // Can't use std::random_shuffle unless we create another (synchronized) // PRNG for (T i = 0; i < n; ++i) std::swap(vertexPermutation[i], vertexPermutation[rand_vertex(gen)]); } template < typename RandomGenerator, typename T > std::pair< T, T > generate_edge( shared_ptr< uniform_01< RandomGenerator > > prob, T n, unsigned int SCALE, double a, double b, double c, double d) { T u = 0, v = 0; T step = n / 2; for (unsigned int j = 0; j < SCALE; ++j) { double p = (*prob)(); if (p < a) ; else if (p >= a && p < a + b) v += step; else if (p >= a + b && p < a + b + c) u += step; else { // p > a + b + c && p < a + b + c + d u += step; v += step; } step /= 2; // 0.2 and 0.9 are hardcoded in the reference SSCA implementation. // The maximum change in any given value should be less than 10% a *= 0.9 + 0.2 * (*prob)(); b *= 0.9 + 0.2 * (*prob)(); c *= 0.9 + 0.2 * (*prob)(); d *= 0.9 + 0.2 * (*prob)(); double S = a + b + c + d; a /= S; b /= S; c /= S; // d /= S; // Ensure all values add up to 1, regardless of floating point errors d = 1. - a - b - c; } return std::make_pair(u, v); } namespace boost { /* Chakrabarti's R-MAT scale free generator. For all flavors of the R-MAT iterator a+b+c+d must equal 1 and for the unique_rmat_iterator 'm' << 'n^2'. If 'm' is too close to 'n^2' the generator may be unable to generate sufficient unique edges To get a true scale free distribution {a, b, c, d : a > b, a > c, a > d} */ template < typename RandomGenerator, typename Graph > class rmat_iterator { typedef typename graph_traits< Graph >::directed_category directed_category; typedef typename graph_traits< Graph >::vertices_size_type vertices_size_type; typedef typename graph_traits< Graph >::edges_size_type edges_size_type; public: typedef std::input_iterator_tag iterator_category; typedef std::pair< vertices_size_type, vertices_size_type > value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef std::ptrdiff_t difference_type; // Not used // No argument constructor, set to terminating condition rmat_iterator() : gen(), edge(0) {} // Initialize for edge generation rmat_iterator(RandomGenerator& gen, vertices_size_type n, edges_size_type m, double a, double b, double c, double d, bool permute_vertices = true) : gen() , n(n) , a(a) , b(b) , c(c) , d(d) , edge(m) , permute_vertices(permute_vertices) , SCALE(int_log2(n)) { this->gen.reset(new uniform_01< RandomGenerator >(gen)); // BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c + // d, 1., 1.e-5)); if (permute_vertices) generate_permutation_vector(gen, vertexPermutation, n); // TODO: Generate the entire adjacency matrix then "Clip and flip" if // undirected graph // Generate the first edge vertices_size_type u, v; boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d); if (permute_vertices) current = std::make_pair(vertexPermutation[u], vertexPermutation[v]); else current = std::make_pair(u, v); --edge; } reference operator*() const { return current; } pointer operator->() const { return ¤t; } rmat_iterator& operator++() { vertices_size_type u, v; boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d); if (permute_vertices) current = std::make_pair(vertexPermutation[u], vertexPermutation[v]); else current = std::make_pair(u, v); --edge; return *this; } rmat_iterator operator++(int) { rmat_iterator temp(*this); ++(*this); return temp; } bool operator==(const rmat_iterator& other) const { return edge == other.edge; } bool operator!=(const rmat_iterator& other) const { return !(*this == other); } private: // Parameters shared_ptr< uniform_01< RandomGenerator > > gen; vertices_size_type n; double a, b, c, d; int edge; bool permute_vertices; int SCALE; // Internal data structures std::vector< vertices_size_type > vertexPermutation; value_type current; }; // Sorted version for CSR template < typename T > struct sort_pair { bool operator()(const std::pair< T, T >& x, const std::pair< T, T >& y) { if (x.first == y.first) return x.second > y.second; else return x.first > y.first; } }; template < typename RandomGenerator, typename Graph, typename EdgePredicate = keep_all_edges > class sorted_rmat_iterator { typedef typename graph_traits< Graph >::directed_category directed_category; typedef typename graph_traits< Graph >::vertices_size_type vertices_size_type; typedef typename graph_traits< Graph >::edges_size_type edges_size_type; public: typedef std::input_iterator_tag iterator_category; typedef std::pair< vertices_size_type, vertices_size_type > value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef std::ptrdiff_t difference_type; // Not used // No argument constructor, set to terminating condition sorted_rmat_iterator() : gen(), values(sort_pair< vertices_size_type >()), done(true) { } // Initialize for edge generation sorted_rmat_iterator(RandomGenerator& gen, vertices_size_type n, edges_size_type m, double a, double b, double c, double d, bool permute_vertices = true, EdgePredicate ep = keep_all_edges()) : gen() , permute_vertices(permute_vertices) , values(sort_pair< vertices_size_type >()) , done(false) { // BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c + // d, 1., 1.e-5)); this->gen.reset(new uniform_01< RandomGenerator >(gen)); std::vector< vertices_size_type > vertexPermutation; if (permute_vertices) generate_permutation_vector(gen, vertexPermutation, n); // TODO: "Clip and flip" if undirected graph int SCALE = int_log2(n); for (edges_size_type i = 0; i < m; ++i) { vertices_size_type u, v; boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d); if (permute_vertices) { if (ep(vertexPermutation[u], vertexPermutation[v])) values.push(std::make_pair( vertexPermutation[u], vertexPermutation[v])); } else { if (ep(u, v)) values.push(std::make_pair(u, v)); } } current = values.top(); values.pop(); } reference operator*() const { return current; } pointer operator->() const { return ¤t; } sorted_rmat_iterator& operator++() { if (!values.empty()) { current = values.top(); values.pop(); } else done = true; return *this; } sorted_rmat_iterator operator++(int) { sorted_rmat_iterator temp(*this); ++(*this); return temp; } bool operator==(const sorted_rmat_iterator& other) const { return values.empty() && other.values.empty() && done && other.done; } bool operator!=(const sorted_rmat_iterator& other) const { return !(*this == other); } private: // Parameters shared_ptr< uniform_01< RandomGenerator > > gen; bool permute_vertices; // Internal data structures std::priority_queue< value_type, std::vector< value_type >, sort_pair< vertices_size_type > > values; value_type current; bool done; }; // This version is slow but guarantees unique edges template < typename RandomGenerator, typename Graph, typename EdgePredicate = keep_all_edges > class unique_rmat_iterator { typedef typename graph_traits< Graph >::directed_category directed_category; typedef typename graph_traits< Graph >::vertices_size_type vertices_size_type; typedef typename graph_traits< Graph >::edges_size_type edges_size_type; public: typedef std::input_iterator_tag iterator_category; typedef std::pair< vertices_size_type, vertices_size_type > value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef std::ptrdiff_t difference_type; // Not used // No argument constructor, set to terminating condition unique_rmat_iterator() : gen(), done(true) {} // Initialize for edge generation unique_rmat_iterator(RandomGenerator& gen, vertices_size_type n, edges_size_type m, double a, double b, double c, double d, bool permute_vertices = true, EdgePredicate ep = keep_all_edges()) : gen(), done(false) { // BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c + // d, 1., 1.e-5)); this->gen.reset(new uniform_01< RandomGenerator >(gen)); std::vector< vertices_size_type > vertexPermutation; if (permute_vertices) generate_permutation_vector(gen, vertexPermutation, n); int SCALE = int_log2(n); std::map< value_type, bool > edge_map; edges_size_type edges = 0; do { vertices_size_type u, v; boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d); // Lowest vertex number always comes first // (this means we don't have to worry about i->j and j->i being in // the edge list) if (u > v && is_same< directed_category, undirected_tag >::value) std::swap(u, v); if (edge_map.find(std::make_pair(u, v)) == edge_map.end()) { edge_map[std::make_pair(u, v)] = true; if (permute_vertices) { if (ep(vertexPermutation[u], vertexPermutation[v])) values.push_back(std::make_pair( vertexPermutation[u], vertexPermutation[v])); } else { if (ep(u, v)) values.push_back(std::make_pair(u, v)); } edges++; } } while (edges < m); // NGE - Asking for more than n^2 edges will result in an infinite loop // here // Asking for a value too close to n^2 edges may as well current = values.back(); values.pop_back(); } reference operator*() const { return current; } pointer operator->() const { return ¤t; } unique_rmat_iterator& operator++() { if (!values.empty()) { current = values.back(); values.pop_back(); } else done = true; return *this; } unique_rmat_iterator operator++(int) { unique_rmat_iterator temp(*this); ++(*this); return temp; } bool operator==(const unique_rmat_iterator& other) const { return values.empty() && other.values.empty() && done && other.done; } bool operator!=(const unique_rmat_iterator& other) const { return !(*this == other); } private: // Parameters shared_ptr< uniform_01< RandomGenerator > > gen; // Internal data structures std::vector< value_type > values; value_type current; bool done; }; // This version is slow but guarantees unique edges template < typename RandomGenerator, typename Graph, typename EdgePredicate = keep_all_edges > class sorted_unique_rmat_iterator { typedef typename graph_traits< Graph >::directed_category directed_category; typedef typename graph_traits< Graph >::vertices_size_type vertices_size_type; typedef typename graph_traits< Graph >::edges_size_type edges_size_type; public: typedef std::input_iterator_tag iterator_category; typedef std::pair< vertices_size_type, vertices_size_type > value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef std::ptrdiff_t difference_type; // Not used // No argument constructor, set to terminating condition sorted_unique_rmat_iterator() : gen(), values(sort_pair< vertices_size_type >()), done(true) { } // Initialize for edge generation sorted_unique_rmat_iterator(RandomGenerator& gen, vertices_size_type n, edges_size_type m, double a, double b, double c, double d, bool bidirectional = false, bool permute_vertices = true, EdgePredicate ep = keep_all_edges()) : gen() , bidirectional(bidirectional) , values(sort_pair< vertices_size_type >()) , done(false) { // BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c + // d, 1., 1.e-5)); this->gen.reset(new uniform_01< RandomGenerator >(gen)); std::vector< vertices_size_type > vertexPermutation; if (permute_vertices) generate_permutation_vector(gen, vertexPermutation, n); int SCALE = int_log2(n); std::map< value_type, bool > edge_map; edges_size_type edges = 0; do { vertices_size_type u, v; boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d); if (bidirectional) { if (edge_map.find(std::make_pair(u, v)) == edge_map.end()) { edge_map[std::make_pair(u, v)] = true; edge_map[std::make_pair(v, u)] = true; if (ep(u, v)) { if (permute_vertices) { values.push(std::make_pair( vertexPermutation[u], vertexPermutation[v])); values.push(std::make_pair( vertexPermutation[v], vertexPermutation[u])); } else { values.push(std::make_pair(u, v)); values.push(std::make_pair(v, u)); } } ++edges; } } else { // Lowest vertex number always comes first // (this means we don't have to worry about i->j and j->i being // in the edge list) if (u > v && is_same< directed_category, undirected_tag >::value) std::swap(u, v); if (edge_map.find(std::make_pair(u, v)) == edge_map.end()) { edge_map[std::make_pair(u, v)] = true; if (permute_vertices) { if (ep(vertexPermutation[u], vertexPermutation[v])) values.push(std::make_pair( vertexPermutation[u], vertexPermutation[v])); } else { if (ep(u, v)) values.push(std::make_pair(u, v)); } ++edges; } } } while (edges < m); // NGE - Asking for more than n^2 edges will result in an infinite loop // here // Asking for a value too close to n^2 edges may as well current = values.top(); values.pop(); } reference operator*() const { return current; } pointer operator->() const { return ¤t; } sorted_unique_rmat_iterator& operator++() { if (!values.empty()) { current = values.top(); values.pop(); } else done = true; return *this; } sorted_unique_rmat_iterator operator++(int) { sorted_unique_rmat_iterator temp(*this); ++(*this); return temp; } bool operator==(const sorted_unique_rmat_iterator& other) const { return values.empty() && other.values.empty() && done && other.done; } bool operator!=(const sorted_unique_rmat_iterator& other) const { return !(*this == other); } private: // Parameters shared_ptr< uniform_01< RandomGenerator > > gen; bool bidirectional; // Internal data structures std::priority_queue< value_type, std::vector< value_type >, sort_pair< vertices_size_type > > values; value_type current; bool done; }; } // end namespace boost #include BOOST_GRAPH_MPI_INCLUDE() #endif // BOOST_GRAPH_RMAT_GENERATOR_HPP