Attachment #396156 for bug #537042

View | Details | Raw Unified | Return to bug 537042
Collapse All | Expand All

Lines 56-62 get_triangles(typename graph_traits<Graph>::vertex_descriptor v, const Graph &g) Link Here

(-)a/src/graph/clustering/graph_clustering.hh (-1 / +1 lines)
56	typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;	56	typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
57		57
58	#ifdef HAVE_SPARSEHASH	58	#ifdef HAVE_SPARSEHASH
59	typedef dense_hash_set<vertex_t> set_t;	59	typedef dense_hash_set<vertex_t, std::hash<vertex_t>> set_t;
60	#else	60	#else
61	typedef unordered_set<vertex_t> set_t;	61	typedef unordered_set<vertex_t> set_t;
62	#endif	62	#endif

Lines 465-472 struct gen_graph Link Here

(-)a/src/graph/generation/graph_generation.hh (-2 / +1 lines)
465	set<deg_t, cmp_in<greater<size_t> > > targets;	465	set<deg_t, cmp_in<greater<size_t> > > targets;
466		466
467	// vertices with a given degree	467	// vertices with a given degree
468	unordered_map<deg_t, vector<size_t>,	468	unordered_map<deg_t, vector<size_t>> vset;
469	boost::hash<deg_t> > vset;
470		469
471	size_t num_e = 0;	470	size_t num_e = 0;
472	for (size_t i = 0; i < vertices.size(); ++i)	471	for (size_t i = 0; i < vertices.size(); ++i)

Lines 121-128 struct get_geometric Link Here

