int igraph_is_separator(const igraph_t *graph,
const igraph_vs_t candidate,
igraph_bool_t *res) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_bool_t removed;
igraph_dqueue_t Q;
igraph_vector_t neis;
igraph_vit_t vit;
IGRAPH_CHECK(igraph_vit_create(graph, candidate, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
IGRAPH_CHECK(igraph_vector_bool_init(&removed, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &removed);
IGRAPH_CHECK(igraph_dqueue_init(&Q, 100));
IGRAPH_FINALLY(igraph_dqueue_destroy, &Q);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
IGRAPH_CHECK(igraph_i_is_separator(graph, &vit, -1, res, &removed,
&Q, &neis, no_of_nodes));
igraph_vector_destroy(&neis);
igraph_dqueue_destroy(&Q);
igraph_vector_bool_destroy(&removed);
igraph_vit_destroy(&vit);
IGRAPH_FINALLY_CLEAN(4);
return 0;
}
int igraph_is_minimal_separator(const igraph_t *graph,
const igraph_vs_t candidate,
igraph_bool_t *res) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_bool_t removed;
igraph_dqueue_t Q;
igraph_vector_t neis;
long int candsize;
igraph_vit_t vit;
IGRAPH_CHECK(igraph_vit_create(graph, candidate, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
candsize=IGRAPH_VIT_SIZE(vit);
IGRAPH_CHECK(igraph_vector_bool_init(&removed, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &removed);
IGRAPH_CHECK(igraph_dqueue_init(&Q, 100));
IGRAPH_FINALLY(igraph_dqueue_destroy, &Q);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
/* Is it a separator at all? */
IGRAPH_CHECK(igraph_i_is_separator(graph, &vit, -1, res, &removed,
&Q, &neis, no_of_nodes));
if (!(*res)) {
/* Not a separator at all, nothing to do, *res is already set */
} else if (candsize == 0) {
/* Nothing to do, minimal, *res is already set */
} else {
/* General case, we need to remove each vertex from 'candidate'
* and check whether the remainder is a separator. If this is
* false for all vertices, then 'candidate' is a minimal
* separator.
*/
long int i;
for (i=0, *res=0; i<candsize && (!*res); i++) {
igraph_vector_bool_null(&removed);
IGRAPH_CHECK(igraph_i_is_separator(graph, &vit, i, res, &removed,
&Q, &neis, no_of_nodes));
}
(*res) = (*res) ? 0 : 1; /* opposite */
}
igraph_vector_destroy(&neis);
igraph_dqueue_destroy(&Q);
igraph_vector_bool_destroy(&removed);
igraph_vit_destroy(&vit);
IGRAPH_FINALLY_CLEAN(4);
return 0;
}
int igraph_cohesive_blocks(const igraph_t *graph,
igraph_vector_ptr_t *blocks,
igraph_vector_t *cohesion,
igraph_vector_t *parent,
igraph_t *block_tree) {
/* Some implementation comments. Everything is relatively
straightforward, except, that we need to follow the vertex ids
of the various subgraphs, without having to store two-way
mappings at each level. The subgraphs can overlap, this
complicates things a bit.
The 'Q' vector is used as a double ended queue and it contains
the subgraphs to work on in the future. Some other vectors are
associated with it. 'Qparent' gives the parent graph of a graph
in Q. Qmapping gives the mapping of the vertices from the graph
to the parent graph. Qcohesion is the vertex connectivity of the
graph.
Qptr is an integer and points to the next graph to work on.
*/
igraph_vector_ptr_t Q;
igraph_vector_ptr_t Qmapping;
igraph_vector_long_t Qparent;
igraph_vector_long_t Qcohesion;
igraph_vector_bool_t Qcheck;
long int Qptr=0;
igraph_integer_t conn;
igraph_bool_t is_simple;
igraph_t *graph_copy;
igraph_vector_ptr_t separators;
igraph_vector_t compvertices;
igraph_vector_long_t components;
igraph_vector_bool_t marked;
igraph_vector_long_t compid;
igraph_dqueue_t bfsQ;
igraph_vector_t neis;
if (igraph_is_directed(graph)) {
IGRAPH_ERROR("Cohesive blocking only works on undirected graphs",
IGRAPH_EINVAL);
}
IGRAPH_CHECK(igraph_is_simple(graph, &is_simple));
if (!is_simple) {
IGRAPH_ERROR("Cohesive blocking only works on simple graphs",
IGRAPH_EINVAL);
}
IGRAPH_STATUS("Starting cohesive block calculation.\n", 0);
if (blocks) { igraph_vector_ptr_clear(blocks); }
if (cohesion) { igraph_vector_clear(cohesion); }
if (parent) { igraph_vector_clear(parent); }
IGRAPH_CHECK(igraph_vector_ptr_init(&Q, 1));
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &Q);
IGRAPH_FINALLY(igraph_i_cohesive_blocks_free, &Q);
IGRAPH_CHECK(igraph_vector_ptr_init(&Qmapping, 1));
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &Qmapping);
IGRAPH_FINALLY(igraph_i_cohesive_blocks_free2, &Qmapping);
IGRAPH_CHECK(igraph_vector_long_init(&Qparent, 1));
IGRAPH_FINALLY(igraph_vector_long_destroy, &Qparent);
IGRAPH_CHECK(igraph_vector_long_init(&Qcohesion, 1));
IGRAPH_FINALLY(igraph_vector_long_destroy, &Qcohesion);
IGRAPH_CHECK(igraph_vector_bool_init(&Qcheck, 1));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &Qcheck);
IGRAPH_CHECK(igraph_vector_ptr_init(&separators, 0));
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &separators);
IGRAPH_VECTOR_INIT_FINALLY(&compvertices, 0);
IGRAPH_CHECK(igraph_vector_bool_init(&marked, 0));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &marked);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
IGRAPH_CHECK(igraph_dqueue_init(&bfsQ, 100));
IGRAPH_FINALLY(igraph_dqueue_destroy, &bfsQ);
IGRAPH_CHECK(igraph_vector_long_init(&compid, 0));
IGRAPH_FINALLY(igraph_vector_long_destroy, &compid);
IGRAPH_CHECK(igraph_vector_long_init(&components, 0));
IGRAPH_FINALLY(igraph_vector_long_destroy, &components);
/* Put the input graph in the queue */
graph_copy=igraph_Calloc(1, igraph_t);
if (!graph_copy) {
IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
}
IGRAPH_CHECK(igraph_copy(graph_copy, graph));
VECTOR(Q)[0] = graph_copy;
VECTOR(Qmapping)[0] = 0; /* Identity mapping */
VECTOR(Qparent)[0] = -1; /* Has no parent */
IGRAPH_CHECK(igraph_vertex_connectivity(graph, &conn, /*checks=*/ 1));
VECTOR(Qcohesion)[0] = conn;
VECTOR(Qcheck)[0] = 0;
/* Then work until the queue is empty */
while (Qptr < igraph_vector_ptr_size(&Q)) {
igraph_t *mygraph=VECTOR(Q)[Qptr];
igraph_bool_t mycheck=VECTOR(Qcheck)[Qptr];
long int mynodes=igraph_vcount(mygraph);
long int i, nsep;
long int no, kept=0;
long int cptr=0;
long int nsepv=0;
igraph_bool_t addedsep=0;
IGRAPH_STATUSF(("Candidate %li: %li vertices,",
0, Qptr, mynodes));
IGRAPH_ALLOW_INTERRUPTION();
/* Get the separators */
IGRAPH_CHECK(igraph_minimum_size_separators(mygraph, &separators));
IGRAPH_FINALLY(igraph_i_cohesive_blocks_free3, &separators);
nsep=igraph_vector_ptr_size(&separators);
IGRAPH_STATUSF((" %li separators,", 0, nsep));
/* Remove them from the graph, also mark them */
IGRAPH_CHECK(igraph_vector_bool_resize(&marked, mynodes));
igraph_vector_bool_null(&marked);
for (i=0; i<nsep; i++) {
igraph_vector_t *v=VECTOR(separators)[i];
long int j, n=igraph_vector_size(v);
for (j=0; j<n; j++) {
long int vv=(long int) VECTOR(*v)[j];
if (!VECTOR(marked)[vv]) {
nsepv++;
VECTOR(marked)[vv] = 1;
}
}
}
/* Find the connected components, omitting the separator vertices,
but including the neighboring separator vertices
*/
IGRAPH_CHECK(igraph_i_cb_components(mygraph, &marked,
&components, &no,
&compid, &bfsQ, &neis));
/* Add the separator vertices themselves, as another component,
but only if there is at least one vertex not included in any
separator. */
if (nsepv != mynodes) {
addedsep=1;
for (i=0; i<mynodes; i++) {
if (VECTOR(marked)[i]) {
IGRAPH_CHECK(igraph_vector_long_push_back(&components, i));
}
}
IGRAPH_CHECK(igraph_vector_long_push_back(&components, -1));
no++;
}
IGRAPH_STATUSF((" %li new candidates,", 0, no));
for (i=0; i<no; i++) {
igraph_vector_t *newmapping;
igraph_t *newgraph;
igraph_integer_t maxdeg;
igraph_vector_clear(&compvertices);
while (1) {
long int v=VECTOR(components)[cptr++];
if (v < 0) { break; }
IGRAPH_CHECK(igraph_vector_push_back(&compvertices, v));
}
newmapping=igraph_Calloc(1, igraph_vector_t);
if (!newmapping) {
IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, newmapping);
IGRAPH_VECTOR_INIT_FINALLY(newmapping, 0);
newgraph=igraph_Calloc(1, igraph_t);
if (!newgraph) {
IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, newgraph);
IGRAPH_CHECK(igraph_induced_subgraph_map(mygraph, newgraph,
igraph_vss_vector(&compvertices),
IGRAPH_SUBGRAPH_AUTO,
/*map=*/ 0,
/*invmap=*/ newmapping));
IGRAPH_FINALLY(igraph_destroy, newgraph);
IGRAPH_CHECK(igraph_maxdegree(newgraph, &maxdeg, igraph_vss_all(),
IGRAPH_ALL, IGRAPH_LOOPS));
if (maxdeg > VECTOR(Qcohesion)[Qptr]) {
igraph_integer_t newconn;
kept++;
IGRAPH_CHECK(igraph_vector_ptr_push_back(&Q, newgraph));
IGRAPH_FINALLY_CLEAN(2);
IGRAPH_CHECK(igraph_vector_ptr_push_back(&Qmapping, newmapping));
IGRAPH_FINALLY_CLEAN(2);
IGRAPH_CHECK(igraph_vertex_connectivity(newgraph, &newconn,
/*checks=*/ 1));
IGRAPH_CHECK(igraph_vector_long_push_back(&Qcohesion, newconn));
IGRAPH_CHECK(igraph_vector_long_push_back(&Qparent, Qptr));
IGRAPH_CHECK(igraph_vector_bool_push_back(&Qcheck,
mycheck || addedsep));
} else {
igraph_destroy(newgraph);
igraph_free(newgraph);
igraph_vector_destroy(newmapping);
igraph_free(newmapping);
IGRAPH_FINALLY_CLEAN(4);
}
}
IGRAPH_STATUSF((" keeping %li.\n", 0, kept));
igraph_destroy(mygraph);
igraph_free(mygraph);
VECTOR(Q)[Qptr] = 0;
igraph_i_cohesive_blocks_free3(&separators);
IGRAPH_FINALLY_CLEAN(1);
Qptr++;
}
igraph_vector_long_destroy(&components);
igraph_vector_long_destroy(&compid);
igraph_dqueue_destroy(&bfsQ);
igraph_vector_destroy(&neis);
igraph_vector_bool_destroy(&marked);
igraph_vector_destroy(&compvertices);
igraph_vector_ptr_destroy(&separators);
IGRAPH_FINALLY_CLEAN(7);
if (blocks || cohesion || parent || block_tree) {
igraph_integer_t noblocks=(igraph_integer_t) Qptr, badblocks=0;
igraph_vector_bool_t removed;
long int i, resptr=0;
igraph_vector_long_t rewritemap;
IGRAPH_CHECK(igraph_vector_bool_init(&removed, noblocks));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &removed);
IGRAPH_CHECK(igraph_vector_long_init(&rewritemap, noblocks));
IGRAPH_FINALLY(igraph_vector_long_destroy, &rewritemap);
for (i=1; i<noblocks; i++) {
long int p=VECTOR(Qparent)[i];
while (VECTOR(removed)[p]) { p=VECTOR(Qparent)[p]; }
if (VECTOR(Qcohesion)[p] >= VECTOR(Qcohesion)[i]) {
VECTOR(removed)[i]=1;
badblocks++;
}
}
/* Rewrite the mappings */
for (i=1; i<Qptr; i++) {
long int p=VECTOR(Qparent)[i];
igraph_vector_t *mapping=VECTOR(Qmapping)[i];
igraph_vector_t *pmapping=VECTOR(Qmapping)[p];
long int j, n=igraph_vector_size(mapping);
if (!pmapping) { continue; }
for (j=0; j<n; j++) {
long int v=(long int) VECTOR(*mapping)[j];
VECTOR(*mapping)[j] = VECTOR(*pmapping)[v];
}
}
/* Because we also put the separator vertices in the queue, it is
not ensured that the found blocks are not subsets of each other.
We check this now. */
for (i=1; i<noblocks; i++) {
long int j, ic;
igraph_vector_t *ivec;
if (!VECTOR(Qcheck)[i] || VECTOR(removed)[i]) { continue; }
ivec=VECTOR(Qmapping)[i];
ic=VECTOR(Qcohesion)[i];
for (j=1; j<noblocks; j++) {
igraph_vector_t *jvec;
long int jc;
if (j==i || !VECTOR(Qcheck)[j] || VECTOR(removed)[j]) { continue; }
jvec=VECTOR(Qmapping)[j];
jc=VECTOR(Qcohesion)[j];
if (igraph_i_cb_isin(ivec, jvec) && jc >= ic) {
badblocks++;
VECTOR(removed)[i]=1;
break;
}
}
}
noblocks -= badblocks;
if (blocks) { IGRAPH_CHECK(igraph_vector_ptr_resize(blocks, noblocks)); }
if (cohesion) { IGRAPH_CHECK(igraph_vector_resize(cohesion, noblocks)); }
if (parent) { IGRAPH_CHECK(igraph_vector_resize(parent, noblocks)); }
for (i=0; i<Qptr; i++) {
if (VECTOR(removed)[i]) {
IGRAPH_STATUSF(("Candidate %li ignored.\n", 0, i));
continue;
} else {
IGRAPH_STATUSF(("Candidate %li is a cohesive (sub)block\n", 0, i));
}
VECTOR(rewritemap)[i] = resptr;
if (cohesion) { VECTOR(*cohesion)[resptr]=VECTOR(Qcohesion)[i]; }
if (parent || block_tree) {
long int p=VECTOR(Qparent)[i];
while (p>=0 && VECTOR(removed)[p]) { p=VECTOR(Qparent)[p]; }
if (p>=0) { p=VECTOR(rewritemap)[p]; }
VECTOR(Qparent)[i]=p;
if (parent) { VECTOR(*parent)[resptr]=p; }
}
if (blocks) {
VECTOR(*blocks)[resptr]=VECTOR(Qmapping)[i];
VECTOR(Qmapping)[i]=0;
}
resptr++;
}
/* Plus the original graph */
if (blocks) {
igraph_vector_t *orig=igraph_Calloc(1, igraph_vector_t);
if (!orig) {
IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, orig);
IGRAPH_CHECK(igraph_vector_init_seq(orig, 0, igraph_vcount(graph)-1));
VECTOR(*blocks)[0]=orig;
IGRAPH_FINALLY_CLEAN(1);
}
if (block_tree) {
igraph_vector_t edges;
long int eptr=0;
IGRAPH_VECTOR_INIT_FINALLY(&edges, noblocks*2-2);
for (i=1; i<Qptr; i++) {
if (VECTOR(removed)[i]) { continue; }
VECTOR(edges)[eptr++] = VECTOR(Qparent)[i];
VECTOR(edges)[eptr++] = VECTOR(rewritemap)[i];
}
IGRAPH_CHECK(igraph_create(block_tree, &edges, noblocks,
IGRAPH_DIRECTED));
igraph_vector_destroy(&edges);
IGRAPH_FINALLY_CLEAN(1);
}
igraph_vector_long_destroy(&rewritemap);
igraph_vector_bool_destroy(&removed);
IGRAPH_FINALLY_CLEAN(2);
}
igraph_vector_bool_destroy(&Qcheck);
igraph_vector_long_destroy(&Qcohesion);
igraph_vector_long_destroy(&Qparent);
igraph_i_cohesive_blocks_free2(&Qmapping);
IGRAPH_FINALLY_CLEAN(4);
igraph_vector_ptr_destroy(&Qmapping);
igraph_vector_ptr_destroy(&Q);
IGRAPH_FINALLY_CLEAN(3); /* + the elements of Q, they were
already destroyed */
IGRAPH_STATUS("Cohesive blocking done.\n", 0);
return 0;
}
/* #include "igraph_visitor.h"
#include "igraph_memory.h"
#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_dqueue.h"
#include "igraph_stack.h"
#include "config.h"*/
int igraph_bfsr(const igraph_t *graph,
igraph_integer_t root,igraph_vector_t *roots,
igraph_neimode_t mode, igraph_bool_t unreachable,
const igraph_vector_t *restricted,
igraph_vector_t *order, igraph_vector_t *rank,
igraph_vector_t *father,
igraph_vector_t *pred, igraph_vector_t *succ,
igraph_vector_t *dist, igraph_bfshandler_t *callback,
void *extra) {
igraph_dqueue_t Q;
long int no_of_nodes=igraph_vcount(graph);
long int actroot=0;
igraph_vector_char_t added;
igraph_lazy_adjlist_t adjlist;
long int act_rank=0;
long int pred_vec=-1;
long int rootpos=0;
long int noroots= roots ? igraph_vector_size(roots) : 1;
if (!roots && (root < 0 || root >= no_of_nodes)) {
IGRAPH_ERROR("Invalid root vertex in BFS", IGRAPH_EINVAL);
}
if (roots) {
igraph_real_t min, max;
igraph_vector_minmax(roots, &min, &max);
if (min < 0 || max >= no_of_nodes) {
IGRAPH_ERROR("Invalid root vertex in BFS", IGRAPH_EINVAL);
}
}
if (restricted) {
igraph_real_t min, max;
igraph_vector_minmax(restricted, &min, &max);
if (min < 0 || max >= no_of_nodes) {
IGRAPH_ERROR("Invalid vertex id in restricted set", IGRAPH_EINVAL);
}
}
if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
mode != IGRAPH_ALL) {
IGRAPH_ERROR("Invalid mode argument", IGRAPH_EINVMODE);
}
if (!igraph_is_directed(graph)) { mode=IGRAPH_ALL; }
IGRAPH_CHECK(igraph_vector_char_init(&added, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_char_destroy, &added);
IGRAPH_CHECK(igraph_dqueue_init(&Q, 100));
IGRAPH_FINALLY(igraph_dqueue_destroy, &Q);
IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &adjlist, mode, /*simplify=*/ 0));
IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adjlist);
/* Mark the vertices that are not in the restricted set, as already
found. Special care must be taken for vertices that are not in
the restricted set, but are to be used as 'root' vertices. */
if (restricted) {
long int i, n=igraph_vector_size(restricted);
igraph_vector_char_fill(&added, 1);
for (i=0; i<n; i++) {
long int v=(long int) VECTOR(*restricted)[i];
VECTOR(added)[v]=0;
}
}
/* Resize result vectors, and fill them with IGRAPH_NAN */
# define VINIT(v) if (v) { \
igraph_vector_resize((v), no_of_nodes); \
igraph_vector_fill((v), IGRAPH_NAN); }
VINIT(order);
VINIT(rank);
VINIT(father);
VINIT(pred);
VINIT(succ);
VINIT(dist);
# undef VINIT
while (1) {
/* Get the next root vertex, if any */
if (roots && rootpos < noroots) {
/* We are still going through the 'roots' vector */
actroot=(long int) VECTOR(*roots)[rootpos++];
} else if (!roots && rootpos==0) {
/* We have a single root vertex given, and start now */
actroot=root;
rootpos++;
} else if (rootpos==noroots && unreachable) {
/* We finished the given root(s), but other vertices are also
tried as root */
actroot=0;
rootpos++;
} else if (unreachable && actroot+1 < no_of_nodes) {
/* We are already doing the other vertices, take the next one */
actroot++;
} else {
/* No more root nodes to do */
break;
}
/* OK, we have a new root, start BFS */
if (VECTOR(added)[actroot]) { continue; }
IGRAPH_CHECK(igraph_dqueue_push(&Q, actroot));
IGRAPH_CHECK(igraph_dqueue_push(&Q, 0));
VECTOR(added)[actroot] = 1;
if (father) { VECTOR(*father)[actroot] = -1; }
pred_vec=-1;
while (!igraph_dqueue_empty(&Q)) {
long int actvect=(long int) igraph_dqueue_pop(&Q);
long int actdist=(long int) igraph_dqueue_pop(&Q);
long int succ_vec;
igraph_vector_t *neis=igraph_lazy_adjlist_get(&adjlist,
(igraph_integer_t) actvect);
long int i, n=igraph_vector_size(neis);
if (pred) { VECTOR(*pred)[actvect] = pred_vec; }
if (rank) { VECTOR(*rank) [actvect] = act_rank; }
if (order) { VECTOR(*order)[act_rank++] = actvect; }
if (dist) { VECTOR(*dist)[actvect] = actdist; }
igraph_vector_shuffle(neis);
for (i=0; i<n; i++) {
long int nei=(long int) VECTOR(*neis)[i];
if (! VECTOR(added)[nei]) {
VECTOR(added)[nei] = 1;
IGRAPH_CHECK(igraph_dqueue_push(&Q, nei));
IGRAPH_CHECK(igraph_dqueue_push(&Q, actdist+1));
if (father) { VECTOR(*father)[nei] = actvect; }
}
}
succ_vec = igraph_dqueue_empty(&Q) ? -1L :
(long int) igraph_dqueue_head(&Q);
if (callback) {
igraph_bool_t terminate=
callback(graph, (igraph_integer_t) actvect, (igraph_integer_t)
pred_vec, (igraph_integer_t) succ_vec,
(igraph_integer_t) act_rank-1, (igraph_integer_t) actdist,
extra);
if (terminate) {
igraph_lazy_adjlist_destroy(&adjlist);
igraph_dqueue_destroy(&Q);
igraph_vector_char_destroy(&added);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
}
if (succ) { VECTOR(*succ)[actvect] = succ_vec; }
pred_vec=actvect;
} /* while Q !empty */
} /* for actroot < no_of_nodes */
igraph_lazy_adjlist_destroy(&adjlist);
igraph_dqueue_destroy(&Q);
igraph_vector_char_destroy(&added);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
int igraph_decompose(const igraph_t *graph, igraph_vector_ptr_t *components,
igraph_connectedness_t mode,
long int maxcompno, long int minelements) {
long int actstart;
long int no_of_nodes=igraph_vcount(graph);
long int resco=0; /* number of graphs created so far */
char *already_added;
igraph_dqueue_t q;
igraph_vector_t verts;
igraph_vector_t neis;
long int i;
igraph_t *newg;
if (!igraph_is_directed(graph)) {
mode=IGRAPH_WEAK;
}
if (mode != IGRAPH_WEAK) {
IGRAPH_ERROR("only 'IGRAPH_WEAK' is implemented", IGRAPH_EINVAL);
}
if (maxcompno<0) {
maxcompno=LONG_MAX;
}
igraph_vector_ptr_clear(components);
IGRAPH_FINALLY(igraph_decompose_destroy, components);
already_added=igraph_Calloc(no_of_nodes, char);
if (already_added==0) {
IGRAPH_ERROR("Cannot decompose graph", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, already_added);
IGRAPH_CHECK(igraph_dqueue_init(&q, 100));
IGRAPH_FINALLY(igraph_dqueue_destroy, &q);
IGRAPH_VECTOR_INIT_FINALLY(&verts, 0);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
for(actstart=0; resco<maxcompno && actstart < no_of_nodes; actstart++) {
if (already_added[actstart]) { continue; }
IGRAPH_ALLOW_INTERRUPTION();
igraph_vector_clear(&verts);
already_added[actstart]=1;
IGRAPH_CHECK(igraph_vector_push_back(&verts, actstart));
IGRAPH_CHECK(igraph_dqueue_push(&q, actstart));
while (!igraph_dqueue_empty(&q) ) {
long int actvert=(long int) igraph_dqueue_pop(&q);
IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) actvert,
IGRAPH_ALL));
for (i=0; i<igraph_vector_size(&neis); i++) {
long int neighbor=(long int) VECTOR(neis)[i];
if (already_added[neighbor]==1) { continue; }
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
IGRAPH_CHECK(igraph_vector_push_back(&verts, neighbor));
already_added[neighbor]=1;
}
}
/* ok, we have a component */
if (igraph_vector_size(&verts)<minelements) { continue; }
newg=igraph_Calloc(1, igraph_t);
if (newg==0) {
IGRAPH_ERROR("Cannot decompose graph", IGRAPH_ENOMEM);
}
IGRAPH_CHECK(igraph_vector_ptr_push_back(components, newg));
IGRAPH_CHECK(igraph_induced_subgraph(graph, newg,
igraph_vss_vector(&verts),
IGRAPH_SUBGRAPH_AUTO));
resco++;
} /* for actstart++ */
igraph_vector_destroy(&neis);
igraph_vector_destroy(&verts);
igraph_dqueue_destroy(&q);
igraph_free(already_added);
IGRAPH_FINALLY_CLEAN(5); /* + components */
return 0;
}
int igraph_bfs(igraph_t *graph, igraph_integer_t vid, igraph_neimode_t mode,
igraph_vector_t *vids, igraph_vector_t *layers,
igraph_vector_t *parents) {
igraph_dqueue_t q;
long int vidspos=0;
igraph_vector_t neis;
long int no_of_nodes=igraph_vcount(graph);
long int i;
char *added;
long int lastlayer=-1;
if (!igraph_is_directed(graph)) { mode=IGRAPH_ALL; }
if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
mode != IGRAPH_ALL) {
IGRAPH_ERROR("Invalid mode argument", IGRAPH_EINVMODE);
}
/* temporary storage */
added=igraph_Calloc(no_of_nodes, char);
if (added==0) {
IGRAPH_ERROR("Cannot calculate BFS", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, added);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
IGRAPH_CHECK(igraph_dqueue_init(&q, 100));
IGRAPH_FINALLY(igraph_dqueue_destroy, &q);
/* results */
IGRAPH_CHECK(igraph_vector_resize(vids, no_of_nodes));
igraph_vector_clear(layers);
IGRAPH_CHECK(igraph_vector_resize(parents, no_of_nodes));
/* ok start with vid */
IGRAPH_CHECK(igraph_dqueue_push(&q, vid));
IGRAPH_CHECK(igraph_dqueue_push(&q, 0));
IGRAPH_CHECK(igraph_vector_push_back(layers, vidspos));
VECTOR(*vids)[vidspos++]=vid;
VECTOR(*parents)[(long int)vid]=vid;
added[(long int)vid]=1;
while (!igraph_dqueue_empty(&q)) {
long int actvect=igraph_dqueue_pop(&q);
long int actdist=igraph_dqueue_pop(&q);
IGRAPH_CHECK(igraph_neighbors(graph, &neis, actvect, mode));
for (i=0; i<igraph_vector_size(&neis); i++) {
long int neighbor=VECTOR(neis)[i];
if (added[neighbor]==0) {
added[neighbor]=1;
VECTOR(*parents)[neighbor]=actvect;
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
IGRAPH_CHECK(igraph_dqueue_push(&q, actdist+1));
if (lastlayer != actdist+1) {
IGRAPH_CHECK(igraph_vector_push_back(layers, vidspos));
}
VECTOR(*vids)[vidspos++]=neighbor;
lastlayer=actdist+1;
}
} /* for i in neis */
} /* while ! dqueue_empty */
IGRAPH_CHECK(igraph_vector_push_back(layers, vidspos));
igraph_vector_destroy(&neis);
igraph_dqueue_destroy(&q);
igraph_Free(added);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
int igraph_all_minimal_st_separators(const igraph_t *graph,
igraph_vector_ptr_t *separators) {
/*
* Some notes about the tricks used here. For finding the components
* of the graph after removing some vertices, we do the
* following. First we mark the vertices with the actual mark stamp
* (mark), then run breadth-first search on the graph, but not
* considering the marked vertices. Then we increase the mark. If
* there is integer overflow here, then we zero out the mark and set
* it to one. (We might as well just always zero it out.)
*
* For each separator the vertices are stored in vertex id order.
* This facilitates the comparison of the separators when we find a
* potential new candidate.
*
* To keep track of which separator we already used as a basis, we
* keep a boolean vector (already_tried). The try_next pointer show
* the next separator to try as a basis.
*/
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_t leaveout;
igraph_vector_bool_t already_tried;
long int try_next=0;
unsigned long int mark=1;
long int v;
igraph_adjlist_t adjlist;
igraph_vector_t components;
igraph_dqueue_t Q;
igraph_vector_t sorter;
igraph_vector_ptr_clear(separators);
IGRAPH_FINALLY(igraph_i_separators_free, separators);
IGRAPH_CHECK(igraph_vector_init(&leaveout, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_destroy, &leaveout);
IGRAPH_CHECK(igraph_vector_bool_init(&already_tried, 0));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &already_tried);
IGRAPH_CHECK(igraph_vector_init(&components, 0));
IGRAPH_FINALLY(igraph_vector_destroy, &components);
IGRAPH_CHECK(igraph_vector_reserve(&components, no_of_nodes*2));
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
IGRAPH_CHECK(igraph_dqueue_init(&Q, 100));
IGRAPH_FINALLY(igraph_dqueue_destroy, &Q);
IGRAPH_CHECK(igraph_vector_init(&sorter, 0));
IGRAPH_FINALLY(igraph_vector_destroy, &sorter);
IGRAPH_CHECK(igraph_vector_reserve(&sorter, no_of_nodes));
/* ---------------------------------------------------------------
* INITIALIZATION, we check whether the neighborhoods of the
* vertices separate the graph. The ones that do will form the
* initial basis.
*/
for (v=0; v<no_of_nodes; v++) {
/* Mark v and its neighbors */
igraph_vector_int_t *neis=igraph_adjlist_get(&adjlist, v);
long int i, n=igraph_vector_int_size(neis);
VECTOR(leaveout)[v]=mark;
for (i=0; i<n; i++) {
long int nei=(long int) VECTOR(*neis)[i];
VECTOR(leaveout)[nei]=mark;
}
/* Find the components */
IGRAPH_CHECK(igraph_i_clusters_leaveout(&adjlist, &components, &leaveout,
&mark, &Q));
/* Store the corresponding separators, N(C) for each component C */
IGRAPH_CHECK(igraph_i_separators_store(separators, &adjlist, &components,
&leaveout, &mark, &sorter));
}
/* ---------------------------------------------------------------
* GENERATION, we need to use all already found separators as
* basis and see if they generate more separators
*/
while (try_next < igraph_vector_ptr_size(separators)) {
igraph_vector_t *basis=VECTOR(*separators)[try_next];
long int b, basislen=igraph_vector_size(basis);
for (b=0; b<basislen; b++) {
/* Remove N(x) U basis */
long int x=(long int) VECTOR(*basis)[b];
igraph_vector_int_t *neis=igraph_adjlist_get(&adjlist, x);
long int i, n=igraph_vector_int_size(neis);
for (i=0; i<basislen; i++) {
long int sn=(long int) VECTOR(*basis)[i];
VECTOR(leaveout)[sn]=mark;
}
for (i=0; i<n; i++) {
long int nei=(long int) VECTOR(*neis)[i];
VECTOR(leaveout)[nei]=mark;
}
/* Find the components */
IGRAPH_CHECK(igraph_i_clusters_leaveout(&adjlist, &components,
&leaveout, &mark, &Q));
/* Store the corresponding separators, N(C) for each component C */
IGRAPH_CHECK(igraph_i_separators_store(separators, &adjlist,
&components, &leaveout, &mark,
&sorter));
}
try_next++;
}
/* --------------------------------------------------------------- */
igraph_vector_destroy(&sorter);
igraph_dqueue_destroy(&Q);
igraph_adjlist_destroy(&adjlist);
igraph_vector_destroy(&components);
igraph_vector_bool_destroy(&already_tried);
igraph_vector_destroy(&leaveout);
IGRAPH_FINALLY_CLEAN(7); /* +1 for separators */
return 0;
}
int main() {
igraph_dqueue_t q;
int i;
/* igraph_dqueue_init, igraph_dqueue_destroy, igraph_dqueue_empty */
igraph_dqueue_init(&q, 5);
if (!igraph_dqueue_empty(&q)) {
return 1;
}
igraph_dqueue_destroy(&q);
/* igraph_dqueue_push, igraph_dqueue_pop */
igraph_dqueue_init(&q, 4);
igraph_dqueue_push(&q, 1);
igraph_dqueue_push(&q, 2);
igraph_dqueue_push(&q, 3);
igraph_dqueue_push(&q, 4);
if (igraph_dqueue_pop(&q) != 1) {
return 2;
}
if (igraph_dqueue_pop(&q) != 2) {
return 3;
}
if (igraph_dqueue_pop(&q) != 3) {
return 4;
}
if (igraph_dqueue_pop(&q) != 4) {
return 5;
}
igraph_dqueue_destroy(&q);
/* igraph_dqueue_clear, igraph_dqueue_size */
igraph_dqueue_init(&q, 0);
if (igraph_dqueue_size(&q) != 0) {
return 6;
}
igraph_dqueue_clear(&q);
if (igraph_dqueue_size(&q) != 0) {
return 7;
}
for (i=0; i<10; i++) {
igraph_dqueue_push(&q, i);
}
igraph_dqueue_clear(&q);
if (igraph_dqueue_size(&q) != 0) {
return 8;
}
igraph_dqueue_destroy(&q);
/* TODO: igraph_dqueue_full */
/* igraph_dqueue_head, igraph_dqueue_back, igraph_dqueue_pop_back */
igraph_dqueue_init(&q, 0);
for (i=0; i<10; i++) {
igraph_dqueue_push(&q, i);
}
for (i=0; i<10; i++) {
if (igraph_dqueue_head(&q) != 0) {
return 9;
}
if (igraph_dqueue_back(&q) != 9-i) {
return 10;
}
if (igraph_dqueue_pop_back(&q) != 9-i) {
return 11;
}
}
igraph_dqueue_destroy(&q);
/* print */
igraph_dqueue_init(&q, 4);
igraph_dqueue_push(&q, 1);
igraph_dqueue_push(&q, 2);
igraph_dqueue_push(&q, 3);
igraph_dqueue_push(&q, 4);
igraph_dqueue_pop(&q);
igraph_dqueue_pop(&q);
igraph_dqueue_push(&q, 5);
igraph_dqueue_push(&q, 6);
igraph_dqueue_print(&q);
igraph_dqueue_clear(&q);
igraph_dqueue_print(&q);
igraph_dqueue_destroy(&q);
if (IGRAPH_FINALLY_STACK_SIZE() != 0) return 12;
return 0;
}
