inline OutputIterator
kruskal_minimum_spanning_tree(const Graph& g,
OutputIterator spanning_tree_edges,
const bgl_named_params<P, T, R>& params)
{
typedef typename graph_traits<Graph>::vertices_size_type size_type;
typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
if (num_vertices(g) == 0) return spanning_tree_edges; // Nothing to do in this case
typename graph_traits<Graph>::vertices_size_type n;
n = is_default_param(get_param(params, vertex_rank))
? num_vertices(g) : 1;
std::vector<size_type> rank_map(n);
n = is_default_param(get_param(params, vertex_predecessor))
? num_vertices(g) : 1;
std::vector<vertex_t> pred_map(n);
return detail::kruskal_mst_impl
(g, spanning_tree_edges,
choose_param
(get_param(params, vertex_rank),
make_iterator_property_map
(rank_map.begin(),
choose_pmap(get_param(params, vertex_index), g, vertex_index), rank_map[0])),
choose_param
(get_param(params, vertex_predecessor),
make_iterator_property_map
(pred_map.begin(),
choose_const_pmap(get_param(params, vertex_index), g, vertex_index),
pred_map[0])),
choose_const_pmap(get_param(params, edge_weight), g, edge_weight));
}
inline void
dag_sp_dispatch1
(const VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor s,
DistanceMap distance, WeightMap weight, ColorMap color, IndexMap id,
DijkstraVisitor vis, const Params& params)
{
typedef typename property_traits<WeightMap>::value_type T;
typename std::vector<T>::size_type n;
n = is_default_param(distance) ? num_vertices(g) : 1;
std::vector<T> distance_map(n);
n = is_default_param(color) ? num_vertices(g) : 1;
std::vector<default_color_type> color_map(n);
dag_sp_dispatch2
(g, s,
choose_param(distance,
make_iterator_property_map(distance_map.begin(), id,
distance_map[0])),
weight,
choose_param(color,
make_iterator_property_map(color_map.begin(), id,
color_map[0])),
id, vis, params);
}
base_state(const GraphThis& graph_this, const GraphOther& graph_other,
IndexMapThis index_map_this, IndexMapOther index_map_other)
: graph_this_(graph_this), graph_other_(graph_other),
index_map_this_(index_map_this), index_map_other_(index_map_other),
term_in_count_(0), term_out_count_(0), term_both_count_(0), core_count_(0) {
core_vec_.resize(num_vertices(graph_this_), graph_traits<GraphOther>::null_vertex());
core_ = make_iterator_property_map(core_vec_.begin(), index_map_this_);
in_vec_.resize(num_vertices(graph_this_), 0);
in_ = make_iterator_property_map(in_vec_.begin(), index_map_this_);
out_vec_.resize(num_vertices(graph_this_), 0);
out_ = make_iterator_property_map(out_vec_.begin(), index_map_this_);
}
inline void
dijkstra_shortest_paths_no_init
(const VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor s,
PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
IndexMap index_map,
Compare compare, Combine combine, DistInf inf, DistZero zero,
DijkstraVisitor vis)
{
typedef indirect_cmp<DistanceMap, Compare> IndirectCmp;
IndirectCmp icmp(distance, compare);
typedef typename graph_traits<VertexListGraph>::vertex_descriptor Vertex;
typedef mutable_queue<Vertex, std::vector<Vertex>, IndirectCmp, IndexMap>
MutableQueue;
MutableQueue Q(num_vertices(g), icmp, index_map);
detail::dijkstra_bfs_visitor<DijkstraVisitor, MutableQueue, WeightMap,
PredecessorMap, DistanceMap, Combine, Compare>
bfs_vis(vis, Q, weight, predecessor, distance, combine, compare, zero);
std::vector<default_color_type> color(num_vertices(g));
default_color_type c = white_color;
breadth_first_visit(g, s, Q, bfs_vis,
make_iterator_property_map(&color[0], index_map, c));
}
static
bool pruneForwardUseless(NGHolder &h, const nfag_t &g, NFAVertex s,
vector<default_color_type> &vertexColor) {
// Begin with all vertices set to white, as DFV only marks visited
// vertices.
fill(vertexColor.begin(), vertexColor.end(), boost::white_color);
auto index_map = get(&NFAGraphVertexProps::index, g);
depth_first_visit(g, s, make_dfs_visitor(boost::null_visitor()),
make_iterator_property_map(vertexColor.begin(),
index_map));
vector<NFAVertex> dead;
// All non-special vertices that are still white can be removed.
for (auto v : vertices_range(g)) {
u32 idx = g[v].index;
if (!is_special(v, g) && vertexColor[idx] == boost::white_color) {
DEBUG_PRINTF("vertex %u is unreachable from %u\n",
g[v].index, g[s].index);
dead.push_back(v);
}
}
if (dead.empty()) {
return false;
}
DEBUG_PRINTF("removing %zu vertices\n", dead.size());
remove_vertices(dead, h, false);
return true;
}
static typename edge_capacity_value<Graph, P, T, R>::type
apply
(Graph& g,
typename graph_traits<Graph>::vertex_descriptor src,
typename graph_traits<Graph>::vertex_descriptor sink,
PredMap pred,
const bgl_named_params<P, T, R>& params,
detail::error_property_not_found)
{
typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
typedef typename graph_traits<Graph>::vertices_size_type size_type;
size_type n = is_default_param(get_param(params, vertex_color)) ?
num_vertices(g) : 1;
std::vector<default_color_type> color_vec(n);
return edmunds_karp_max_flow
(g, src, sink,
choose_const_pmap(get_param(params, edge_capacity), g, edge_capacity),
choose_pmap(get_param(params, edge_residual_capacity),
g, edge_residual_capacity),
choose_const_pmap(get_param(params, edge_reverse), g, edge_reverse),
make_iterator_property_map(color_vec.begin(), choose_const_pmap
(get_param(params, vertex_index),
g, vertex_index), color_vec[0]),
pred);
}
inline void
kruskal_minimum_spanning_tree(const Graph& g,
OutputIterator spanning_tree_edges)
{
typedef typename graph_traits<Graph>::vertices_size_type size_type;
typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
if (num_vertices(g) == 0) return; // Nothing to do in this case
typename graph_traits<Graph>::vertices_size_type
n = num_vertices(g);
std::vector<size_type> rank_map(n);
std::vector<vertex_t> pred_map(n);
detail::kruskal_mst_impl
(g, spanning_tree_edges,
make_iterator_property_map(rank_map.begin(), get(vertex_index, g), rank_map[0]),
make_iterator_property_map(pred_map.begin(), get(vertex_index, g), pred_map[0]),
get(edge_weight, g));
}
void
betweenness_centrality_clustering(MutableGraph& g, Done done)
{
typedef typename Done::centrality_type centrality_type;
std::vector<centrality_type> edge_centrality(num_edges(g));
betweenness_centrality_clustering(g, done,
make_iterator_property_map(edge_centrality.begin(), get(edge_index, g)),
get(vertex_index, g));
}
std::pair<std::size_t, OutputIterator>
biconnected_components(const Graph& g, ComponentMap comp, OutputIterator out,
VertexIndexMap index_map)
{
typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
typedef typename graph_traits<Graph>::vertices_size_type
vertices_size_type;
std::vector<vertices_size_type> discover_time(num_vertices(g));
std::vector<vertices_size_type> lowpt(num_vertices(g));
vertices_size_type vst(0);
return biconnected_components
(g, comp, out,
make_iterator_property_map(discover_time.begin(), index_map, vst),
make_iterator_property_map(lowpt.begin(), index_map, vst),
index_map);
}
typename property_traits<CoreMap>::value_type
core_numbers(Graph& g, CoreMap c, CoreNumVisitor vis)
{
typedef typename graph_traits<Graph>::vertices_size_type size_type;
detail::compute_in_degree_map(g,c,
detail::constant_value_property_map<
typename property_traits<CoreMap>::value_type>(1) );
return detail::core_numbers_impl(g,c,
make_iterator_property_map(
std::vector<size_type>(num_vertices(g)).begin(),get(vertex_index, g)),
vis
);
}
std::pair<std::size_t, OutputIterator>
biconnected_components(const Graph & g, ComponentMap comp,
OutputIterator out, DiscoverTimeMap discover_time,
LowPointMap lowpt, VertexIndexMap index_map)
{
typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
std::vector<vertex_t> pred(num_vertices(g));
vertex_t vert = graph_traits<Graph>::null_vertex();
return biconnected_components
(g, comp, out, discover_time, lowpt,
make_iterator_property_map(pred.begin(), index_map, vert),
index_map);
}
inline typename FloatTraits::value_type
minimum_cycle_mean(const Graph &g, VertexIndexMap vim,
EdgeWeightMap ewm, EdgeIndexMap eim,
std::vector<typename graph_traits<Graph>::edge_descriptor>* pcc = 0,
FloatTraits ft = FloatTraits())
{
typedef typename remove_const<
typename property_traits<EdgeWeightMap>::value_type
>::type Weight;
typename std::vector<Weight> ed_w2(boost::num_edges(g), 1);
return minimum_cycle_ratio(g, vim, ewm,
make_iterator_property_map(ed_w2.begin(), eim),
pcc, ft);
}
distributed_property_map<ProcessGroup,
GlobalMap,
iterator_property_map<RandomAccessIterator,
StorageMap> >
make_iterator_property_map(RandomAccessIterator cc,
local_property_map<ProcessGroup, GlobalMap,
StorageMap> index_map)
{
typedef distributed_property_map<
ProcessGroup, GlobalMap,
iterator_property_map<RandomAccessIterator, StorageMap> >
result_type;
return result_type(index_map.process_group(), index_map.global(),
make_iterator_property_map(cc, index_map.base()));
}
void transitive_closure_dispatch
(const Graph & g, GraphTC & tc,
G_to_TC_VertexMap g_to_tc_map, VertexIndexMap index_map)
{
typedef typename graph_traits < GraphTC >::vertex_descriptor tc_vertex;
typename std::vector < tc_vertex >::size_type
n = is_default_param(g_to_tc_map) ? num_vertices(g) : 1;
std::vector < tc_vertex > to_tc_vec(n);
transitive_closure
(g, tc,
choose_param(g_to_tc_map, make_iterator_property_map
(to_tc_vec.begin(), index_map, to_tc_vec[0])),
index_map);
}
static void
apply(const Graph& g, DFSVisitor vis, Vertex start_vertex,
const bgl_named_params<P, T, R>& params,
EdgeColorMap edge_color,
param_not_found)
{
std::vector<default_color_type> color_vec(num_vertices(g));
default_color_type c = white_color; // avoid warning about un-init
undirected_dfs
(g, vis, make_iterator_property_map
(color_vec.begin(),
choose_const_pmap(get_param(params, vertex_index),
g, vertex_index), c),
edge_color,
start_vertex);
}
inline static typename property_traits<ComponentMap>::value_type
apply(const Graph& g,
ComponentMap comp,
RootMap r_map,
const bgl_named_params<P, T, R>& params,
param_not_found)
{
typedef typename graph_traits<Graph>::vertices_size_type size_type;
size_type n = num_vertices(g) > 0 ? num_vertices(g) : 1;
std::vector<size_type> time_vec(n);
return strong_components_impl
(g, comp, r_map,
make_iterator_property_map(time_vec.begin(), choose_const_pmap
(get_param(params, vertex_index),
g, vertex_index), time_vec[0]),
params);
}
inline static typename property_traits<ComponentMap>::value_type
apply(const Graph& g,
ComponentMap comp,
const bgl_named_params<P, T, R>& params,
param_not_found)
{
typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
typename std::vector<Vertex>::size_type
n = num_vertices(g) > 0 ? num_vertices(g) : 1;
std::vector<Vertex> root_vec(n);
return scc_helper2
(g, comp,
make_iterator_property_map(root_vec.begin(), choose_const_pmap
(get_param(params, vertex_index),
g, vertex_index), root_vec[0]),
params,
get_param(params, vertex_discover_time));
}
inline void
dijkstra_dispatch1
(const VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor s,
DistanceMap distance, WeightMap weight, IndexMap index_map,
const Params& params)
{
// Default for distance map
typedef typename property_traits<WeightMap>::value_type D;
typename std::vector<D>::size_type
n = is_default_param(distance) ? num_vertices(g) : 1;
std::vector<D> distance_map(n);
detail::dijkstra_dispatch2
(g, s, choose_param(distance, make_iterator_property_map
(distance_map.begin(), index_map,
distance_map[0])),
weight, index_map, params);
}
static void
run(const DistributedGraph& g,
typename graph_traits<DistributedGraph>::vertex_descriptor s,
PredecessorMap predecessor, DistanceMap distance,
Lookahead lookahead, WeightMap weight, IndexMap index_map,
::boost::param_not_found,
Compare compare, Combine combine, DistInf inf, DistZero zero,
DijkstraVisitor vis)
{
typedef typename graph_traits<DistributedGraph>::vertices_size_type
vertices_size_type;
vertices_size_type n = num_vertices(g);
std::vector<default_color_type> colors(n, white_color);
run_impl(g, s, predecessor, distance, lookahead, weight, index_map,
make_iterator_property_map(colors.begin(), index_map),
compare, combine, inf, zero, vis);
}
static void apply
(VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor s,
const bgl_named_params<P, T, R>& params,
detail::error_property_not_found)
{
std::vector<default_color_type> color_vec(num_vertices(g));
default_color_type c = white_color;
null_visitor null_vis;
bfs_helper
(g, s,
make_iterator_property_map
(color_vec.begin(),
choose_const_pmap(get_param(params, vertex_index),
g, vertex_index), c),
choose_param(get_param(params, graph_visitor),
make_bfs_visitor(null_vis)),
params);
}
static
depth findMinWidth(const NGHolder &h, const SpecialEdgeFilter &filter,
NFAVertex src) {
if (isLeafNode(src, h)) {
return depth::unreachable();
}
boost::filtered_graph<NFAGraph, SpecialEdgeFilter> g(h.g, filter);
assert(hasCorrectlyNumberedVertices(h));
const size_t num = num_vertices(h);
vector<depth> distance(num, depth::unreachable());
distance.at(g[src].index) = depth(0);
auto index_map = get(&NFAGraphVertexProps::index, g);
// Since we are interested in the single-source shortest paths on a graph
// with the same weight on every edge, using BFS will be faster than
// Dijkstra here.
breadth_first_search(
g, src,
visitor(make_bfs_visitor(record_distances(
make_iterator_property_map(distance.begin(), index_map),
boost::on_tree_edge()))).vertex_index_map(index_map));
DEBUG_PRINTF("d[accept]=%s, d[acceptEod]=%s\n",
distance.at(NODE_ACCEPT).str().c_str(),
distance.at(NODE_ACCEPT_EOD).str().c_str());
depth d = min(distance.at(NODE_ACCEPT), distance.at(NODE_ACCEPT_EOD));
if (d.is_unreachable()) {
return d;
}
assert(d.is_finite());
assert(d > depth(0));
return d - depth(1);
}
typename property_traits<ColorMap>::value_type
sequential_vertex_coloring(const VertexListGraph& G, ColorMap color)
{
typedef typename graph_traits<VertexListGraph>::vertex_descriptor
vertex_descriptor;
typedef typename graph_traits<VertexListGraph>::vertex_iterator
vertex_iterator;
std::pair<vertex_iterator, vertex_iterator> v = vertices(G);
#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
std::vector<vertex_descriptor> order(v.first, v.second);
#else
std::vector<vertex_descriptor> order;
order.reserve(std::distance(v.first, v.second));
while (v.first != v.second) order.push_back(*v.first++);
#endif
return sequential_vertex_coloring
(G,
make_iterator_property_map
(order.begin(), identity_property_map(),
graph_traits<VertexListGraph>::null_vertex()),
color);
}
static typename edge_capacity_value<Graph, P, T, R>::type
apply
(Graph& g,
typename graph_traits<Graph>::vertex_descriptor src,
typename graph_traits<Graph>::vertex_descriptor sink,
const bgl_named_params<P, T, R>& params,
detail::error_property_not_found)
{
typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
typedef typename graph_traits<Graph>::vertices_size_type size_type;
size_type n = is_default_param(get_param(params, vertex_predecessor)) ?
num_vertices(g) : 1;
std::vector<edge_descriptor> pred_vec(n);
typedef typename property_value< bgl_named_params<P,T,R>, vertex_color_t>::type C;
return edmunds_karp_dispatch2<C>::apply
(g, src, sink,
make_iterator_property_map(pred_vec.begin(), choose_const_pmap
(get_param(params, vertex_index),
g, vertex_index), pred_vec[0]),
params,
get_param(params, vertex_color));
}
void traverse( vertex_descriptor startingNode, DFSVisitor& visitor )
{
// try
// {
// Colors
// @todo Could be optimize (don't reallocate this vector for each traverse call).
std::vector< boost::default_color_type > colors( num_vertices(bglGraph()) );
const boost::default_color_type c = boost::white_color;
// Index Map
typedef boost::property_map<detail::bglGraph, boost::vertex_index_t>::type IndexMap;
IndexMap indexmap = boost::get(boost::vertex_index, bglGraph());
// Initialize visitor
visitor.initialize( &getVertexNamePropertyMap(), &getEdgeNamePropertyMap() );
// Depth first search
vgd::visitor::internal::depth_first_search(
bglGraph(),
visitor,
make_iterator_property_map(
colors.begin(),
indexmap,
c ),
startingNode
);
// }
// catch (vgd::visitor::HasCycle e)
// {
// throw e;
// FIXME
//return ( true );
// }
}
static
depth findMaxWidth(const NGHolder &h, const SpecialEdgeFilter &filter,
NFAVertex src) {
if (isLeafNode(src, h.g)) {
return depth::unreachable();
}
if (hasReachableCycle(h, src)) {
// There's a cycle reachable from this src, so we have inf width.
return depth::infinity();
}
boost::filtered_graph<NFAGraph, SpecialEdgeFilter> g(h.g, filter);
assert(hasCorrectlyNumberedVertices(h));
const size_t num = num_vertices(h);
vector<int> distance(num);
vector<boost::default_color_type> colors(num);
auto index_map = get(&NFAGraphVertexProps::index, g);
// DAG shortest paths with negative edge weights.
dag_shortest_paths(
g, src,
distance_map(make_iterator_property_map(distance.begin(), index_map))
.weight_map(boost::make_constant_property<NFAEdge>(-1))
.vertex_index_map(index_map)
.color_map(make_iterator_property_map(colors.begin(), index_map)));
depth acceptDepth, acceptEodDepth;
if (colors.at(NODE_ACCEPT) == boost::white_color) {
acceptDepth = depth::unreachable();
} else {
acceptDepth = -1 * distance.at(NODE_ACCEPT);
}
if (colors.at(NODE_ACCEPT_EOD) == boost::white_color) {
acceptEodDepth = depth::unreachable();
} else {
acceptEodDepth = -1 * distance.at(NODE_ACCEPT_EOD);
}
depth d;
if (acceptDepth.is_unreachable()) {
d = acceptEodDepth;
} else if (acceptEodDepth.is_unreachable()) {
d = acceptDepth;
} else {
d = max(acceptDepth, acceptEodDepth);
}
if (d.is_unreachable()) {
// If we're actually reachable, we'll have a min width, so we can
// return infinity in this case.
if (findMinWidth(h, filter, src).is_reachable()) {
return depth::infinity();
}
return d;
}
// Invert sign and subtract one for start transition.
assert(d.is_finite() && d > depth(0));
return d - depth(1);
}
static type build(const Graph& g, const IndexMap& index, boost::scoped_array<Value>& array_holder) {
array_holder.reset(new Value[num_vertices(g)]);
std::fill(array_holder.get(), array_holder.get() + num_vertices(g), Value());
return make_iterator_property_map(array_holder.get(), index);
}
std::vector<typename graph_traits<VertexListGraph>::vertex_descriptor>
smallest_last_vertex_ordering(const VertexListGraph& G) {
std::vector<typename graph_traits<VertexListGraph>::vertex_descriptor> o(num_vertices(G));
smallest_last_vertex_ordering(G, make_iterator_property_map(o.begin(), typed_identity_property_map<std::size_t>()));
return o;
}
inline typename property_map<YASMIC_SIMPLE_CSR_GRAPH_TYPE, edge_weight_t>::const_type
get(edge_weight_t, const YASMIC_SIMPLE_CSR_GRAPH_TYPE& g)
{
return make_iterator_property_map(g.a,get(edge_index,g));
}