(-)a/src/graph/generation/graph_geometric.hh (-2 / +1 lines)
121	}	121	}
122		122
123	std::unordered_multimap<vector<int>,	123	std::unordered_multimap<vector<int>,
124	typename graph_traits<Graph>::vertex_descriptor,	124	typename graph_traits<Graph>::vertex_descriptor> boxes;
125	boost::hash<vector<int> > > boxes;
126		125
127	for (int i = 0; i < N; ++i)	126	for (int i = 0; i < N; ++i)
128	{	127	{




    rng_t& _rng;

#ifdef HAVE_SPARSEHASH
    typedef google::dense_hash_map<size_t, size_t, std::hash<size_t>> nmapv_t;
#else
    typedef unordered_map<size_t, size_t> nmapv_t;
#endif
    typedef typename property_map_type::apply<nmapv_t,
                                              typename property_map<Graph, vertex_index_t>::type>

#ifdef HAVE_SPARSEHASH
    typedef google::dense_hash_map<deg_t,
                                   vector<pair<size_t, bool>>,
                                   std::hash<deg_t>>
        edges_by_end_deg_t;
#else
    typedef std::unordered_map<deg_t,
                               vector<pair<size_t, bool>>>
                               boost::hash<deg_t>>
        edges_by_end_deg_t;
#endif



            if (_probs.empty())
            {
                std::unordered_set<deg_t> deg_set;
                for (size_t ei = 0; ei < base_t::_edges.size(); ++ei)
                {
                    edge_t& e = base_t::_edges[ei];


#ifdef HAVE_SPARSEHASH
    typedef google::dense_hash_map<pair<deg_t, deg_t>, double,
                                   std::hash<pair<deg_t, deg_t>>> prob_map_t;
#else
    typedef std::unordered_map<pair<deg_t, deg_t>, double> prob_map_t;
                               boost::hash<pair<deg_t, deg_t>>> prob_map_t;
#endif

    prob_map_t _probs;

    BlockDeg _blockdeg;

#ifdef HAVE_SPARSEHASH
    typedef google::dense_hash_map<deg_t, Sampler<deg_t, boost::mpl::false_>*,
                                   std::hash<deg_t>> sampler_map_t;
#else
    typedef std::unordered_map<deg_t, Sampler<deg_t, boost::mpl::false_>*> sampler_map_t;
#endif

    sampler_map_t _sampler;

#ifdef HAVE_SPARSEHASH
    typedef google::dense_hash_map<deg_t,
                                   google::dense_hash_map<deg_t, double,
                                                          std::hash<deg_t>>,
                                   std::hash<deg_t>> sprob_map_t;
#else
    typedef std::unordered_map<deg_t, std::unordered_map<deg_t, double>> sprob_map_t;
#endif



#ifdef HAVE_SPARSEHASH
    typedef google::dense_hash_map<pair<deg_t, deg_t>, double,
                                   std::hash<pair<deg_t, deg_t>>> prob_map_t;
#else
    typedef std::unordered_map<pair<deg_t, deg_t>, double> prob_map_t;
#endif

    prob_map_t _probs;

#ifdef HAVE_SPARSEHASH
    typedef google::dense_hash_map<deg_t, vector<size_t>,
                                   std::hash<deg_t>> edge_map_t;
#else
    typedef std::unordered_map<deg_t, vector<size_t>> edge_map_t;
#endif

            _vertices[d].push_back(*v);
        }

        std::unordered_map<pair<deg_t, deg_t>, double> probs;
            probs;
        _corr_prob.get_probs(probs);

        vector<double> dprobs;

    rng_t& _rng;

#ifdef HAVE_SPARSEHASH
    google::dense_hash_map<deg_t, vector<vertex_t>,
                           std::hash<deg_t>> _vertices;
#else
    std::unordered_map<deg_t, vector<vertex_t>> _vertices;
#endif

Lines 252-258 struct do_perfect_vhash Link Here

(-)a/src/graph/graph_properties.cc (-2 / +2 lines)
252	{	252	{
253	typedef typename property_traits<VertexPropertyMap>::value_type val_t;	253	typedef typename property_traits<VertexPropertyMap>::value_type val_t;
254	typedef typename property_traits<HashProp>::value_type hash_t;	254	typedef typename property_traits<HashProp>::value_type hash_t;
255	typedef unordered_map<val_t, hash_t, boost::hash<val_t>> dict_t;	255	typedef unordered_map<val_t, hash_t> dict_t;
256		256
257	if (adict.empty())	257	if (adict.empty())
258	adict = dict_t();	258	adict = dict_t();
Lines 291-297 struct do_perfect_ehash Link Here
291	{	291	{
292	typedef typename property_traits<EdgePropertyMap>::value_type val_t;	292	typedef typename property_traits<EdgePropertyMap>::value_type val_t;
293	typedef typename property_traits<HashProp>::value_type hash_t;	293	typedef typename property_traits<HashProp>::value_type hash_t;
294	typedef unordered_map<val_t, hash_t, boost::hash<val_t>> dict_t;	294	typedef unordered_map<val_t, hash_t> dict_t;
295		295
296	if (adict.empty())	296	if (adict.empty())
297	adict = dict_t();	297	adict = dict_t();

Lines 96-104 struct do_propagate_pos Link Here

(-)a/src/graph/layout/graph_sfdp.cc (-3 / +1 lines)
96	typedef typename pos_t::value_type val_t;	96	typedef typename pos_t::value_type val_t;
97		97
98	uniform_real_distribution<val_t> noise(-delta, delta);	98	uniform_real_distribution<val_t> noise(-delta, delta);
99	unordered_map<c_t, pos_t, boost::hash<c_t> >	99	unordered_map<c_t, pos_t> cmap(num_vertices(*cg));
100	cmap(num_vertices(*cg));
101
102		100
103	for (auto v : vertices_range(*cg))	101	for (auto v : vertices_range(*cg))
104	cmap[cvmap[v]] = cpos[v];	102	cmap[cvmap[v]] = cpos[v];

Lines 51-59 struct label_parallel_edges Link Here

(-)a/src/graph/stats/graph_parallel.hh (-2 / +2 lines)
51	continue;	51	continue;
52		52
53	#ifdef HAVE_SPARSEHASH	53	#ifdef HAVE_SPARSEHASH
54	google::dense_hash_map<vertex_t, edge_t> vset;	54	google::dense_hash_map<vertex_t, edge_t, std::hash<vertex_t>> vset;
55	vset.set_empty_key(graph_traits<Graph>::null_vertex());	55	vset.set_empty_key(graph_traits<Graph>::null_vertex());
56	google::dense_hash_map<size_t, bool> self_loops;	56	google::dense_hash_map<size_t, bool, std::hash<size_t>> self_loops;
57	self_loops.set_empty_key(numeric_limits<size_t>::max());	57	self_loops.set_empty_key(numeric_limits<size_t>::max());
58	#else	58	#else
59	unordered_map<vertex_t, edge_t> vset;	59	unordered_map<vertex_t, edge_t> vset;





        typedef typename property_traits<LabelMap>::value_type label_t;

        std::unordered_map<label_t, typename graph_traits<Graph1>::vertex_descriptor>
                           boost::hash<label_t>>
            lmap1;
        std::unordered_map<label_t, typename graph_traits<Graph2>::vertex_descriptor>
                           boost::hash<label_t>>
            lmap2;

        for (auto v : vertices_range(g1))

                continue;
            auto v2 = li2->second;

            std::unordered_set<label_t> keys;
            std::unordered_multiset<label_t> adj1;
            std::unordered_multiset<label_t> adj2;

            for (auto a1 : adjacent_vertices_range(v1, g1))
            {
- 

Return to bug 537042

Lines 527-535 protected: Link Here

(-)a/src/graph/generation/graph_rewiring.hh (-17 / +21 lines)
527	rng_t& _rng;	527	rng_t& _rng;
528		528
529	#ifdef HAVE_SPARSEHASH	529	#ifdef HAVE_SPARSEHASH
530	typedef google::dense_hash_map<size_t, size_t> nmapv_t;	530	typedef google::dense_hash_map<size_t, size_t, std::hash<size_t>> nmapv_t;
531	#else	531	#else
532	typedef unordered_map<size_t, size_t> nmapv_t;	532	typedef unordered_map<size_t, size_t> nmapv_t;
533	#endif	533	#endif
534	typedef typename property_map_type::apply<nmapv_t,	534	typedef typename property_map_type::apply<nmapv_t,
535	typename property_map<Graph, vertex_index_t>::type>	535	typename property_map<Graph, vertex_index_t>::type>
Lines 668-679 private: Link Here
668	#ifdef HAVE_SPARSEHASH	668	#ifdef HAVE_SPARSEHASH
669	typedef google::dense_hash_map<deg_t,	669	typedef google::dense_hash_map<deg_t,
670	vector<pair<size_t, bool>>,	670	vector<pair<size_t, bool>>,
671	boost::hash<deg_t>>	671	std::hash<deg_t>>
672	edges_by_end_deg_t;	672	edges_by_end_deg_t;
673	#else	673	#else
674	typedef std::unordered_map<deg_t,	674	typedef std::unordered_map<deg_t,
675	vector<pair<size_t, bool>>,	675	vector<pair<size_t, bool>>>
676	boost::hash<deg_t>>
677	edges_by_end_deg_t;	676	edges_by_end_deg_t;
678	#endif	677	#endif
679		678
Lines 724-730 public: Link Here
724		723
725	if (_probs.empty())	724	if (_probs.empty())
726	{	725	{
727	std::unordered_set<deg_t, boost::hash<deg_t> > deg_set;	726	std::unordered_set<deg_t> deg_set;
728	for (size_t ei = 0; ei < base_t::_edges.size(); ++ei)	727	for (size_t ei = 0; ei < base_t::_edges.size(); ++ei)
729	{	728	{
730	edge_t& e = base_t::_edges[ei];	729	edge_t& e = base_t::_edges[ei];
Lines 826-835 private: Link Here
826		825
827	#ifdef HAVE_SPARSEHASH	826	#ifdef HAVE_SPARSEHASH
828	typedef google::dense_hash_map<pair<deg_t, deg_t>, double,	827	typedef google::dense_hash_map<pair<deg_t, deg_t>, double,
829	boost::hash<pair<deg_t, deg_t>>> prob_map_t;	828	std::hash<pair<deg_t, deg_t>>> prob_map_t;
830	#else	829	#else
831	typedef std::unordered_map<pair<deg_t, deg_t>, double,	830	typedef std::unordered_map<pair<deg_t, deg_t>, double> prob_map_t;
832	boost::hash<pair<deg_t, deg_t>>> prob_map_t;
833	#endif	831	#endif
834		832
835	prob_map_t _probs;	833	prob_map_t _probs;
Lines 1185-1191 private: Link Here
1185	BlockDeg _blockdeg;	1183	BlockDeg _blockdeg;
1186		1184
1187	#ifdef HAVE_SPARSEHASH	1185	#ifdef HAVE_SPARSEHASH
1188	typedef google::dense_hash_map<deg_t, Sampler<deg_t, boost::mpl::false_>*> sampler_map_t;	1186	typedef google::dense_hash_map<deg_t, Sampler<deg_t, boost::mpl::false_>*,
		1187	std::hash<deg_t>> sampler_map_t;
1189	#else	1188	#else
1190	typedef std::unordered_map<deg_t, Sampler<deg_t, boost::mpl::false_>*> sampler_map_t;	1189	typedef std::unordered_map<deg_t, Sampler<deg_t, boost::mpl::false_>*> sampler_map_t;
1191	#endif	1190	#endif
Lines 1193-1199 private: Link Here
1193	sampler_map_t _sampler;	1192	sampler_map_t _sampler;
1194		1193
1195	#ifdef HAVE_SPARSEHASH	1194	#ifdef HAVE_SPARSEHASH
1196	typedef google::dense_hash_map<deg_t, google::dense_hash_map<deg_t, double>> sprob_map_t;	1195	typedef google::dense_hash_map<deg_t,
		1196	google::dense_hash_map<deg_t, double,
		1197	std::hash<deg_t>>,
		1198	std::hash<deg_t>> sprob_map_t;
1197	#else	1199	#else
1198	typedef std::unordered_map<deg_t, std::unordered_map<deg_t, double>> sprob_map_t;	1200	typedef std::unordered_map<deg_t, std::unordered_map<deg_t, double>> sprob_map_t;
1199	#endif	1201	#endif
Lines 1202-1216 private: Link Here
1202		1204
1203		1205
1204	#ifdef HAVE_SPARSEHASH	1206	#ifdef HAVE_SPARSEHASH
1205	typedef google::dense_hash_map<pair<deg_t, deg_t>, double, boost::hash<pair<deg_t, deg_t>>> prob_map_t;	1207	typedef google::dense_hash_map<pair<deg_t, deg_t>, double,
		1208	std::hash<pair<deg_t, deg_t>>> prob_map_t;
1206	#else	1209	#else
1207	typedef std::unordered_map<pair<deg_t, deg_t>, double, boost::hash<pair<deg_t, deg_t>>> prob_map_t;	1210	typedef std::unordered_map<pair<deg_t, deg_t>, double> prob_map_t;
1208	#endif	1211	#endif
1209		1212
1210	prob_map_t _probs;	1213	prob_map_t _probs;
1211		1214
1212	#ifdef HAVE_SPARSEHASH	1215	#ifdef HAVE_SPARSEHASH
1213	typedef google::dense_hash_map<deg_t, vector<size_t>> edge_map_t;	1216	typedef google::dense_hash_map<deg_t, vector<size_t>,
		1217	std::hash<deg_t>> edge_map_t;
1214	#else	1218	#else
1215	typedef std::unordered_map<deg_t, vector<size_t>> edge_map_t;	1219	typedef std::unordered_map<deg_t, vector<size_t>> edge_map_t;
1216	#endif	1220	#endif
Lines 1253-1260 public: Link Here
1253	_vertices[d].push_back(*v);	1257	_vertices[d].push_back(*v);
1254	}	1258	}
1255		1259
1256	std::unordered_map<pair<deg_t, deg_t>, double, boost::hash<pair<deg_t, deg_t> > >	1260	std::unordered_map<pair<deg_t, deg_t>, double> probs;
1257	probs;
1258	_corr_prob.get_probs(probs);	1261	_corr_prob.get_probs(probs);
1259		1262
1260	vector<double> dprobs;	1263	vector<double> dprobs;
Lines 1347-1353 private: Link Here
1347	rng_t& _rng;	1350	rng_t& _rng;
1348		1351
1349	#ifdef HAVE_SPARSEHASH	1352	#ifdef HAVE_SPARSEHASH
1350	google::dense_hash_map<deg_t, vector<vertex_t>> _vertices;	1353	google::dense_hash_map<deg_t, vector<vertex_t>,
		1354	std::hash<deg_t>> _vertices;
1351	#else	1355	#else
1352	std::unordered_map<deg_t, vector<vertex_t>> _vertices;	1356	std::unordered_map<deg_t, vector<vertex_t>> _vertices;
1353	#endif	1357	#endif

Lines 53-63 struct get_similarity Link Here

(-)a/src/graph/topology/graph_similarity.hh (-8 / +5 lines)
53		53
54	typedef typename property_traits<LabelMap>::value_type label_t;	54	typedef typename property_traits<LabelMap>::value_type label_t;
55		55
56	std::unordered_map<label_t, typename graph_traits<Graph1>::vertex_descriptor,	56	std::unordered_map<label_t, typename graph_traits<Graph1>::vertex_descriptor>
57	boost::hash<label_t>>
58	lmap1;	57	lmap1;
59	std::unordered_map<label_t, typename graph_traits<Graph2>::vertex_descriptor,	58	std::unordered_map<label_t, typename graph_traits<Graph2>::vertex_descriptor>
60	boost::hash<label_t>>
61	lmap2;	59	lmap2;
62		60
63	for (auto v : vertices_range(g1))	61	for (auto v : vertices_range(g1))
Lines 75-83 struct get_similarity Link Here
75	continue;	73	continue;
76	auto v2 = li2->second;	74	auto v2 = li2->second;
77		75
78	std::unordered_set<label_t, boost::hash<label_t>> keys;	76	std::unordered_set<label_t> keys;
79	std::unordered_multiset<label_t, boost::hash<label_t>> adj1;	77	std::unordered_multiset<label_t> adj1;
80	std::unordered_multiset<label_t, boost::hash<label_t>> adj2;	78	std::unordered_multiset<label_t> adj2;
81		79
82	for (auto a1 : adjacent_vertices_range(v1, g1))	80	for (auto a1 : adjacent_vertices_range(v1, g1))
83	{	81	{
84	-