int igraph_i_maximal_or_largest_cliques_or_indsets(const igraph_t *graph,
igraph_vector_ptr_t *res,
igraph_integer_t *clique_number,
igraph_bool_t keep_only_largest,
igraph_bool_t complementer) {
igraph_i_max_ind_vsets_data_t clqdata;
long int no_of_nodes = igraph_vcount(graph), i;
if (igraph_is_directed(graph))
IGRAPH_WARNING("directionality of edges is ignored for directed graphs");
clqdata.matrix_size=no_of_nodes;
clqdata.keep_only_largest=keep_only_largest;
if (complementer)
IGRAPH_CHECK(igraph_adjlist_init_complementer(graph, &clqdata.adj_list, IGRAPH_ALL, 0));
else
IGRAPH_CHECK(igraph_adjlist_init(graph, &clqdata.adj_list, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjlist_destroy, &clqdata.adj_list);
clqdata.IS = igraph_Calloc(no_of_nodes, igraph_integer_t);
if (clqdata.IS == 0)
IGRAPH_ERROR("igraph_i_maximal_or_largest_cliques_or_indsets failed", IGRAPH_ENOMEM);
IGRAPH_FINALLY(igraph_free, clqdata.IS);
IGRAPH_VECTOR_INIT_FINALLY(&clqdata.deg, no_of_nodes);
for (i=0; i<no_of_nodes; i++)
VECTOR(clqdata.deg)[i] = igraph_vector_size(igraph_adjlist_get(&clqdata.adj_list, i));
clqdata.buckets = igraph_Calloc(no_of_nodes+1, igraph_set_t);
if (clqdata.buckets == 0)
IGRAPH_ERROR("igraph_maximal_or_largest_cliques_or_indsets failed", IGRAPH_ENOMEM);
IGRAPH_FINALLY(igraph_i_free_set_array, clqdata.buckets);
for (i=0; i<no_of_nodes; i++)
IGRAPH_CHECK(igraph_set_init(&clqdata.buckets[i], 0));
if (res) igraph_vector_ptr_clear(res);
/* Do the show */
clqdata.largest_set_size=0;
IGRAPH_CHECK(igraph_i_maximal_independent_vertex_sets_backtrack(graph, res, &clqdata, 0));
/* Cleanup */
for (i=0; i<no_of_nodes; i++) igraph_set_destroy(&clqdata.buckets[i]);
igraph_adjlist_destroy(&clqdata.adj_list);
igraph_vector_destroy(&clqdata.deg);
igraph_free(clqdata.IS);
igraph_free(clqdata.buckets);
IGRAPH_FINALLY_CLEAN(4);
if (clique_number) *clique_number = clqdata.largest_set_size;
return 0;
}
int igraph_local_scan_1_ecount_them(const igraph_t *us, const igraph_t *them,
igraph_vector_t *res,
const igraph_vector_t *weights_them,
igraph_neimode_t mode) {
int no_of_nodes=igraph_vcount(us);
igraph_adjlist_t adj_us;
igraph_inclist_t incs_them;
igraph_vector_int_t neis;
int node;
if (igraph_vcount(them) != no_of_nodes) {
IGRAPH_ERROR("Number of vertices must match in scan-1", IGRAPH_EINVAL);
}
if (igraph_is_directed(us) != igraph_is_directed(them)) {
IGRAPH_ERROR("Directedness must match in scan-1", IGRAPH_EINVAL);
}
if (weights_them &&
igraph_vector_size(weights_them) != igraph_ecount(them)) {
IGRAPH_ERROR("Invalid weight vector length in scan-1 (them)",
IGRAPH_EINVAL);
}
igraph_adjlist_init(us, &adj_us, mode);
IGRAPH_FINALLY(igraph_adjlist_destroy, &adj_us);
igraph_adjlist_simplify(&adj_us);
igraph_inclist_init(them, &incs_them, mode);
IGRAPH_FINALLY(igraph_inclist_destroy, &incs_them);
igraph_vector_int_init(&neis, no_of_nodes);
IGRAPH_FINALLY(igraph_vector_int_destroy, &neis);
igraph_vector_resize(res, no_of_nodes);
igraph_vector_null(res);
for (node=0; node < no_of_nodes; node++) {
igraph_vector_int_t *neis_us=igraph_adjlist_get(&adj_us, node);
igraph_vector_int_t *edges1_them=igraph_inclist_get(&incs_them, node);
int len1_us=igraph_vector_int_size(neis_us);
int len1_them=igraph_vector_int_size(edges1_them);
int i;
IGRAPH_ALLOW_INTERRUPTION();
/* Mark neighbors and self in us */
VECTOR(neis)[node] = node+1;
for (i = 0; i < len1_us; i++) {
int nei=VECTOR(*neis_us)[i];
VECTOR(neis)[nei] = node+1;
}
/* Crawl neighbors in them, first ego */
for (i = 0; i < len1_them; i++) {
int e=VECTOR(*edges1_them)[i];
int nei=IGRAPH_OTHER(them, e, node);
if (VECTOR(neis)[nei] == node+1) {
igraph_real_t w=weights_them ? VECTOR(*weights_them)[e] : 1;
VECTOR(*res)[node] += w;
}
}
/* Then the rest */
for (i = 0; i < len1_us; i++) {
int nei=VECTOR(*neis_us)[i];
igraph_vector_int_t *edges2_them=igraph_inclist_get(&incs_them, nei);
int j, len2_them=igraph_vector_int_size(edges2_them);
for (j = 0; j < len2_them; j++) {
int e2=VECTOR(*edges2_them)[j];
int nei2=IGRAPH_OTHER(them, e2, nei);
if (VECTOR(neis)[nei2] == node+1) {
igraph_real_t w=weights_them ? VECTOR(*weights_them)[e2] : 1;
VECTOR(*res)[node] += w;
}
}
}
/* For undirected, it was double counted */
if (mode == IGRAPH_ALL || ! igraph_is_directed(us)) {
VECTOR(*res)[node] /= 2.0;
}
} /* node < no_of_nodes */
igraph_vector_int_destroy(&neis);
igraph_inclist_destroy(&incs_them);
igraph_adjlist_destroy(&adj_us);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
int igraph_i_eigen_adjacency_arpack(const igraph_t *graph,
const igraph_eigen_which_t *which,
igraph_arpack_options_t *options,
igraph_arpack_storage_t* storage,
igraph_vector_t *values,
igraph_matrix_t *vectors,
igraph_vector_complex_t *cmplxvalues,
igraph_matrix_complex_t *cmplxvectors){
igraph_adjlist_t adjlist;
void *extra=(void*) &adjlist;
int n=igraph_vcount(graph);
if (!options) {
IGRAPH_ERROR("`options' must be given for ARPACK algorithm",
IGRAPH_EINVAL);
}
if (igraph_is_directed(graph)) {
IGRAPH_ERROR("ARPACK adjacency eigensolver not implemented for "
"directed graphs", IGRAPH_UNIMPLEMENTED);
}
if (which->pos == IGRAPH_EIGEN_INTERVAL) {
IGRAPH_ERROR("ARPACK adjacency eigensolver does not implement "
"`INTERNAL' eigenvalues", IGRAPH_UNIMPLEMENTED);
}
if (which->pos == IGRAPH_EIGEN_SELECT) {
IGRAPH_ERROR("ARPACK adjacency eigensolver does not implement "
"`SELECT' eigenvalues", IGRAPH_UNIMPLEMENTED);
}
if (which->pos == IGRAPH_EIGEN_ALL) {
IGRAPH_ERROR("ARPACK adjacency eigensolver does not implement "
"`ALL' eigenvalues", IGRAPH_UNIMPLEMENTED);
}
switch (which->pos) {
case IGRAPH_EIGEN_LM:
options->which[0]='L'; options->which[1]='M';
options->nev=which->howmany;
break;
case IGRAPH_EIGEN_SM:
options->which[0]='S'; options->which[1]='M';
options->nev=which->howmany;
break;
case IGRAPH_EIGEN_LA:
options->which[0]='L'; options->which[1]='A';
options->nev=which->howmany;
break;
case IGRAPH_EIGEN_SA:
options->which[0]='S'; options->which[1]='A';
options->nev=which->howmany;
break;
case IGRAPH_EIGEN_ALL:
options->which[0]='L'; options->which[1]='M';
options->nev=n;
break;
case IGRAPH_EIGEN_BE:
IGRAPH_ERROR("Eigenvectors from both ends with ARPACK",
IGRAPH_UNIMPLEMENTED);
/* TODO */
break;
case IGRAPH_EIGEN_INTERVAL:
IGRAPH_ERROR("Interval of eigenvectors with ARPACK",
IGRAPH_UNIMPLEMENTED);
/* TODO */
break;
case IGRAPH_EIGEN_SELECT:
IGRAPH_ERROR("Selected eigenvalues with ARPACK",
IGRAPH_UNIMPLEMENTED);
/* TODO */
break;
default:
/* This cannot happen */
break;
}
options->n=n;
options->ncv= 2*options->nev < n ? 2*options->nev : n;
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_IN));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
IGRAPH_CHECK(igraph_arpack_rssolve(igraph_i_eigen_adjacency_arpack_sym_cb,
extra, options, storage, values, vectors));
igraph_adjlist_destroy(&adjlist);
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;
}
int igraph_bipartite_projection_size(const igraph_t *graph,
const igraph_vector_bool_t *types,
igraph_integer_t *vcount1,
igraph_integer_t *ecount1,
igraph_integer_t *vcount2,
igraph_integer_t *ecount2) {
long int no_of_nodes=igraph_vcount(graph);
long int vc1=0, ec1=0, vc2=0, ec2=0;
igraph_adjlist_t adjlist;
igraph_vector_long_t added;
long int i;
IGRAPH_CHECK(igraph_vector_long_init(&added, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &added);
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
for (i=0; i<no_of_nodes; i++) {
igraph_vector_int_t *neis1;
long int neilen1, j;
long int *ecptr;
if (VECTOR(*types)[i]) {
vc2++;
ecptr=&ec2;
} else {
vc1++;
ecptr=&ec1;
}
neis1=igraph_adjlist_get(&adjlist, i);
neilen1=igraph_vector_int_size(neis1);
for (j=0; j<neilen1; j++) {
long int k, neilen2, nei=(long int) VECTOR(*neis1)[j];
igraph_vector_int_t *neis2=igraph_adjlist_get(&adjlist, nei);
if (IGRAPH_UNLIKELY(VECTOR(*types)[i] == VECTOR(*types)[nei])) {
IGRAPH_ERROR("Non-bipartite edge found in bipartite projection",
IGRAPH_EINVAL);
}
neilen2=igraph_vector_int_size(neis2);
for (k=0; k<neilen2; k++) {
long int nei2=(long int) VECTOR(*neis2)[k];
if (nei2 <= i) { continue; }
if (VECTOR(added)[nei2] == i+1) { continue; }
VECTOR(added)[nei2] = i+1;
(*ecptr)++;
}
}
}
*vcount1=(igraph_integer_t) vc1;
*ecount1=(igraph_integer_t) ec1;
*vcount2=(igraph_integer_t) vc2;
*ecount2=(igraph_integer_t) ec2;
igraph_adjlist_destroy(&adjlist);
igraph_vector_long_destroy(&added);
IGRAPH_FINALLY_CLEAN(2);
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 igraph_i_bipartite_projection(const igraph_t *graph,
const igraph_vector_bool_t *types,
igraph_t *proj,
int which,
igraph_vector_t *multiplicity) {
long int no_of_nodes=igraph_vcount(graph);
long int i, j, k;
igraph_integer_t remaining_nodes=0;
igraph_vector_t vertex_perm, vertex_index;
igraph_vector_t edges;
igraph_adjlist_t adjlist;
igraph_vector_int_t *neis1, *neis2;
long int neilen1, neilen2;
igraph_vector_long_t added;
igraph_vector_t mult;
if (which < 0) { return 0; }
IGRAPH_VECTOR_INIT_FINALLY(&vertex_perm, 0);
IGRAPH_CHECK(igraph_vector_reserve(&vertex_perm, no_of_nodes));
IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
IGRAPH_VECTOR_INIT_FINALLY(&vertex_index, no_of_nodes);
IGRAPH_CHECK(igraph_vector_long_init(&added, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &added);
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
if (multiplicity) {
IGRAPH_VECTOR_INIT_FINALLY(&mult, no_of_nodes);
igraph_vector_clear(multiplicity);
}
for (i=0; i<no_of_nodes; i++) {
if (VECTOR(*types)[i] == which) {
VECTOR(vertex_index)[i] = ++remaining_nodes;
igraph_vector_push_back(&vertex_perm, i);
}
}
for (i=0; i<no_of_nodes; i++) {
if (VECTOR(*types)[i] == which) {
long int new_i=(long int) VECTOR(vertex_index)[i]-1;
long int iedges=0;
neis1=igraph_adjlist_get(&adjlist, i);
neilen1=igraph_vector_int_size(neis1);
for (j=0; j<neilen1; j++) {
long int nei=(long int) VECTOR(*neis1)[j];
if (IGRAPH_UNLIKELY(VECTOR(*types)[i] == VECTOR(*types)[nei])) {
IGRAPH_ERROR("Non-bipartite edge found in bipartite projection",
IGRAPH_EINVAL);
}
neis2=igraph_adjlist_get(&adjlist, nei);
neilen2=igraph_vector_int_size(neis2);
for (k=0; k<neilen2; k++) {
long int nei2=(long int) VECTOR(*neis2)[k], new_nei2;
if (nei2 <= i) { continue; }
if (VECTOR(added)[nei2] == i+1) {
if (multiplicity) { VECTOR(mult)[nei2]+=1; }
continue;
}
VECTOR(added)[nei2] = i+1;
if (multiplicity) { VECTOR(mult)[nei2]=1; }
iedges++;
IGRAPH_CHECK(igraph_vector_push_back(&edges, new_i));
if (multiplicity) {
/* If we need the multiplicity as well, then we put in the
old vertex ids here and rewrite it later */
IGRAPH_CHECK(igraph_vector_push_back(&edges, nei2));
} else {
new_nei2=(long int) VECTOR(vertex_index)[nei2]-1;
IGRAPH_CHECK(igraph_vector_push_back(&edges, new_nei2));
}
}
}
if (multiplicity) {
/* OK, we need to go through all the edges added for vertex new_i
and check their multiplicity */
long int now=igraph_vector_size(&edges);
long int from=now-iedges*2;
for (j=from; j<now; j+=2) {
long int nei2=(long int) VECTOR(edges)[j+1];
long int new_nei2=(long int) VECTOR(vertex_index)[nei2]-1;
long int m=(long int) VECTOR(mult)[nei2];
VECTOR(edges)[j+1]=new_nei2;
IGRAPH_CHECK(igraph_vector_push_back(multiplicity, m));
}
}
} /* if VECTOR(*type)[i] == which */
}
if (multiplicity) {
igraph_vector_destroy(&mult);
IGRAPH_FINALLY_CLEAN(1);
}
igraph_adjlist_destroy(&adjlist);
igraph_vector_long_destroy(&added);
igraph_vector_destroy(&vertex_index);
IGRAPH_FINALLY_CLEAN(3);
IGRAPH_CHECK(igraph_create(proj, &edges, remaining_nodes,
/*directed=*/ 0));
igraph_vector_destroy(&edges);
IGRAPH_FINALLY_CLEAN(1);
IGRAPH_FINALLY(igraph_destroy, proj);
IGRAPH_I_ATTRIBUTE_DESTROY(proj);
IGRAPH_I_ATTRIBUTE_COPY(proj, graph, 1, 0, 0);
IGRAPH_CHECK(igraph_i_attribute_permute_vertices(graph, proj, &vertex_perm));
igraph_vector_destroy(&vertex_perm);
IGRAPH_FINALLY_CLEAN(2);
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;
}
int igraph_i_vertex_coloring_greedy_cn(const igraph_t *graph, igraph_vector_int_t *colors) {
long i, vertex, maxdeg;
long vc = igraph_vcount(graph);
igraph_2wheap_t cn; /* indexed heap storing number of already coloured neighbours */
igraph_vector_int_t neigh_colors;
igraph_adjlist_t adjlist;
IGRAPH_CHECK(igraph_vector_int_resize(colors, vc));
igraph_vector_int_fill(colors, 0);
/* Nothing to do for 0 or 1 vertices.
* Remember that colours are integers starting from 0,
* and the 'colors' vector is already 0-initialized above.
*/
if (vc <= 1)
return IGRAPH_SUCCESS;
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
/* find maximum degree and a corresponding vertex */
{
igraph_vector_t degree;
IGRAPH_CHECK(igraph_vector_init(°ree, 0));
IGRAPH_FINALLY(igraph_vector_destroy, °ree);
IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(), IGRAPH_ALL, 0));
vertex = igraph_vector_which_max(°ree);
maxdeg = VECTOR(degree)[vertex];
igraph_vector_destroy(°ree);
IGRAPH_FINALLY_CLEAN(1);
}
IGRAPH_CHECK(igraph_vector_int_init(&neigh_colors, 0));
IGRAPH_CHECK(igraph_vector_int_reserve(&neigh_colors, maxdeg));
IGRAPH_FINALLY(igraph_vector_int_destroy, &neigh_colors);
IGRAPH_CHECK(igraph_2wheap_init(&cn, vc));
IGRAPH_FINALLY(igraph_2wheap_destroy, &cn);
for (i=0; i < vc; ++i)
if (i != vertex)
igraph_2wheap_push_with_index(&cn, i, 0); /* should not fail since memory was already reserved */
while (1) {
igraph_vector_int_t *neighbors = igraph_adjlist_get(&adjlist, vertex);
long neigh_count = igraph_vector_int_size(neighbors);
/* colour current vertex */
{
igraph_integer_t col;
IGRAPH_CHECK(igraph_vector_int_resize(&neigh_colors, neigh_count));
for (i=0; i < neigh_count; ++i)
VECTOR(neigh_colors)[i] = VECTOR(*colors)[ VECTOR(*neighbors)[i] ];
igraph_vector_int_sort(&neigh_colors);
i=0;
col = 0;
do {
while (i < neigh_count && VECTOR(neigh_colors)[i] == col)
i++;
col++;
} while (i < neigh_count && VECTOR(neigh_colors)[i] == col);
VECTOR(*colors)[vertex] = col;
}
/* increment number of coloured neighbours for each neighbour of vertex */
for (i=0; i < neigh_count; ++i) {
long idx = VECTOR(*neighbors)[i];
if (igraph_2wheap_has_elem(&cn, idx))
igraph_2wheap_modify(&cn, idx, igraph_2wheap_get(&cn, idx) + 1);
}
/* stop if no more vertices left to colour */
if (igraph_2wheap_empty(&cn))
break;
igraph_2wheap_delete_max_index(&cn, &vertex);
IGRAPH_ALLOW_INTERRUPTION();
}
/* subtract 1 from each colour value, so that colours start at 0 */
igraph_vector_int_add_constant(colors, -1);
/* free data structures */
igraph_vector_int_destroy(&neigh_colors);
igraph_adjlist_destroy(&adjlist);
igraph_2wheap_destroy(&cn);
IGRAPH_FINALLY_CLEAN(3);
return IGRAPH_SUCCESS;
}
/**
* \ingroup structural
* \function igraph_betweenness_estimate
* \brief Estimated betweenness centrality of some vertices.
*
* </para><para>
* The betweenness centrality of a vertex is the number of geodesics
* going through it. If there are more than one geodesic between two
* vertices, the value of these geodesics are weighted by one over the
* number of geodesics. When estimating betweenness centrality, igraph
* takes into consideration only those paths that are shorter than or
* equal to a prescribed length. Note that the estimated centrality
* will always be less than the real one.
*
* \param graph The graph object.
* \param res The result of the computation, a vector containing the
* estimated betweenness scores for the specified vertices.
* \param vids The vertices of which the betweenness centrality scores
* will be estimated.
* \param directed Logical, if true directed paths will be considered
* for directed graphs. It is ignored for undirected graphs.
* \param cutoff The maximal length of paths that will be considered.
* If zero or negative, the exact betweenness will be calculated
* (no upper limit on path lengths).
* \return Error code:
* \c IGRAPH_ENOMEM, not enough memory for
* temporary data.
* \c IGRAPH_EINVVID, invalid vertex id passed in
* \p vids.
*
* Time complexity: O(|V||E|),
* |V| and
* |E| are the number of vertices and
* edges in the graph.
* Note that the time complexity is independent of the number of
* vertices for which the score is calculated.
*
* \sa Other centrality types: \ref igraph_degree(), \ref igraph_closeness().
* See \ref igraph_edge_betweenness() for calculating the betweenness score
* of the edges in a graph.
*/
int igraph_betweenness_estimate(const igraph_t *graph, igraph_vector_t *res,
const igraph_vs_t vids, igraph_bool_t directed,
igraph_integer_t cutoff) {
long int no_of_nodes=igraph_vcount(graph);
igraph_dqueue_t q=IGRAPH_DQUEUE_NULL;
long int *distance;
long int *nrgeo;
double *tmpscore;
igraph_stack_t stack=IGRAPH_STACK_NULL;
long int source;
long int j, k;
igraph_integer_t modein, modeout;
igraph_vit_t vit;
igraph_vector_t *neis;
igraph_adjlist_t adjlist_out, adjlist_in;
igraph_adjlist_t *adjlist_out_p, *adjlist_in_p;
IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
directed=directed && igraph_is_directed(graph);
if (directed) {
modeout=IGRAPH_OUT;
modein=IGRAPH_IN;
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist_out, IGRAPH_OUT));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist_out);
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist_in, IGRAPH_IN));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist_in);
adjlist_out_p=&adjlist_out;
adjlist_in_p=&adjlist_in;
} else {
modeout=modein=IGRAPH_ALL;
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist_out, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist_out);
adjlist_out_p=adjlist_in_p=&adjlist_out;
}
distance=igraph_Calloc(no_of_nodes, long int);
if (distance==0) {
IGRAPH_ERROR("betweenness failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, distance);
nrgeo=igraph_Calloc(no_of_nodes, long int);
if (nrgeo==0) {
IGRAPH_ERROR("betweenness failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, nrgeo);
tmpscore=igraph_Calloc(no_of_nodes, double);
if (tmpscore==0) {
IGRAPH_ERROR("betweenness failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, tmpscore);
IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
igraph_stack_init(&stack, no_of_nodes);
IGRAPH_FINALLY(igraph_stack_destroy, &stack);
IGRAPH_CHECK(igraph_vector_resize(res, IGRAPH_VIT_SIZE(vit)));
igraph_vector_null(res);
/* here we go */
for (source=0; source<no_of_nodes; source++) {
IGRAPH_PROGRESS("Betweenness centrality: ", 100.0*source/no_of_nodes, 0);
IGRAPH_ALLOW_INTERRUPTION();
memset(distance, 0, no_of_nodes*sizeof(long int));
memset(nrgeo, 0, no_of_nodes*sizeof(long int));
memset(tmpscore, 0, no_of_nodes*sizeof(double));
igraph_stack_clear(&stack); /* it should be empty anyway... */
IGRAPH_CHECK(igraph_dqueue_push(&q, source));
nrgeo[source]=1;
distance[source]=0;
while (!igraph_dqueue_empty(&q)) {
long int actnode=igraph_dqueue_pop(&q);
if (cutoff > 0 && distance[actnode] >= cutoff) continue;
neis = igraph_adjlist_get(adjlist_out_p, actnode);
for (j=0; j<igraph_vector_size(neis); j++) {
long int neighbor=VECTOR(*neis)[j];
if (nrgeo[neighbor] != 0) {
/* we've already seen this node, another shortest path? */
if (distance[neighbor]==distance[actnode]+1) {
nrgeo[neighbor]+=nrgeo[actnode];
}
} else {
/* we haven't seen this node yet */
nrgeo[neighbor]+=nrgeo[actnode];
distance[neighbor]=distance[actnode]+1;
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
IGRAPH_CHECK(igraph_stack_push(&stack, neighbor));
}
}
} /* while !igraph_dqueue_empty */
/* Ok, we've the distance of each node and also the number of
shortest paths to them. Now we do an inverse search, starting
with the farthest nodes. */
while (!igraph_stack_empty(&stack)) {
long int actnode=igraph_stack_pop(&stack);
if (distance[actnode]<=1) { continue; } /* skip source node */
/* set the temporary score of the friends */
neis = igraph_adjlist_get(adjlist_in_p, actnode);
for (j=0; j<igraph_vector_size(neis); j++) {
long int neighbor=VECTOR(*neis)[j];
if (distance[neighbor]==distance[actnode]-1 && nrgeo[neighbor] != 0) {
tmpscore[neighbor] +=
(tmpscore[actnode]+1)*nrgeo[neighbor]/nrgeo[actnode];
}
}
}
/* Ok, we've the scores for this source */
for (k=0, IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit);
IGRAPH_VIT_NEXT(vit), k++) {
long int node=IGRAPH_VIT_GET(vit);
VECTOR(*res)[k] += tmpscore[node];
tmpscore[node] = 0.0; /* in case a node is in vids multiple times */
}
} /* for source < no_of_nodes */
/* divide by 2 for undirected graph */
if (!directed) {
for (j=0; j<igraph_vector_size(res); j++) {
VECTOR(*res)[j] /= 2.0;
}
}
/* clean */
igraph_Free(distance);
igraph_Free(nrgeo);
igraph_Free(tmpscore);
igraph_dqueue_destroy(&q);
igraph_stack_destroy(&stack);
igraph_vit_destroy(&vit);
IGRAPH_FINALLY_CLEAN(6);
if (directed) {
igraph_adjlist_destroy(&adjlist_out);
igraph_adjlist_destroy(&adjlist_in);
IGRAPH_FINALLY_CLEAN(2);
} else {
igraph_adjlist_destroy(&adjlist_out);
IGRAPH_FINALLY_CLEAN(1);
}
return 0;
}
int igraph_pagerank(const igraph_t *graph, igraph_vector_t *vector,
igraph_real_t *value, const igraph_vs_t vids,
igraph_bool_t directed, igraph_real_t damping,
const igraph_vector_t *weights,
igraph_arpack_options_t *options) {
igraph_matrix_t values;
igraph_matrix_t vectors;
igraph_integer_t dirmode;
igraph_vector_t outdegree;
igraph_vector_t tmp;
long int i;
long int no_of_nodes=igraph_vcount(graph);
long int no_of_edges=igraph_ecount(graph);
options->n = igraph_vcount(graph);
options->nev = 1;
options->ncv = 3;
options->which[0]='L'; options->which[1]='M';
options->start=1; /* no random start vector */
directed = directed && igraph_is_directed(graph);
if (weights && igraph_vector_size(weights) != igraph_ecount(graph))
{
IGRAPH_ERROR("Invalid length of weights vector when calculating "
"PageRank scores", IGRAPH_EINVAL);
}
IGRAPH_MATRIX_INIT_FINALLY(&values, 0, 0);
IGRAPH_MATRIX_INIT_FINALLY(&vectors, options->n, 1);
if (directed) { dirmode=IGRAPH_IN; } else { dirmode=IGRAPH_ALL; }
IGRAPH_VECTOR_INIT_FINALLY(&outdegree, options->n);
IGRAPH_VECTOR_INIT_FINALLY(&tmp, options->n);
RNG_BEGIN();
if (!weights) {
igraph_adjlist_t adjlist;
igraph_i_pagerank_data_t data = { graph, &adjlist, damping,
&outdegree, &tmp };
IGRAPH_CHECK(igraph_degree(graph, &outdegree, igraph_vss_all(),
directed ? IGRAPH_OUT : IGRAPH_ALL, /*loops=*/ 0));
/* Avoid division by zero */
for (i=0; i<options->n; i++) {
if (VECTOR(outdegree)[i]==0) {
VECTOR(outdegree)[i]=1;
}
MATRIX(vectors, i, 0) = VECTOR(outdegree)[i];
}
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, dirmode));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
IGRAPH_CHECK(igraph_arpack_rnsolve(igraph_i_pagerank,
&data, options, 0, &values, &vectors));
igraph_adjlist_destroy(&adjlist);
IGRAPH_FINALLY_CLEAN(1);
} else {
igraph_adjedgelist_t adjedgelist;
igraph_i_pagerank_data2_t data = { graph, &adjedgelist, weights,
damping, &outdegree, &tmp };
IGRAPH_CHECK(igraph_adjedgelist_init(graph, &adjedgelist, dirmode));
IGRAPH_FINALLY(igraph_adjedgelist_destroy, &adjedgelist);
/* Weighted degree */
for (i=0; i<no_of_edges; i++) {
long int from=IGRAPH_FROM(graph, i);
long int to=IGRAPH_TO(graph, i);
igraph_real_t weight=VECTOR(*weights)[i];
VECTOR(outdegree)[from] += weight;
if (!directed) {
VECTOR(outdegree)[to] += weight;
}
}
/* Avoid division by zero */
for (i=0; i<options->n; i++) {
if (VECTOR(outdegree)[i]==0) {
VECTOR(outdegree)[i]=1;
}
MATRIX(vectors, i, 0) = VECTOR(outdegree)[i];
}
IGRAPH_CHECK(igraph_arpack_rnsolve(igraph_i_pagerank2,
&data, options, 0, &values, &vectors));
igraph_adjedgelist_destroy(&adjedgelist);
IGRAPH_FINALLY_CLEAN(1);
}
RNG_END();
igraph_vector_destroy(&tmp);
igraph_vector_destroy(&outdegree);
IGRAPH_FINALLY_CLEAN(2);
if (value) {
*value=MATRIX(values, 0, 0);
}
if (vector) {
long int i;
igraph_vit_t vit;
long int nodes_to_calc;
igraph_real_t sum=0;
for (i=0; i<no_of_nodes; i++) {
sum += MATRIX(vectors, i, 0);
}
IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
nodes_to_calc=IGRAPH_VIT_SIZE(vit);
IGRAPH_CHECK(igraph_vector_resize(vector, nodes_to_calc));
for (IGRAPH_VIT_RESET(vit), i=0; !IGRAPH_VIT_END(vit);
IGRAPH_VIT_NEXT(vit), i++) {
VECTOR(*vector)[i] = MATRIX(vectors, (long int)IGRAPH_VIT_GET(vit), 0);
VECTOR(*vector)[i] /= sum;
}
igraph_vit_destroy(&vit);
IGRAPH_FINALLY_CLEAN(1);
}
if (options->info) {
IGRAPH_WARNING("Non-zero return code from ARPACK routine!");
}
igraph_matrix_destroy(&vectors);
igraph_matrix_destroy(&values);
IGRAPH_FINALLY_CLEAN(2);
return 0;
}
int igraph_i_kleinberg(const igraph_t *graph, igraph_vector_t *vector,
igraph_real_t *value, igraph_bool_t scale,
igraph_arpack_options_t *options, int inout) {
igraph_adjlist_t myinadjlist, myoutadjlist;
igraph_adjlist_t *inadjlist, *outadjlist;
igraph_vector_t tmp;
igraph_vector_t values;
igraph_matrix_t vectors;
igraph_i_kleinberg_data_t extra;
long int i;
options->n=igraph_vcount(graph);
options->start=1;
IGRAPH_VECTOR_INIT_FINALLY(&values, 0);
IGRAPH_MATRIX_INIT_FINALLY(&vectors, options->n, 1);
IGRAPH_VECTOR_INIT_FINALLY(&tmp, options->n);
if (inout==0) {
inadjlist=&myinadjlist;
outadjlist=&myoutadjlist;
} else if (inout==1) {
inadjlist=&myoutadjlist;
outadjlist=&myinadjlist;
} else {
/* This should not happen */
IGRAPH_ERROR("Invalid 'inout' argument, plese do not call "
"this funtion directly", IGRAPH_FAILURE);
}
IGRAPH_CHECK(igraph_adjlist_init(graph, &myinadjlist, IGRAPH_IN));
IGRAPH_FINALLY(igraph_adjlist_destroy, &myinadjlist);
IGRAPH_CHECK(igraph_adjlist_init(graph, &myoutadjlist, IGRAPH_OUT));
IGRAPH_FINALLY(igraph_adjlist_destroy, &myoutadjlist);
IGRAPH_CHECK(igraph_degree(graph, &tmp, igraph_vss_all(), IGRAPH_ALL, 0));
for (i=0; i<options->n; i++) {
if (VECTOR(tmp)[i] != 0) {
MATRIX(vectors, i, 0) = VECTOR(tmp)[i];
} else {
MATRIX(vectors, i, 0) = 1.0;
}
}
extra.in=inadjlist; extra.out=outadjlist; extra.tmp=&tmp;
options->n = igraph_vcount(graph);
options->nev = 1;
options->ncv = 3;
options->which[0]='L'; options->which[1]='M';
options->start=1; /* no random start vector */
IGRAPH_CHECK(igraph_arpack_rssolve(igraph_i_kleinberg2, &extra,
options, 0, &values, &vectors));
igraph_adjlist_destroy(&myoutadjlist);
igraph_adjlist_destroy(&myinadjlist);
igraph_vector_destroy(&tmp);
IGRAPH_FINALLY_CLEAN(3);
if (value) {
*value = VECTOR(values)[0];
}
if (vector) {
igraph_real_t amax=0;
long int which=0;
long int i;
IGRAPH_CHECK(igraph_vector_resize(vector, options->n));
for (i=0; i<options->n; i++) {
igraph_real_t tmp;
VECTOR(*vector)[i] = MATRIX(vectors, i, 0);
tmp=fabs(VECTOR(*vector)[i]);
if (tmp>amax) { amax=tmp; which=i; }
}
if (scale && amax!=0) { igraph_vector_scale(vector, 1/VECTOR(*vector)[which]); }
}
if (options->info) {
IGRAPH_WARNING("Non-zero return code from ARPACK routine!");
}
igraph_matrix_destroy(&vectors);
igraph_vector_destroy(&values);
IGRAPH_FINALLY_CLEAN(2);
return 0;
}
/**
* \ingroup structural
* \function igraph_closeness_estimate
* \brief Closeness centrality estimations for some vertices.
*
* </para><para>
* The closeness centrality of a vertex measures how easily other
* vertices can be reached from it (or the other way: how easily it
* can be reached from the other vertices). It is defined as the
* number of the number of vertices minus one divided by the sum of the
* lengths of all geodesics from/to the given vertex. When estimating
* closeness centrality, igraph considers paths having a length less than
* or equal to a prescribed cutoff value.
*
* </para><para>
* If the graph is not connected, and there is no such path between two
* vertices, the number of vertices is used instead the length of the
* geodesic. This is always longer than the longest possible geodesic.
*
* </para><para>
* Since the estimation considers vertex pairs with a distance greater than
* the given value as disconnected, the resulting estimation will always be
* lower than the actual closeness centrality.
*
* \param graph The graph object.
* \param res The result of the computation, a vector containing the
* closeness centrality scores for the given vertices.
* \param vids Vector giving the vertices for which the closeness
* centrality scores will be computed.
* \param mode The type of shortest paths to be used for the
* calculation in directed graphs. Possible values:
* \clist
* \cli IGRAPH_OUT
* the lengths of the outgoing paths are calculated.
* \cli IGRAPH_IN
* the lengths of the incoming paths are calculated.
* \cli IGRAPH_ALL
* the directed graph is considered as an
* undirected one for the computation.
* \endclist
* \param cutoff The maximal length of paths that will be considered.
* If zero or negative, the exact closeness will be calculated
* (no upper limit on path lengths).
* \return Error code:
* \clist
* \cli IGRAPH_ENOMEM
* not enough memory for temporary data.
* \cli IGRAPH_EINVVID
* invalid vertex id passed.
* \cli IGRAPH_EINVMODE
* invalid mode argument.
* \endclist
*
* Time complexity: O(n|E|),
* n is the number
* of vertices for which the calculation is done and
* |E| is the number
* of edges in the graph.
*
* \sa Other centrality types: \ref igraph_degree(), \ref igraph_betweenness().
*/
int igraph_closeness_estimate(const igraph_t *graph, igraph_vector_t *res,
const igraph_vs_t vids, igraph_neimode_t mode,
igraph_integer_t cutoff) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_t already_counted, *neis;
long int i, j;
long int nodes_reached;
igraph_adjlist_t allneis;
igraph_dqueue_t q;
long int nodes_to_calc;
igraph_vit_t vit;
IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
nodes_to_calc=IGRAPH_VIT_SIZE(vit);
if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
mode != IGRAPH_ALL) {
IGRAPH_ERROR("calculating closeness", IGRAPH_EINVMODE);
}
IGRAPH_VECTOR_INIT_FINALLY(&already_counted, no_of_nodes);
IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
IGRAPH_CHECK(igraph_adjlist_init(graph, &allneis, mode));
IGRAPH_FINALLY(igraph_adjlist_destroy, &allneis);
IGRAPH_CHECK(igraph_vector_resize(res, nodes_to_calc));
igraph_vector_null(res);
for (IGRAPH_VIT_RESET(vit), i=0;
!IGRAPH_VIT_END(vit);
IGRAPH_VIT_NEXT(vit), i++) {
IGRAPH_CHECK(igraph_dqueue_push(&q, IGRAPH_VIT_GET(vit)));
IGRAPH_CHECK(igraph_dqueue_push(&q, 0));
nodes_reached=1;
VECTOR(already_counted)[(long int)IGRAPH_VIT_GET(vit)]=i+1;
IGRAPH_PROGRESS("Closeness: ", 100.0*i/no_of_nodes, NULL);
IGRAPH_ALLOW_INTERRUPTION();
while (!igraph_dqueue_empty(&q)) {
long int act=igraph_dqueue_pop(&q);
long int actdist=igraph_dqueue_pop(&q);
VECTOR(*res)[i] += actdist;
if (cutoff>0 && actdist>=cutoff) continue;
neis=igraph_adjlist_get(&allneis, act);
for (j=0; j<igraph_vector_size(neis); j++) {
long int neighbor=VECTOR(*neis)[j];
if (VECTOR(already_counted)[neighbor] == i+1) { continue; }
VECTOR(already_counted)[neighbor] = i+1;
nodes_reached++;
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
IGRAPH_CHECK(igraph_dqueue_push(&q, actdist+1));
}
}
VECTOR(*res)[i] += ((igraph_integer_t)no_of_nodes * (no_of_nodes-nodes_reached));
VECTOR(*res)[i] = (no_of_nodes-1) / VECTOR(*res)[i];
}
IGRAPH_PROGRESS("Closeness: ", 100.0, NULL);
/* Clean */
igraph_dqueue_destroy(&q);
igraph_vector_destroy(&already_counted);
igraph_vit_destroy(&vit);
igraph_adjlist_destroy(&allneis);
IGRAPH_FINALLY_CLEAN(4);
return 0;
}
int igraph_eigenvector_centrality(const igraph_t *graph, igraph_vector_t *vector,
igraph_real_t *value, igraph_bool_t scale,
const igraph_vector_t *weights,
igraph_arpack_options_t *options) {
igraph_vector_t values;
igraph_matrix_t vectors;
igraph_vector_t degree;
long int i;
options->n=igraph_vcount(graph);
options->start=1; /* no random start vector */
if (weights && igraph_vector_size(weights) != igraph_ecount(graph)) {
IGRAPH_ERROR("Invalid length of weights vector when calculating "
"eigenvector centrality", IGRAPH_EINVAL);
}
if (weights && igraph_is_directed(graph)) {
IGRAPH_WARNING("Weighted directed graph in eigenvector centrality");
}
IGRAPH_VECTOR_INIT_FINALLY(&values, 0);
IGRAPH_MATRIX_INIT_FINALLY(&vectors, options->n, 1);
IGRAPH_VECTOR_INIT_FINALLY(°ree, options->n);
IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(),
IGRAPH_ALL, /*loops=*/ 0));
for (i=0; i<options->n; i++) {
if (VECTOR(degree)[i]) {
MATRIX(vectors, i, 0) = VECTOR(degree)[i];
} else {
MATRIX(vectors, i, 0) = 1.0;
}
}
igraph_vector_destroy(°ree);
IGRAPH_FINALLY_CLEAN(1);
options->n = igraph_vcount(graph);
options->nev = 1;
options->ncv = 3;
options->which[0]='L'; options->which[1]='A';
options->start=1; /* no random start vector */
if (!weights) {
igraph_adjlist_t adjlist;
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
IGRAPH_CHECK(igraph_arpack_rssolve(igraph_i_eigenvector_centrality,
&adjlist, options, 0, &values, &vectors));
igraph_adjlist_destroy(&adjlist);
IGRAPH_FINALLY_CLEAN(1);
} else {
igraph_adjedgelist_t adjedgelist;
igraph_i_eigenvector_centrality_t data = { graph, &adjedgelist, weights };
IGRAPH_CHECK(igraph_adjedgelist_init(graph, &adjedgelist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjedgelist_destroy, &adjedgelist);
IGRAPH_CHECK(igraph_arpack_rssolve(igraph_i_eigenvector_centrality2,
&data, options, 0, &values, &vectors));
igraph_adjedgelist_destroy(&adjedgelist);
IGRAPH_FINALLY_CLEAN(1);
}
if (value) {
*value=VECTOR(values)[0];
}
if (vector) {
igraph_real_t amax=0;
long int which=0;
long int i;
IGRAPH_CHECK(igraph_vector_resize(vector, options->n));
for (i=0; i<options->n; i++) {
igraph_real_t tmp;
VECTOR(*vector)[i] = MATRIX(vectors, i, 0);
tmp=fabs(VECTOR(*vector)[i]);
if (tmp>amax) { amax=tmp; which=i; }
}
if (scale && amax!=0) { igraph_vector_scale(vector, 1/VECTOR(*vector)[which]); }
}
if (options->info) {
IGRAPH_WARNING("Non-zero return code from ARPACK routine!");
}
igraph_matrix_destroy(&vectors);
igraph_vector_destroy(&values);
IGRAPH_FINALLY_CLEAN(2);
return 0;
}
