int igraph_complementer(igraph_t *res, const igraph_t *graph,
igraph_bool_t loops) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_t edges;
igraph_vector_t neis;
long int i, j;
long int zero=0, *limit;
IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
if (igraph_is_directed(graph)) {
limit=&zero;
} else {
limit=&i;
}
for (i=0; i<no_of_nodes; i++) {
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) i,
IGRAPH_OUT));
if (loops) {
for (j=no_of_nodes-1; j>=*limit; j--) {
if (igraph_vector_empty(&neis) || j>igraph_vector_tail(&neis)) {
IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
IGRAPH_CHECK(igraph_vector_push_back(&edges, j));
} else {
igraph_vector_pop_back(&neis);
}
}
} else {
for (j=no_of_nodes-1; j>=*limit; j--) {
if (igraph_vector_empty(&neis) || j>igraph_vector_tail(&neis)) {
if (i!=j) {
IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
IGRAPH_CHECK(igraph_vector_push_back(&edges, j));
}
} else {
igraph_vector_pop_back(&neis);
}
}
}
}
IGRAPH_CHECK(igraph_create(res, &edges, (igraph_integer_t) no_of_nodes,
igraph_is_directed(graph)));
igraph_vector_destroy(&edges);
igraph_vector_destroy(&neis);
IGRAPH_I_ATTRIBUTE_DESTROY(res);
IGRAPH_I_ATTRIBUTE_COPY(res, graph, /*graph=*/1, /*vertex=*/1, /*edge=*/0);
IGRAPH_FINALLY_CLEAN(2);
return 0;
}
int igraph_adjlist_simplify(igraph_adjlist_t *al) {
long int i;
long int n=al->length;
igraph_vector_t mark;
IGRAPH_VECTOR_INIT_FINALLY(&mark, n);
for (i=0; i<n; i++) {
igraph_vector_t *v=&al->adjs[i];
long int j, l=igraph_vector_size(v);
VECTOR(mark)[i] = i+1;
for (j=0; j<l; /* nothing */) {
long int e=VECTOR(*v)[j];
if (VECTOR(mark)[e] != i+1) {
VECTOR(mark)[e]=i+1;
j++;
} else {
VECTOR(*v)[j] = igraph_vector_tail(v);
igraph_vector_pop_back(v);
l--;
}
}
}
igraph_vector_destroy(&mark);
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int igraph_i_maximal_cliques(const igraph_t *graph, igraph_i_maximal_clique_func_t func, void* data) {
int directed=igraph_is_directed(graph);
long int i, j, k, l;
igraph_integer_t no_of_nodes, nodes_to_check, nodes_done;
igraph_integer_t best_cand = 0, best_cand_degree = 0, best_fini_cand_degree;
igraph_adjlist_t adj_list;
igraph_stack_ptr_t stack;
igraph_i_maximal_cliques_stack_frame frame, *new_frame_ptr;
igraph_vector_t clique, new_cand, new_fini, cn, best_cand_nbrs, best_fini_cand_nbrs;
igraph_bool_t cont = 1;
int assret;
if (directed)
IGRAPH_WARNING("directionality of edges is ignored for directed graphs");
no_of_nodes = igraph_vcount(graph);
if (no_of_nodes == 0)
return IGRAPH_SUCCESS;
/* Construct an adjacency list representation */
IGRAPH_CHECK(igraph_adjlist_init(graph, &adj_list, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adj_list);
IGRAPH_CHECK(igraph_adjlist_simplify(&adj_list));
igraph_adjlist_sort(&adj_list);
/* Initialize stack */
IGRAPH_CHECK(igraph_stack_ptr_init(&stack, 0));
IGRAPH_FINALLY(igraph_i_maximal_cliques_stack_destroy, &stack);
/* Create the initial (empty) clique */
IGRAPH_VECTOR_INIT_FINALLY(&clique, 0);
/* Initialize new_cand, new_fini, cn, best_cand_nbrs and best_fini_cand_nbrs (will be used later) */
IGRAPH_VECTOR_INIT_FINALLY(&new_cand, 0);
IGRAPH_VECTOR_INIT_FINALLY(&new_fini, 0);
IGRAPH_VECTOR_INIT_FINALLY(&cn, 0);
IGRAPH_VECTOR_INIT_FINALLY(&best_cand_nbrs, 0);
IGRAPH_VECTOR_INIT_FINALLY(&best_fini_cand_nbrs, 0);
/* Find the vertex with the highest degree */
best_cand = 0; best_cand_degree = igraph_vector_size(igraph_adjlist_get(&adj_list, 0));
for (i = 1; i < no_of_nodes; i++) {
j = igraph_vector_size(igraph_adjlist_get(&adj_list, i));
if (j > best_cand_degree) {
best_cand = i;
best_cand_degree = j;
}
}
/* Create the initial stack frame */
IGRAPH_CHECK(igraph_vector_init_seq(&frame.cand, 0, no_of_nodes-1));
IGRAPH_FINALLY(igraph_vector_destroy, &frame.cand);
IGRAPH_CHECK(igraph_vector_init(&frame.fini, 0));
IGRAPH_FINALLY(igraph_vector_destroy, &frame.fini);
IGRAPH_CHECK(igraph_vector_init(&frame.cand_filtered, 0));
IGRAPH_FINALLY(igraph_vector_destroy, &frame.cand_filtered);
IGRAPH_CHECK(igraph_vector_difference_sorted(&frame.cand,
igraph_adjlist_get(&adj_list, best_cand), &frame.cand_filtered));
IGRAPH_FINALLY_CLEAN(3);
IGRAPH_FINALLY(igraph_i_maximal_cliques_stack_frame_destroy, &frame);
/* TODO: frame.cand and frame.fini should be a set instead of a vector */
/* Main loop starts here */
nodes_to_check = igraph_vector_size(&frame.cand_filtered); nodes_done = 0;
while (!igraph_vector_empty(&frame.cand_filtered) || !igraph_stack_ptr_empty(&stack)) {
if (igraph_vector_empty(&frame.cand_filtered)) {
/* No candidates left to check in this stack frame, pop out the previous stack frame */
igraph_i_maximal_cliques_stack_frame *newframe = igraph_stack_ptr_pop(&stack);
igraph_i_maximal_cliques_stack_frame_destroy(&frame);
frame = *newframe;
free(newframe);
if (igraph_stack_ptr_size(&stack) == 1) {
/* We will be using the next candidate node in the next iteration, so we can increase
* nodes_done by 1 */
nodes_done++;
}
/* For efficiency reasons, we only check for interruption and show progress here */
IGRAPH_PROGRESS("Maximal cliques: ", 100.0 * nodes_done / nodes_to_check, NULL);
IGRAPH_ALLOW_INTERRUPTION();
igraph_vector_pop_back(&clique);
continue;
}
/* Try the next node in the clique */
i = igraph_vector_pop_back(&frame.cand_filtered);
IGRAPH_CHECK(igraph_vector_push_back(&clique, i));
/* Remove the node from the candidate list */
assret=igraph_vector_binsearch(&frame.cand, i, &j); assert(assret);
igraph_vector_remove(&frame.cand, j);
/* Add the node to the finished list */
assret = !igraph_vector_binsearch(&frame.fini, i, &j); assert(assret);
IGRAPH_CHECK(igraph_vector_insert(&frame.fini, j, i));
/* Create new_cand and new_fini */
IGRAPH_CHECK(igraph_vector_intersect_sorted(&frame.cand, igraph_adjlist_get(&adj_list, i), &new_cand));
IGRAPH_CHECK(igraph_vector_intersect_sorted(&frame.fini, igraph_adjlist_get(&adj_list, i), &new_fini));
/* Do we have anything more to search? */
if (igraph_vector_empty(&new_cand)) {
if (igraph_vector_empty(&new_fini)) {
/* We have a maximal clique here */
IGRAPH_CHECK(func(&clique, data, &cont));
if (!cont) {
/* The callback function requested to stop the search */
break;
}
}
igraph_vector_pop_back(&clique);
continue;
}
if (igraph_vector_empty(&new_fini) && igraph_vector_size(&new_cand) == 1) {
/* Shortcut: only one node left */
IGRAPH_CHECK(igraph_vector_push_back(&clique, VECTOR(new_cand)[0]));
IGRAPH_CHECK(func(&clique, data, &cont));
if (!cont) {
/* The callback function requested to stop the search */
break;
}
igraph_vector_pop_back(&clique);
igraph_vector_pop_back(&clique);
continue;
}
/* Find the next best candidate node in new_fini */
l = igraph_vector_size(&new_cand);
best_cand_degree = -1;
j = igraph_vector_size(&new_fini);
for (i = 0; i < j; i++) {
k = (long int)VECTOR(new_fini)[i];
IGRAPH_CHECK(igraph_vector_intersect_sorted(&new_cand, igraph_adjlist_get(&adj_list, k), &cn));
if (igraph_vector_size(&cn) > best_cand_degree) {
best_cand_degree = igraph_vector_size(&cn);
IGRAPH_CHECK(igraph_vector_update(&best_fini_cand_nbrs, &cn));
if (best_cand_degree == l) {
/* Cool, we surely have the best candidate node here as best_cand_degree can't get any better */
break;
}
}
}
/* Shortcut here: we don't have to examine new_cand */
if (best_cand_degree == l) {
igraph_vector_pop_back(&clique);
continue;
}
/* Still finding best candidate node */
best_fini_cand_degree = best_cand_degree;
best_cand_degree = -1;
j = igraph_vector_size(&new_cand);
l = l - 1;
for (i = 0; i < j; i++) {
k = (long int)VECTOR(new_cand)[i];
IGRAPH_CHECK(igraph_vector_intersect_sorted(&new_cand, igraph_adjlist_get(&adj_list, k), &cn));
if (igraph_vector_size(&cn) > best_cand_degree) {
best_cand_degree = igraph_vector_size(&cn);
IGRAPH_CHECK(igraph_vector_update(&best_cand_nbrs, &cn));
if (best_cand_degree == l) {
/* Cool, we surely have the best candidate node here as best_cand_degree can't get any better */
break;
}
}
}
/* Create a new stack frame in case we back out later */
new_frame_ptr = igraph_Calloc(1, igraph_i_maximal_cliques_stack_frame);
if (new_frame_ptr == 0) {
IGRAPH_ERROR("cannot allocate new stack frame", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, new_frame_ptr);
*new_frame_ptr = frame;
memset(&frame, 0, sizeof(frame));
IGRAPH_CHECK(igraph_stack_ptr_push(&stack, new_frame_ptr));
IGRAPH_FINALLY_CLEAN(1); /* ownership of new_frame_ptr taken by the stack */
/* Ownership of the current frame and its vectors (frame.cand, frame.done, frame.cand_filtered)
* is taken by the stack from now on. Vectors in frame must be re-initialized with new_cand,
* new_fini and stuff. The old frame.cand and frame.fini won't be leaked because they are
* managed by the stack now. */
frame.cand = new_cand;
frame.fini = new_fini;
IGRAPH_CHECK(igraph_vector_init(&new_cand, 0));
IGRAPH_CHECK(igraph_vector_init(&new_fini, 0));
IGRAPH_CHECK(igraph_vector_init(&frame.cand_filtered, 0));
/* Adjust frame.cand_filtered */
if (best_cand_degree < best_fini_cand_degree) {
IGRAPH_CHECK(igraph_vector_difference_sorted(&frame.cand, &best_fini_cand_nbrs, &frame.cand_filtered));
} else {
IGRAPH_CHECK(igraph_vector_difference_sorted(&frame.cand, &best_cand_nbrs, &frame.cand_filtered));
}
}
IGRAPH_PROGRESS("Maximal cliques: ", 100.0, NULL);
igraph_adjlist_destroy(&adj_list);
igraph_vector_destroy(&clique);
igraph_vector_destroy(&new_cand);
igraph_vector_destroy(&new_fini);
igraph_vector_destroy(&cn);
igraph_vector_destroy(&best_cand_nbrs);
igraph_vector_destroy(&best_fini_cand_nbrs);
igraph_i_maximal_cliques_stack_frame_destroy(&frame);
igraph_i_maximal_cliques_stack_destroy(&stack);
IGRAPH_FINALLY_CLEAN(9);
return IGRAPH_SUCCESS;
}
/**
* \ingroup nongraph
* \function igraph_convex_hull
* \brief Determines the convex hull of a given set of points in the 2D plane
*
* </para><para>
* The convex hull is determined by the Graham scan algorithm.
* See the following reference for details:
*
* </para><para>
* Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford
* Stein. Introduction to Algorithms, Second Edition. MIT Press and
* McGraw-Hill, 2001. ISBN 0262032937. Pages 949-955 of section 33.3:
* Finding the convex hull.
*
* \param data vector containing the coordinates. The length of the
* vector must be even, since it contains X-Y coordinate pairs.
* \param resverts the vector containing the result, e.g. the vector of
* vertex indices used as the corners of the convex hull. Supply
* \c NULL here if you are only interested in the coordinates of
* the convex hull corners.
* \param rescoords the matrix containing the coordinates of the selected
* corner vertices. Supply \c NULL here if you are only interested in
* the vertex indices.
* \return Error code:
* \c IGRAPH_ENOMEM: not enough memory
*
* Time complexity: O(n log(n)) where n is the number of vertices
*/
int igraph_convex_hull(const igraph_matrix_t *data, igraph_vector_t *resverts,
igraph_matrix_t *rescoords) {
igraph_integer_t no_of_nodes;
long int i, pivot_idx=0, last_idx, before_last_idx, next_idx, j;
igraph_real_t* angles;
igraph_vector_t stack;
igraph_indheap_t order;
igraph_real_t px, py, cp;
no_of_nodes=igraph_matrix_nrow(data);
if (igraph_matrix_ncol(data) != 2) {
IGRAPH_ERROR("matrix must have 2 columns", IGRAPH_EINVAL);
}
if (no_of_nodes == 0) {
if (resverts != 0) {
IGRAPH_CHECK(igraph_vector_resize(resverts, 0));
}
if (rescoords != 0) {
IGRAPH_CHECK(igraph_matrix_resize(rescoords, 0, 2));
}
/**************************** this is an exit here *********/
return 0;
}
angles=igraph_Calloc(no_of_nodes, igraph_real_t);
if (!angles) IGRAPH_ERROR("not enough memory for angle array", IGRAPH_ENOMEM);
IGRAPH_FINALLY(free, angles);
IGRAPH_VECTOR_INIT_FINALLY(&stack, 0);
/* Search for the pivot vertex */
for (i=1; i<no_of_nodes; i++) {
if (MATRIX(*data, i, 1)<MATRIX(*data, pivot_idx, 1))
pivot_idx=i;
else if (MATRIX(*data, i, 1) == MATRIX(*data, pivot_idx, 1) &&
MATRIX(*data, i, 0) < MATRIX(*data, pivot_idx, 0))
pivot_idx=i;
}
px=MATRIX(*data, pivot_idx, 0);
py=MATRIX(*data, pivot_idx, 1);
/* Create angle array */
for (i=0; i<no_of_nodes; i++) {
if (i == pivot_idx) {
/* We can't calculate the angle of the pivot point with itself,
* so we use 10 here. This way, after sorting the angle vector,
* the pivot point will always be the first one, since the range
* of atan2 is -3.14..3.14 */
angles[i] = 10;
} else {
angles[i] = atan2(MATRIX(*data, i, 1)-py,
MATRIX(*data, i, 0)-px);
}
}
IGRAPH_CHECK(igraph_indheap_init_array(&order, angles, no_of_nodes));
IGRAPH_FINALLY(igraph_indheap_destroy, &order);
igraph_Free(angles);
IGRAPH_FINALLY_CLEAN(1);
if (no_of_nodes == 1) {
IGRAPH_CHECK(igraph_vector_push_back(&stack, 0));
igraph_indheap_delete_max(&order);
} else {
/* Do the trick */
IGRAPH_CHECK(igraph_vector_push_back(&stack, igraph_indheap_max_index(&order)-1));
igraph_indheap_delete_max(&order);
IGRAPH_CHECK(igraph_vector_push_back(&stack, igraph_indheap_max_index(&order)-1));
igraph_indheap_delete_max(&order);
j=2;
while (!igraph_indheap_empty(&order)) {
/* Determine whether we are at a left or right turn */
last_idx=VECTOR(stack)[j-1];
before_last_idx=VECTOR(stack)[j-2];
next_idx=(long)igraph_indheap_max_index(&order)-1;
igraph_indheap_delete_max(&order);
cp=(MATRIX(*data, last_idx, 0)-MATRIX(*data, before_last_idx, 0))*
(MATRIX(*data, next_idx, 1)-MATRIX(*data, before_last_idx, 1))-
(MATRIX(*data, next_idx, 0)-MATRIX(*data, before_last_idx, 0))*
(MATRIX(*data, last_idx, 1)-MATRIX(*data, before_last_idx, 1));
/*
printf("B L N cp: %d, %d, %d, %f [", before_last_idx, last_idx, next_idx, (float)cp);
for (k=0; k<j; k++) printf("%ld ", (long)VECTOR(stack)[k]);
printf("]\n");
*/
if (cp == 0) {
/* The last three points are collinear. Replace the last one in
* the stack to the newest one */
VECTOR(stack)[j-1]=next_idx;
} else if (cp < 0) {
/* We are turning into the right direction */
IGRAPH_CHECK(igraph_vector_push_back(&stack, next_idx));
j++;
} else {
/* No, skip back until we're okay */
while (cp >= 0 && j > 2) {
igraph_vector_pop_back(&stack);
j--;
last_idx=VECTOR(stack)[j-1];
before_last_idx=VECTOR(stack)[j-2];
cp=(MATRIX(*data, last_idx, 0)-MATRIX(*data, before_last_idx, 0))*
(MATRIX(*data, next_idx, 1)-MATRIX(*data, before_last_idx, 1))-
(MATRIX(*data, next_idx, 0)-MATRIX(*data, before_last_idx, 0))*
(MATRIX(*data, last_idx, 1)-MATRIX(*data, before_last_idx, 1));
}
IGRAPH_CHECK(igraph_vector_push_back(&stack, next_idx));
j++;
}
}
}
/* Create result vector */
if (resverts != 0) {
igraph_vector_clear(resverts);
IGRAPH_CHECK(igraph_vector_append(resverts, &stack));
}
if (rescoords != 0) {
igraph_matrix_select_rows(data, rescoords, &stack);
}
/* Free everything */
igraph_vector_destroy(&stack);
igraph_indheap_destroy(&order);
IGRAPH_FINALLY_CLEAN(2);
return 0;
}
int igraph_biconnected_components(const igraph_t *graph,
igraph_integer_t *no,
igraph_vector_ptr_t *tree_edges,
igraph_vector_ptr_t *component_edges,
igraph_vector_ptr_t *components,
igraph_vector_t *articulation_points) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_long_t nextptr;
igraph_vector_long_t num, low;
igraph_vector_bool_t found;
igraph_vector_int_t *adjedges;
igraph_stack_t path;
igraph_vector_t edgestack;
igraph_inclist_t inclist;
long int i, counter, rootdfs=0;
igraph_vector_long_t vertex_added;
long int comps=0;
igraph_vector_ptr_t *mycomponents=components, vcomponents;
IGRAPH_CHECK(igraph_vector_long_init(&nextptr, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &nextptr);
IGRAPH_CHECK(igraph_vector_long_init(&num, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &num);
IGRAPH_CHECK(igraph_vector_long_init(&low, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &low);
IGRAPH_CHECK(igraph_vector_bool_init(&found, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &found);
IGRAPH_CHECK(igraph_stack_init(&path, 100));
IGRAPH_FINALLY(igraph_stack_destroy, &path);
IGRAPH_VECTOR_INIT_FINALLY(&edgestack, 0);
IGRAPH_CHECK(igraph_vector_reserve(&edgestack, 100));
IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_inclist_destroy, &inclist);
IGRAPH_CHECK(igraph_vector_long_init(&vertex_added, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &vertex_added);
if (no) {
*no=0;
}
if (tree_edges) {
igraph_vector_ptr_clear(tree_edges);
}
if (components) {
igraph_vector_ptr_clear(components);
}
if (component_edges) {
igraph_vector_ptr_clear(component_edges);
}
if (articulation_points) {
igraph_vector_clear(articulation_points);
}
if (component_edges && !components) {
mycomponents=&vcomponents;
IGRAPH_CHECK(igraph_vector_ptr_init(mycomponents, 0));
IGRAPH_FINALLY(igraph_i_free_vectorlist, mycomponents);
}
for (i=0; i<no_of_nodes; i++) {
if (VECTOR(low)[i] != 0) { continue; } /* already visited */
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_stack_push(&path, i));
counter=1;
rootdfs=0;
VECTOR(low)[i]=VECTOR(num)[i]=counter++;
while (!igraph_stack_empty(&path)) {
long int n;
long int act=(long int) igraph_stack_top(&path);
long int actnext=VECTOR(nextptr)[act];
adjedges=igraph_inclist_get(&inclist, act);
n=igraph_vector_int_size(adjedges);
if (actnext < n) {
/* Step down (maybe) */
long int edge=(long int) VECTOR(*adjedges)[actnext];
long int nei=IGRAPH_OTHER(graph, edge, act);
if (VECTOR(low)[nei] == 0) {
if (act==i) { rootdfs++; }
IGRAPH_CHECK(igraph_vector_push_back(&edgestack, edge));
IGRAPH_CHECK(igraph_stack_push(&path, nei));
VECTOR(low)[nei] = VECTOR(num)[nei]=counter++;
} else {
/* Update low value if needed */
if (VECTOR(num)[nei] < VECTOR(low)[act]) {
VECTOR(low)[act]=VECTOR(num)[nei];
}
}
VECTOR(nextptr)[act] += 1;
} else {
/* Step up */
igraph_stack_pop(&path);
if (!igraph_stack_empty(&path)) {
long int prev=(long int) igraph_stack_top(&path);
/* Update LOW value if needed */
if (VECTOR(low)[act] < VECTOR(low)[prev]) {
VECTOR(low)[prev] = VECTOR(low)[act];
}
/* Check for articulation point */
if (VECTOR(low)[act] >= VECTOR(num)[prev]) {
if (articulation_points && !VECTOR(found)[prev]
&& prev != i /* the root */) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, prev));
VECTOR(found)[prev] = 1;
}
if (no) { *no += 1; }
/*------------------------------------*/
/* Record the biconnected component just found */
if (tree_edges || mycomponents) {
igraph_vector_t *v = 0, *v2 = 0;
comps++;
if (tree_edges) {
v=igraph_Calloc(1, igraph_vector_t);
if (!v) { IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM); }
IGRAPH_CHECK(igraph_vector_init(v, 0));
IGRAPH_FINALLY(igraph_vector_destroy, v);
}
if (mycomponents) {
v2=igraph_Calloc(1, igraph_vector_t);
if (!v2) { IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM); }
IGRAPH_CHECK(igraph_vector_init(v2, 0));
IGRAPH_FINALLY(igraph_vector_destroy, v2);
}
while (!igraph_vector_empty(&edgestack)) {
long int e=(long int) igraph_vector_pop_back(&edgestack);
long int from=IGRAPH_FROM(graph,e);
long int to=IGRAPH_TO(graph,e);
if (tree_edges) {
IGRAPH_CHECK(igraph_vector_push_back(v, e));
}
if (mycomponents) {
if (VECTOR(vertex_added)[from] != comps) {
VECTOR(vertex_added)[from] = comps;
IGRAPH_CHECK(igraph_vector_push_back(v2, from));
}
if (VECTOR(vertex_added)[to] != comps) {
VECTOR(vertex_added)[to] = comps;
IGRAPH_CHECK(igraph_vector_push_back(v2, to));
}
}
if (from==prev || to==prev) {
break;
}
}
if (mycomponents) {
IGRAPH_CHECK(igraph_vector_ptr_push_back(mycomponents, v2));
IGRAPH_FINALLY_CLEAN(1);
}
if (tree_edges) {
IGRAPH_CHECK(igraph_vector_ptr_push_back(tree_edges, v));
IGRAPH_FINALLY_CLEAN(1);
}
if (component_edges) {
igraph_vector_t *nodes=VECTOR(*mycomponents)[comps-1];
igraph_vector_t *vv=igraph_Calloc(1, igraph_vector_t);
long int ii, no_vert=igraph_vector_size(nodes);
if (!vv) { IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM); }
IGRAPH_CHECK(igraph_vector_init(vv, 0));
IGRAPH_FINALLY(igraph_vector_destroy, vv);
for (ii=0; ii<no_vert; ii++) {
long int vert=(long int) VECTOR(*nodes)[ii];
igraph_vector_int_t *edges=igraph_inclist_get(&inclist,
vert);
long int j, nn=igraph_vector_int_size(edges);
for (j=0; j<nn; j++) {
long int e=(long int) VECTOR(*edges)[j];
long int nei=IGRAPH_OTHER(graph, e, vert);
if (VECTOR(vertex_added)[nei] == comps && nei<vert) {
IGRAPH_CHECK(igraph_vector_push_back(vv, e));
}
}
}
IGRAPH_CHECK(igraph_vector_ptr_push_back(component_edges, vv));
IGRAPH_FINALLY_CLEAN(1);
}
} /* record component if requested */
/*------------------------------------*/
}
} /* !igraph_stack_empty(&path) */
}
} /* !igraph_stack_empty(&path) */
if (articulation_points && rootdfs >= 2) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, i));
}
} /* i < no_of_nodes */
if (mycomponents != components) {
igraph_i_free_vectorlist(mycomponents);
IGRAPH_FINALLY_CLEAN(1);
}
igraph_vector_long_destroy(&vertex_added);
igraph_inclist_destroy(&inclist);
igraph_vector_destroy(&edgestack);
igraph_stack_destroy(&path);
igraph_vector_bool_destroy(&found);
igraph_vector_long_destroy(&low);
igraph_vector_long_destroy(&num);
igraph_vector_long_destroy(&nextptr);
IGRAPH_FINALLY_CLEAN(8);
return 0;
}
int igraph_clusters_strong(const igraph_t *graph, igraph_vector_t *membership,
igraph_vector_t *csize, igraph_integer_t *no) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_t next_nei=IGRAPH_VECTOR_NULL;
long int i;
igraph_dqueue_t q=IGRAPH_DQUEUE_NULL;
long int no_of_clusters=1;
long int act_cluster_size;
igraph_vector_t out=IGRAPH_VECTOR_NULL;
igraph_vector_t tmp=IGRAPH_VECTOR_NULL;
/* The result */
IGRAPH_VECTOR_INIT_FINALLY(&next_nei, no_of_nodes);
IGRAPH_VECTOR_INIT_FINALLY(&out, 0);
IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
IGRAPH_VECTOR_INIT_FINALLY(&tmp, 0);
if (membership) {
IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
}
IGRAPH_CHECK(igraph_vector_reserve(&out, no_of_nodes));
igraph_vector_null(&out);
if (csize) {
igraph_vector_clear(csize);
}
for (i=0; i<no_of_nodes; i++) {
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_neighbors(graph, &tmp, (igraph_integer_t) i,
IGRAPH_OUT));
if (VECTOR(next_nei)[i] > igraph_vector_size(&tmp)) { continue; }
IGRAPH_CHECK(igraph_dqueue_push(&q, i));
while (!igraph_dqueue_empty(&q)) {
long int act_node=(long int) igraph_dqueue_back(&q);
IGRAPH_CHECK(igraph_neighbors(graph, &tmp, (igraph_integer_t) act_node,
IGRAPH_OUT));
if (VECTOR(next_nei)[act_node]==0) {
/* this is the first time we've met this vertex */
VECTOR(next_nei)[act_node]++;
} else if (VECTOR(next_nei)[act_node] <= igraph_vector_size(&tmp)) {
/* we've already met this vertex but it has more children */
long int neighbor=(long int) VECTOR(tmp)[(long int)
VECTOR(next_nei)[act_node]-1];
if (VECTOR(next_nei)[neighbor] == 0) {
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
}
VECTOR(next_nei)[act_node]++;
} else {
/* we've met this vertex and it has no more children */
IGRAPH_CHECK(igraph_vector_push_back(&out, act_node));
igraph_dqueue_pop_back(&q);
}
} /* while q */
} /* for */
/* OK, we've the 'out' values for the nodes, let's use them in
decreasing order with the help of a heap */
igraph_vector_null(&next_nei); /* mark already
added vertices */
while (!igraph_vector_empty(&out)) {
long int grandfather=(long int) igraph_vector_pop_back(&out);
IGRAPH_ALLOW_INTERRUPTION();
if (VECTOR(next_nei)[grandfather] != 0) { continue; }
VECTOR(next_nei)[grandfather]=1;
act_cluster_size=1;
if (membership) {
VECTOR(*membership)[grandfather]=no_of_clusters-1;
}
IGRAPH_CHECK(igraph_dqueue_push(&q, grandfather));
while (!igraph_dqueue_empty(&q)) {
long int act_node=(long int) igraph_dqueue_pop_back(&q);
IGRAPH_CHECK(igraph_neighbors(graph, &tmp, (igraph_integer_t) act_node,
IGRAPH_IN));
for (i=0; i<igraph_vector_size(&tmp); i++) {
long int neighbor=(long int) VECTOR(tmp)[i];
if (VECTOR(next_nei)[neighbor] != 0) { continue; }
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
VECTOR(next_nei)[neighbor]=1;
act_cluster_size++;
if (membership) {
VECTOR(*membership)[neighbor]=no_of_clusters-1;
}
}
}
no_of_clusters++;
if (csize) {
IGRAPH_CHECK(igraph_vector_push_back(csize, act_cluster_size));
}
}
if (no) { *no=(igraph_integer_t) no_of_clusters-1; }
/* Clean up, return */
igraph_vector_destroy(&out);
igraph_vector_destroy(&tmp);
igraph_dqueue_destroy(&q);
igraph_vector_destroy(&next_nei);
IGRAPH_FINALLY_CLEAN(4);
return 0;
}
int igraph_biconnected_components(const igraph_t *graph,
igraph_integer_t *no,
igraph_vector_ptr_t *components,
igraph_vector_t *articulation_points) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_long_t nextptr;
igraph_vector_long_t num, low;
igraph_vector_bool_t found;
igraph_vector_t *adjedges;
igraph_stack_t path;
igraph_vector_t edgestack;
igraph_adjedgelist_t adjedgelist;
long int i, counter, rootdfs=0;
IGRAPH_CHECK(igraph_vector_long_init(&nextptr, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &nextptr);
IGRAPH_CHECK(igraph_vector_long_init(&num, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &num);
IGRAPH_CHECK(igraph_vector_long_init(&low, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &low);
IGRAPH_CHECK(igraph_vector_bool_init(&found, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &found);
IGRAPH_CHECK(igraph_stack_init(&path, 100));
IGRAPH_FINALLY(igraph_stack_destroy, &path);
IGRAPH_VECTOR_INIT_FINALLY(&edgestack, 0);
IGRAPH_CHECK(igraph_vector_reserve(&edgestack, 100));
IGRAPH_CHECK(igraph_adjedgelist_init(graph, &adjedgelist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjedgelist_destroy, &adjedgelist);
if (no) {
*no=0;
}
if (components) {
igraph_vector_ptr_clear(components);
}
if (articulation_points) {
igraph_vector_clear(articulation_points);
}
for (i=0; i<no_of_nodes; i++) {
if (VECTOR(low)[i] != 0) {
continue; /* already visited */
}
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_stack_push(&path, i));
counter=1;
rootdfs=0;
VECTOR(low)[i]=VECTOR(num)[i]=counter++;
while (!igraph_stack_empty(&path)) {
long int n;
long int act=igraph_stack_top(&path);
long int actnext=VECTOR(nextptr)[act];
adjedges=igraph_adjedgelist_get(&adjedgelist, act);
n=igraph_vector_size(adjedges);
if (actnext < n) {
/* Step down (maybe) */
long int edge=VECTOR(*adjedges)[actnext];
long int nei=IGRAPH_OTHER(graph, edge, act);
if (VECTOR(low)[nei] == 0) {
if (act==i) {
rootdfs++;
}
IGRAPH_CHECK(igraph_vector_push_back(&edgestack, edge));
IGRAPH_CHECK(igraph_stack_push(&path, nei));
VECTOR(low)[nei] = VECTOR(num)[nei]=counter++;
} else {
/* Update low value if needed */
if (VECTOR(num)[nei] < VECTOR(low)[act]) {
VECTOR(low)[act]=VECTOR(num)[nei];
}
}
VECTOR(nextptr)[act] += 1;
} else {
/* Step up */
igraph_stack_pop(&path);
if (!igraph_stack_empty(&path)) {
long int prev=igraph_stack_top(&path);
/* Update LOW value if needed */
if (VECTOR(low)[act] < VECTOR(low)[prev]) {
VECTOR(low)[prev] = VECTOR(low)[act];
}
/* Check for articulation point */
if (VECTOR(low)[act] >= VECTOR(num)[prev]) {
if (articulation_points && !VECTOR(found)[prev]
&& prev != i /* the root */) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, prev));
VECTOR(found)[prev] = 1;
}
if (no) {
*no += 1;
}
if (components) {
igraph_vector_t *v=igraph_Calloc(1, igraph_vector_t);
IGRAPH_CHECK(igraph_vector_init(v, 0));
while (!igraph_vector_empty(&edgestack)) {
long int e=igraph_vector_pop_back(&edgestack);
IGRAPH_CHECK(igraph_vector_push_back(v, e));
if (IGRAPH_FROM(graph,e)==prev || IGRAPH_TO(graph,e)==prev) {
break;
}
}
IGRAPH_CHECK(igraph_vector_ptr_push_back(components, v));
}
}
} /* !igraph_stack_empty(&path) */
}
} /* !igraph_stack_empty(&path) */
if (articulation_points && rootdfs >= 2) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, i));
}
} /* i < no_of_nodes */
igraph_adjedgelist_destroy(&adjedgelist);
igraph_vector_destroy(&edgestack);
igraph_stack_destroy(&path);
igraph_vector_bool_destroy(&found);
igraph_vector_long_destroy(&low);
igraph_vector_long_destroy(&num);
igraph_vector_long_destroy(&nextptr);
IGRAPH_FINALLY_CLEAN(7);
return 0;
}
/**
* \ingroup nongraph
* \function igraph_convex_hull
* \brief Determines the convex hull of a given set of points in the 2D plane
*
* </para><para>
* The convex hull is determined by the Graham scan algorithm.
* See the following reference for details:
*
* </para><para>
* Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford
* Stein. Introduction to Algorithms, Second Edition. MIT Press and
* McGraw-Hill, 2001. ISBN 0262032937. Pages 949-955 of section 33.3:
* Finding the convex hull.
*
* \param data vector containing the coordinates. The length of the
* vector must be even, since it contains X-Y coordinate pairs.
* \param resverts the vector containing the result, e.g. the vector of
* vertex indices used as the corners of the convex hull. Supply
* \c NULL here if you are only interested in the coordinates of
* the convex hull corners.
* \param rescoords the matrix containing the coordinates of the selected
* corner vertices. Supply \c NULL here if you are only interested in
* the vertex indices.
* \return Error code:
* \c IGRAPH_ENOMEM: not enough memory
*
* Time complexity: O(n log(n)) where n is the number of vertices
*
* \example examples/simple/igraph_convex_hull.c
*/
int igraph_convex_hull(const igraph_matrix_t *data, igraph_vector_t *resverts,
igraph_matrix_t *rescoords) {
igraph_integer_t no_of_nodes;
long int i, pivot_idx=0, last_idx, before_last_idx, next_idx, j;
igraph_vector_t angles, stack, order;
igraph_real_t px, py, cp;
no_of_nodes=(igraph_integer_t) igraph_matrix_nrow(data);
if (igraph_matrix_ncol(data) != 2) {
IGRAPH_ERROR("matrix must have 2 columns", IGRAPH_EINVAL);
}
if (no_of_nodes == 0) {
if (resverts != 0) {
IGRAPH_CHECK(igraph_vector_resize(resverts, 0));
}
if (rescoords != 0) {
IGRAPH_CHECK(igraph_matrix_resize(rescoords, 0, 2));
}
/**************************** this is an exit here *********/
return 0;
}
IGRAPH_VECTOR_INIT_FINALLY(&angles, no_of_nodes);
IGRAPH_VECTOR_INIT_FINALLY(&stack, 0);
/* Search for the pivot vertex */
for (i=1; i<no_of_nodes; i++) {
if (MATRIX(*data, i, 1)<MATRIX(*data, pivot_idx, 1))
pivot_idx=i;
else if (MATRIX(*data, i, 1) == MATRIX(*data, pivot_idx, 1) &&
MATRIX(*data, i, 0) < MATRIX(*data, pivot_idx, 0))
pivot_idx=i;
}
px=MATRIX(*data, pivot_idx, 0);
py=MATRIX(*data, pivot_idx, 1);
/* Create angle array */
for (i=0; i<no_of_nodes; i++) {
if (i == pivot_idx) {
/* We can't calculate the angle of the pivot point with itself,
* so we use 10 here. This way, after sorting the angle vector,
* the pivot point will always be the first one, since the range
* of atan2 is -3.14..3.14 */
VECTOR(angles)[i] = 10;
} else {
VECTOR(angles)[i] = atan2(MATRIX(*data, i, 1)-py, MATRIX(*data, i, 0)-px);
}
}
/* Sort points by angles */
IGRAPH_VECTOR_INIT_FINALLY(&order, no_of_nodes);
IGRAPH_CHECK(igraph_vector_qsort_ind(&angles, &order, 0));
/* Check if two points have the same angle. If so, keep only the point that
* is farthest from the pivot */
j = 0;
last_idx = (long int) VECTOR(order)[0];
pivot_idx = (long int) VECTOR(order)[no_of_nodes - 1];
for (i=1; i < no_of_nodes; i++) {
next_idx = (long int) VECTOR(order)[i];
if (VECTOR(angles)[last_idx] == VECTOR(angles)[next_idx]) {
/* Keep the vertex that is farther from the pivot, drop the one that is
* closer */
px = pow(MATRIX(*data, last_idx, 0) - MATRIX(*data, pivot_idx, 0), 2) +
pow(MATRIX(*data, last_idx, 1) - MATRIX(*data, pivot_idx, 1), 2);
py = pow(MATRIX(*data, next_idx, 0) - MATRIX(*data, pivot_idx, 0), 2) +
pow(MATRIX(*data, next_idx, 1) - MATRIX(*data, pivot_idx, 1), 2);
if (px > py) {
VECTOR(order)[i] = -1;
} else {
VECTOR(order)[j] = -1;
last_idx = next_idx;
j = i;
}
} else {
last_idx = next_idx;
j = i;
}
}
j=0;
last_idx=-1;
before_last_idx=-1;
while (!igraph_vector_empty(&order)) {
next_idx=(long int)VECTOR(order)[igraph_vector_size(&order) - 1];
if (next_idx < 0) {
/* This vertex should be skipped; was excluded in an earlier step */
igraph_vector_pop_back(&order);
continue;
}
/* Determine whether we are at a left or right turn */
if (j < 2) {
/* Pretend that we are turning into the right direction if we have less
* than two items in the stack */
cp=-1;
} else {
cp=(MATRIX(*data, last_idx, 0)-MATRIX(*data, before_last_idx, 0))*
(MATRIX(*data, next_idx, 1)-MATRIX(*data, before_last_idx, 1))-
(MATRIX(*data, next_idx, 0)-MATRIX(*data, before_last_idx, 0))*
(MATRIX(*data, last_idx, 1)-MATRIX(*data, before_last_idx, 1));
}
/*
printf("B L N cp: %ld, %ld, %ld, %f [", before_last_idx, last_idx, next_idx, (float)cp);
for (int k=0; k<j; k++) printf("%ld ", (long)VECTOR(stack)[k]);
printf("]\n");
*/
if (cp < 0) {
/* We are turning into the right direction */
igraph_vector_pop_back(&order);
IGRAPH_CHECK(igraph_vector_push_back(&stack, next_idx));
before_last_idx = last_idx;
last_idx = next_idx;
j++;
} else {
/* No, skip back and try again in the next iteration */
igraph_vector_pop_back(&stack);
j--;
last_idx = before_last_idx;
before_last_idx = (j >= 2) ? (long int) VECTOR(stack)[j-2] : -1;
}
}
/* Create result vector */
if (resverts != 0) {
igraph_vector_clear(resverts);
IGRAPH_CHECK(igraph_vector_append(resverts, &stack));
}
if (rescoords != 0) {
igraph_matrix_select_rows(data, rescoords, &stack);
}
/* Free everything */
igraph_vector_destroy(&order);
igraph_vector_destroy(&stack);
igraph_vector_destroy(&angles);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
int igraph_compose(igraph_t *res, const igraph_t *g1, const igraph_t *g2,
igraph_vector_t *edge_map1, igraph_vector_t *edge_map2) {
long int no_of_nodes_left=igraph_vcount(g1);
long int no_of_nodes_right=igraph_vcount(g2);
long int no_of_nodes;
igraph_bool_t directed=igraph_is_directed(g1);
igraph_vector_t edges;
igraph_vector_t neis1, neis2;
long int i;
if (directed != igraph_is_directed(g2)) {
IGRAPH_ERROR("Cannot compose directed and undirected graph",
IGRAPH_EINVAL);
}
no_of_nodes= no_of_nodes_left > no_of_nodes_right ?
no_of_nodes_left : no_of_nodes_right;
IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
IGRAPH_VECTOR_INIT_FINALLY(&neis1, 0);
IGRAPH_VECTOR_INIT_FINALLY(&neis2, 0);
if (edge_map1) { igraph_vector_clear(edge_map1); }
if (edge_map2) { igraph_vector_clear(edge_map2); }
for (i=0; i<no_of_nodes_left; i++) {
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_incident(g1, &neis1, (igraph_integer_t) i,
IGRAPH_OUT));
while (!igraph_vector_empty(&neis1)) {
long int con=(long int) igraph_vector_pop_back(&neis1);
long int v1=IGRAPH_OTHER(g1, con, i);
if (v1 < no_of_nodes_right) {
IGRAPH_CHECK(igraph_incident(g2, &neis2, (igraph_integer_t) v1,
IGRAPH_OUT));
} else {
continue;
}
while (!igraph_vector_empty(&neis2)) {
long int con2=igraph_vector_pop_back(&neis2);
long int v2=IGRAPH_OTHER(g2, con2, v1);
IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
IGRAPH_CHECK(igraph_vector_push_back(&edges, v2));
if (edge_map1) {
IGRAPH_CHECK(igraph_vector_push_back(edge_map1, con));
}
if (edge_map2) {
IGRAPH_CHECK(igraph_vector_push_back(edge_map2, con2));
}
}
}
}
igraph_vector_destroy(&neis1);
igraph_vector_destroy(&neis2);
IGRAPH_FINALLY_CLEAN(2);
IGRAPH_CHECK(igraph_create(res, &edges, (igraph_integer_t) no_of_nodes,
directed));
igraph_vector_destroy(&edges);
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int igraph_clusters_strong(const igraph_t *graph, igraph_vector_t *membership,
igraph_vector_t *csize, igraph_integer_t *no) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_t next_nei=IGRAPH_VECTOR_NULL;
long int i, n, num_seen;
igraph_dqueue_t q=IGRAPH_DQUEUE_NULL;
long int no_of_clusters=1;
long int act_cluster_size;
igraph_vector_t out=IGRAPH_VECTOR_NULL;
const igraph_vector_int_t* tmp;
igraph_adjlist_t adjlist;
/* The result */
IGRAPH_VECTOR_INIT_FINALLY(&next_nei, no_of_nodes);
IGRAPH_VECTOR_INIT_FINALLY(&out, 0);
IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
if (membership) {
IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
}
IGRAPH_CHECK(igraph_vector_reserve(&out, no_of_nodes));
igraph_vector_null(&out);
if (csize) {
igraph_vector_clear(csize);
}
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_OUT));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
num_seen = 0;
for (i=0; i<no_of_nodes; i++) {
IGRAPH_ALLOW_INTERRUPTION();
tmp = igraph_adjlist_get(&adjlist, i);
if (VECTOR(next_nei)[i] > igraph_vector_int_size(tmp)) {
continue;
}
IGRAPH_CHECK(igraph_dqueue_push(&q, i));
while (!igraph_dqueue_empty(&q)) {
long int act_node=(long int) igraph_dqueue_back(&q);
tmp = igraph_adjlist_get(&adjlist, act_node);
if (VECTOR(next_nei)[act_node]==0) {
/* this is the first time we've met this vertex */
VECTOR(next_nei)[act_node]++;
} else if (VECTOR(next_nei)[act_node] <= igraph_vector_int_size(tmp)) {
/* we've already met this vertex but it has more children */
long int neighbor=(long int) VECTOR(*tmp)[(long int)
VECTOR(next_nei)[act_node]-1];
if (VECTOR(next_nei)[neighbor] == 0) {
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
}
VECTOR(next_nei)[act_node]++;
} else {
/* we've met this vertex and it has no more children */
IGRAPH_CHECK(igraph_vector_push_back(&out, act_node));
igraph_dqueue_pop_back(&q);
num_seen++;
if (num_seen % 10000 == 0) {
/* time to report progress and allow the user to interrupt */
IGRAPH_PROGRESS("Strongly connected components: ",
num_seen * 50.0 / no_of_nodes, NULL);
IGRAPH_ALLOW_INTERRUPTION();
}
}
} /* while q */
} /* for */
IGRAPH_PROGRESS("Strongly connected components: ", 50.0, NULL);
igraph_adjlist_destroy(&adjlist);
IGRAPH_FINALLY_CLEAN(1);
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_IN));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
/* OK, we've the 'out' values for the nodes, let's use them in
decreasing order with the help of a heap */
igraph_vector_null(&next_nei); /* mark already added vertices */
num_seen = 0;
while (!igraph_vector_empty(&out)) {
long int grandfather=(long int) igraph_vector_pop_back(&out);
if (VECTOR(next_nei)[grandfather] != 0) { continue; }
VECTOR(next_nei)[grandfather]=1;
act_cluster_size=1;
if (membership) {
VECTOR(*membership)[grandfather]=no_of_clusters-1;
}
IGRAPH_CHECK(igraph_dqueue_push(&q, grandfather));
num_seen++;
if (num_seen % 10000 == 0) {
/* time to report progress and allow the user to interrupt */
IGRAPH_PROGRESS("Strongly connected components: ",
50.0 + num_seen * 50.0 / no_of_nodes, NULL);
IGRAPH_ALLOW_INTERRUPTION();
}
while (!igraph_dqueue_empty(&q)) {
long int act_node=(long int) igraph_dqueue_pop_back(&q);
tmp = igraph_adjlist_get(&adjlist, act_node);
n = igraph_vector_int_size(tmp);
for (i=0; i<n; i++) {
long int neighbor=(long int) VECTOR(*tmp)[i];
if (VECTOR(next_nei)[neighbor] != 0) { continue; }
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
VECTOR(next_nei)[neighbor]=1;
act_cluster_size++;
if (membership) {
VECTOR(*membership)[neighbor]=no_of_clusters-1;
}
num_seen++;
if (num_seen % 10000 == 0) {
/* time to report progress and allow the user to interrupt */
IGRAPH_PROGRESS("Strongly connected components: ",
50.0 + num_seen * 50.0 / no_of_nodes, NULL);
IGRAPH_ALLOW_INTERRUPTION();
}
}
}
no_of_clusters++;
if (csize) {
IGRAPH_CHECK(igraph_vector_push_back(csize, act_cluster_size));
}
}
IGRAPH_PROGRESS("Strongly connected components: ", 100.0, NULL);
if (no) { *no=(igraph_integer_t) no_of_clusters-1; }
/* Clean up, return */
igraph_adjlist_destroy(&adjlist);
igraph_vector_destroy(&out);
igraph_dqueue_destroy(&q);
igraph_vector_destroy(&next_nei);
IGRAPH_FINALLY_CLEAN(4);
return 0;
}
