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_vector_rank(const igraph_vector_t *v, igraph_vector_t *res,
long int nodes) {
igraph_vector_t rad;
igraph_vector_t ptr;
long int edges = igraph_vector_size(v);
long int i, c=0;
IGRAPH_VECTOR_INIT_FINALLY(&rad, nodes);
IGRAPH_VECTOR_INIT_FINALLY(&ptr, edges);
IGRAPH_CHECK(igraph_vector_resize(res, edges));
for (i=0; i<edges; i++) {
long int elem=VECTOR(*v)[i];
VECTOR(ptr)[i] = VECTOR(rad)[elem];
VECTOR(rad)[elem] = i+1;
}
for (i=0; i<nodes; i++) {
long int p=VECTOR(rad)[i];
while (p != 0) {
VECTOR(*res)[p-1]=c++;
p=VECTOR(ptr)[p-1];
}
}
igraph_vector_destroy(&ptr);
igraph_vector_destroy(&rad);
IGRAPH_FINALLY_CLEAN(2);
return 0;
}
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_get_edgelist(const igraph_t *graph, igraph_vector_t *res, igraph_bool_t bycol) {
igraph_eit_t edgeit;
long int no_of_edges=igraph_ecount(graph);
long int vptr=0;
igraph_integer_t from, to;
IGRAPH_CHECK(igraph_vector_resize(res, no_of_edges*2));
IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID),
&edgeit));
IGRAPH_FINALLY(igraph_eit_destroy, &edgeit);
if (bycol) {
while (!IGRAPH_EIT_END(edgeit)) {
igraph_edge(graph, IGRAPH_EIT_GET(edgeit), &from, &to);
VECTOR(*res)[vptr]=from;
VECTOR(*res)[vptr+no_of_edges]=to;
vptr++;
IGRAPH_EIT_NEXT(edgeit);
}
} else {
while (!IGRAPH_EIT_END(edgeit)) {
igraph_edge(graph, IGRAPH_EIT_GET(edgeit), &from, &to);
VECTOR(*res)[vptr++]=from;
VECTOR(*res)[vptr++]=to;
IGRAPH_EIT_NEXT(edgeit);
}
}
igraph_eit_destroy(&edgeit);
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int igraph_i_cliquer_callback(const igraph_t *graph,
igraph_integer_t min_size, igraph_integer_t max_size,
igraph_clique_handler_t *cliquehandler_fn, void *arg)
{
graph_t *g;
struct callback_data cd;
igraph_integer_t vcount = igraph_vcount(graph);
if (vcount == 0)
return IGRAPH_SUCCESS;
if (min_size <= 0) min_size = 1;
if (max_size <= 0) max_size = 0;
if (max_size > 0 && max_size < min_size)
IGRAPH_ERROR("max_size must not be smaller than min_size", IGRAPH_EINVAL);
igraph_to_cliquer(graph, &g);
IGRAPH_FINALLY(graph_free, g);
cd.handler = cliquehandler_fn;
cd.arg = arg;
igraph_cliquer_opt.user_data = &cd;
igraph_cliquer_opt.user_function = &callback_callback;
CLIQUER_INTERRUPTABLE(clique_unweighted_find_all(g, min_size, max_size, /* maximal= */ FALSE, &igraph_cliquer_opt));
graph_free(g);
IGRAPH_FINALLY_CLEAN(1);
return IGRAPH_SUCCESS;
}
int igraph_i_weighted_clique_number(const igraph_t *graph,
const igraph_vector_t *vertex_weights, igraph_real_t *res)
{
graph_t *g;
igraph_integer_t vcount = igraph_vcount(graph);
if (vcount == 0) {
*res = 0;
return IGRAPH_SUCCESS;
}
igraph_to_cliquer(graph, &g);
IGRAPH_FINALLY(graph_free, g);
IGRAPH_CHECK(set_weights(vertex_weights, g));
igraph_cliquer_opt.user_function = NULL;
/* we are not using a callback function, thus this is not interruptable */
*res = clique_max_weight(g, &igraph_cliquer_opt);
graph_free(g);
IGRAPH_FINALLY_CLEAN(1);
return IGRAPH_SUCCESS;
}
int igraph_inclist_init(const igraph_t *graph,
igraph_inclist_t *il,
igraph_neimode_t mode) {
long int i;
if (mode != IGRAPH_IN && mode != IGRAPH_OUT && mode != IGRAPH_ALL) {
IGRAPH_ERROR("Cannot create incidence list view", IGRAPH_EINVMODE);
}
if (!igraph_is_directed(graph)) { mode=IGRAPH_ALL; }
il->length=igraph_vcount(graph);
il->incs=igraph_Calloc(il->length, igraph_vector_t);
if (il->incs == 0) {
IGRAPH_ERROR("Cannot create incidence list view", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_inclist_destroy, il);
for (i=0; i<il->length; i++) {
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_vector_init(&il->incs[i], 0));
IGRAPH_CHECK(igraph_incident(graph, &il->incs[i], i, mode));
}
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
/* Shrinks communities into single vertices, keeping all the edges.
* This method is internal because it destroys the graph in-place and
* creates a new one -- this is fine for the multilevel community
* detection where a copy of the original graph is used anyway.
* The membership vector will also be rewritten by the underlying
* igraph_membership_reindex call */
int igraph_i_multilevel_shrink(igraph_t *graph, igraph_vector_t *membership) {
igraph_vector_t edges;
long int no_of_nodes = igraph_vcount(graph);
long int no_of_edges = igraph_ecount(graph);
igraph_bool_t directed = igraph_is_directed(graph);
long int i;
igraph_eit_t eit;
if (no_of_nodes == 0)
return 0;
if (igraph_vector_size(membership) < no_of_nodes) {
IGRAPH_ERROR("cannot shrink graph, membership vector too short",
IGRAPH_EINVAL);
}
IGRAPH_VECTOR_INIT_FINALLY(&edges, no_of_edges * 2);
IGRAPH_CHECK(igraph_reindex_membership(membership, 0));
/* Create the new edgelist */
igraph_eit_create(graph, igraph_ess_all(IGRAPH_EDGEORDER_ID), &eit);
IGRAPH_FINALLY(igraph_eit_destroy, &eit);
i = 0;
while (!IGRAPH_EIT_END(eit)) {
igraph_integer_t from, to;
IGRAPH_CHECK(igraph_edge(graph, IGRAPH_EIT_GET(eit), &from, &to));
VECTOR(edges)[i++] = VECTOR(*membership)[(long int) from];
VECTOR(edges)[i++] = VECTOR(*membership)[(long int) to];
IGRAPH_EIT_NEXT(eit);
}
igraph_eit_destroy(&eit);
IGRAPH_FINALLY_CLEAN(1);
/* Create the new graph */
igraph_destroy(graph);
no_of_nodes = (long int) igraph_vector_max(membership)+1;
IGRAPH_CHECK(igraph_create(graph, &edges, (igraph_integer_t) no_of_nodes,
directed));
igraph_vector_destroy(&edges);
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int igraph_i_weighted_cliques(const igraph_t *graph,
const igraph_vector_t *vertex_weights, igraph_vector_ptr_t *res,
igraph_real_t min_weight, igraph_real_t max_weight, igraph_bool_t maximal)
{
graph_t *g;
igraph_integer_t vcount = igraph_vcount(graph);
if (vcount == 0) {
igraph_vector_ptr_clear(res);
return IGRAPH_SUCCESS;
}
if (min_weight != (int) min_weight) {
IGRAPH_WARNING("Only integer vertex weights are supported; the minimum weight will be truncated to its integer part");
min_weight = (int) min_weight;
}
if (max_weight != (int) max_weight) {
IGRAPH_WARNING("Only integer vertex weights are supported; the maximum weight will be truncated to its integer part");
max_weight = (int) max_weight;
}
if (min_weight <= 0) min_weight = 1;
if (max_weight <= 0) max_weight = 0;
if (max_weight > 0 && max_weight < min_weight)
IGRAPH_ERROR("max_weight must not be smaller than min_weight", IGRAPH_EINVAL);
igraph_to_cliquer(graph, &g);
IGRAPH_FINALLY(graph_free, g);
IGRAPH_CHECK(set_weights(vertex_weights, g));
igraph_vector_ptr_clear(res);
igraph_cliquer_opt.user_data = res;
igraph_cliquer_opt.user_function = &collect_cliques_callback;
IGRAPH_FINALLY(free_clique_list, res);
CLIQUER_INTERRUPTABLE(clique_find_all(g, min_weight, max_weight, maximal, &igraph_cliquer_opt));
IGRAPH_FINALLY_CLEAN(1);
graph_free(g);
IGRAPH_FINALLY_CLEAN(1);
return IGRAPH_SUCCESS;
}
int igraph_adjlist_init_complementer(const igraph_t *graph,
igraph_adjlist_t *al,
igraph_neimode_t mode,
igraph_bool_t loops) {
long int i, j, k, n;
igraph_bool_t* seen;
igraph_vector_t vec;
if (mode != IGRAPH_IN && mode != IGRAPH_OUT && mode != IGRAPH_ALL) {
IGRAPH_ERROR("Cannot create complementer adjlist view", IGRAPH_EINVMODE);
}
if (!igraph_is_directed(graph)) { mode=IGRAPH_ALL; }
al->length=igraph_vcount(graph);
al->adjs=igraph_Calloc(al->length, igraph_vector_t);
if (al->adjs == 0) {
IGRAPH_ERROR("Cannot create complementer adjlist view", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_adjlist_destroy, al);
n=al->length;
seen=igraph_Calloc(n, igraph_bool_t);
if (seen==0) {
IGRAPH_ERROR("Cannot create complementer adjlist view", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, seen);
IGRAPH_VECTOR_INIT_FINALLY(&vec, 0);
for (i=0; i<al->length; i++) {
IGRAPH_ALLOW_INTERRUPTION();
igraph_neighbors(graph, &vec, i, mode);
memset(seen, 0, sizeof(igraph_bool_t)*al->length);
n=al->length;
if (!loops) { seen[i] = 1; n--; }
for (j=0; j<igraph_vector_size(&vec); j++) {
if (! seen [ (long int) VECTOR(vec)[j] ] ) {
n--;
seen[ (long int) VECTOR(vec)[j] ] = 1;
}
}
IGRAPH_CHECK(igraph_vector_init(&al->adjs[i], n));
for (j=0, k=0; k<n; j++) {
if (!seen[j]) {
VECTOR(al->adjs[i])[k++] = j;
}
}
}
igraph_Free(seen);
igraph_vector_destroy(&vec);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
int igraph_i_separators_store(igraph_vector_ptr_t *separators,
const igraph_adjlist_t *adjlist,
igraph_vector_t *components,
igraph_vector_t *leaveout,
unsigned long int *mark,
igraph_vector_t *sorter) {
/* We need to stote N(C), the neighborhood of C, but only if it is
* not already stored among the separators.
*/
long int cptr=0, next, complen=igraph_vector_size(components);
while (cptr < complen) {
long int saved=cptr;
igraph_vector_clear(sorter);
/* Calculate N(C) for the next C */
while ( (next=(long int) VECTOR(*components)[cptr++]) != -1) {
VECTOR(*leaveout)[next] = *mark;
}
cptr=saved;
while ( (next=(long int) VECTOR(*components)[cptr++]) != -1) {
igraph_vector_int_t *neis=igraph_adjlist_get(adjlist, next);
long int j, nn=igraph_vector_int_size(neis);
for (j=0; j<nn; j++) {
long int nei=(long int) VECTOR(*neis)[j];
if (VECTOR(*leaveout)[nei] != *mark) {
igraph_vector_push_back(sorter, nei);
VECTOR(*leaveout)[nei] = *mark;
}
}
}
igraph_vector_sort(sorter);
UPDATEMARK();
/* Add it to the list of separators, if it is new */
if (igraph_i_separators_newsep(separators, sorter)) {
igraph_vector_t *newc=igraph_Calloc(1, igraph_vector_t);
if (!newc) {
IGRAPH_ERROR("Cannot calculate minimal separators", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, newc);
igraph_vector_copy(newc, sorter);
IGRAPH_FINALLY(igraph_vector_destroy, newc);
IGRAPH_CHECK(igraph_vector_ptr_push_back(separators, newc));
IGRAPH_FINALLY_CLEAN(2);
}
} /* while cptr < complen */
return 0;
}
int igraph_i_maximum_bipartite_matching_unweighted_relabel(const igraph_t* graph,
const igraph_vector_bool_t* types, igraph_vector_t* labels,
igraph_vector_long_t* match, igraph_bool_t smaller_set) {
long int i, j, n, no_of_nodes = igraph_vcount(graph), matched_to;
igraph_dqueue_long_t q;
igraph_vector_t neis;
debug("Running global relabeling.\n");
/* Set all the labels to no_of_nodes first */
igraph_vector_fill(labels, no_of_nodes);
/* Allocate vector for neighbors */
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
/* Create a FIFO for the BFS and initialize it with the unmatched rows
* (i.e. members of the larger set) */
IGRAPH_CHECK(igraph_dqueue_long_init(&q, 0));
IGRAPH_FINALLY(igraph_dqueue_long_destroy, &q);
for (i = 0; i < no_of_nodes; i++) {
if (VECTOR(*types)[i] != smaller_set && VECTOR(*match)[i] == -1) {
IGRAPH_CHECK(igraph_dqueue_long_push(&q, i));
VECTOR(*labels)[i] = 0;
}
}
/* Run the BFS */
while (!igraph_dqueue_long_empty(&q)) {
long int v = igraph_dqueue_long_pop(&q);
long int w;
IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) v,
IGRAPH_ALL));
n = igraph_vector_size(&neis);
//igraph_vector_shuffle(&neis);
for (j = 0; j < n; j++) {
w = (long int) VECTOR(neis)[j];
if (VECTOR(*labels)[w] == no_of_nodes) {
VECTOR(*labels)[w] = VECTOR(*labels)[v] + 1;
matched_to = VECTOR(*match)[w];
if (matched_to != -1 && VECTOR(*labels)[matched_to] == no_of_nodes) {
IGRAPH_CHECK(igraph_dqueue_long_push(&q, matched_to));
VECTOR(*labels)[matched_to] = VECTOR(*labels)[w] + 1;
}
}
}
}
printf("Inside relabel : ");
igraph_vector_print(labels);
igraph_dqueue_long_destroy(&q);
igraph_vector_destroy(&neis);
IGRAPH_FINALLY_CLEAN(2);
return IGRAPH_SUCCESS;
}
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_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_random_walk(const igraph_t *graph, igraph_vector_t *walk,
igraph_integer_t start, igraph_neimode_t mode,
igraph_integer_t steps,
igraph_random_walk_stuck_t stuck) {
/* TODO:
- multiple walks potentially from multiple start vertices
- weights
*/
igraph_lazy_adjlist_t adj;
igraph_integer_t vc = igraph_vcount(graph);
igraph_integer_t i;
if (start < 0 || start >= vc) {
IGRAPH_ERROR("Invalid start vertex", IGRAPH_EINVAL);
}
if (steps < 0) {
IGRAPH_ERROR("Invalid number of steps", IGRAPH_EINVAL);
}
IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &adj, mode,
IGRAPH_DONT_SIMPLIFY));
IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adj);
IGRAPH_CHECK(igraph_vector_resize(walk, steps));
RNG_BEGIN();
VECTOR(*walk)[0] = start;
for (i = 1; i < steps; i++) {
igraph_vector_t *neis;
igraph_integer_t nn;
neis = igraph_lazy_adjlist_get(&adj, start);
nn = igraph_vector_size(neis);
if (IGRAPH_UNLIKELY(nn == 0)) {
igraph_vector_resize(walk, i);
if (stuck == IGRAPH_RANDOM_WALK_STUCK_RETURN) {
break;
} else {
IGRAPH_ERROR("Random walk got stuck", IGRAPH_ERWSTUCK);
}
}
start = VECTOR(*walk)[i] = VECTOR(*neis)[ RNG_INTEGER(0, nn - 1) ];
}
RNG_END();
igraph_lazy_adjlist_destroy(&adj);
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
/**
* \ingroup structural
* \function igraph_similarity_jaccard
* \brief Jaccard similarity coefficient for the given vertices.
*
* </para><para>
* The Jaccard similarity coefficient of two vertices is the number of common
* neighbors divided by the number of vertices that are neighbors of at
* least one of the two vertices being considered. This function calculates
* the pairwise Jaccard similarities for some (or all) of the vertices.
*
* \param graph The graph object to analyze
* \param res Pointer to a matrix, the result of the calculation will
* be stored here. The number of its rows and columns is the same
* as the number of vertex ids in \p vids.
* \param vids The vertex ids of the vertices for which the
* calculation will be done.
* \param mode The type of neighbors to be used for the calculation in
* directed graphs. Possible values:
* \clist
* \cli IGRAPH_OUT
* the outgoing edges will be considered for each node.
* \cli IGRAPH_IN
* the incoming edges will be considered for each node.
* \cli IGRAPH_ALL
* the directed graph is considered as an undirected one for the
* computation.
* \endclist
* \param loops Whether to include the vertices themselves in the neighbor
* sets.
* \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(|V|^2 d),
* |V| is the number of vertices in the vertex iterator given, d is the
* (maximum) degree of the vertices in the graph.
*
* \sa \ref igraph_similarity_dice(), a measure very similar to the Jaccard
* coefficient
*
* \example examples/simple/igraph_similarity.c
*/
int igraph_similarity_jaccard(const igraph_t *graph, igraph_matrix_t *res,
const igraph_vs_t vids, igraph_neimode_t mode, igraph_bool_t loops) {
igraph_lazy_adjlist_t al;
igraph_vit_t vit, vit2;
long int i, j, k;
long int len_union, len_intersection;
igraph_vector_t *v1, *v2;
IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit2));
IGRAPH_FINALLY(igraph_vit_destroy, &vit2);
IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &al, mode, IGRAPH_SIMPLIFY));
IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &al);
IGRAPH_CHECK(igraph_matrix_resize(res, IGRAPH_VIT_SIZE(vit), IGRAPH_VIT_SIZE(vit)));
if (loops) {
for (IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit)) {
i=IGRAPH_VIT_GET(vit);
v1=igraph_lazy_adjlist_get(&al, (igraph_integer_t) i);
if (!igraph_vector_binsearch(v1, i, &k))
igraph_vector_insert(v1, k, i);
}
}
for (IGRAPH_VIT_RESET(vit), i=0;
!IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
MATRIX(*res, i, i) = 1.0;
for (IGRAPH_VIT_RESET(vit2), j=0;
!IGRAPH_VIT_END(vit2); IGRAPH_VIT_NEXT(vit2), j++) {
if (j <= i)
continue;
v1=igraph_lazy_adjlist_get(&al, IGRAPH_VIT_GET(vit));
v2=igraph_lazy_adjlist_get(&al, IGRAPH_VIT_GET(vit2));
igraph_i_neisets_intersect(v1, v2, &len_union, &len_intersection);
if (len_union > 0)
MATRIX(*res, i, j) = ((igraph_real_t)len_intersection)/len_union;
else
MATRIX(*res, i, j) = 0.0;
MATRIX(*res, j, i) = MATRIX(*res, i, j);
}
}
igraph_lazy_adjlist_destroy(&al);
igraph_vit_destroy(&vit);
igraph_vit_destroy(&vit2);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
int igraph_is_connected_weak(const igraph_t *graph, igraph_bool_t *res) {
long int no_of_nodes=igraph_vcount(graph);
char *already_added;
igraph_vector_t neis=IGRAPH_VECTOR_NULL;
igraph_dqueue_t q=IGRAPH_DQUEUE_NULL;
long int i, j;
if (no_of_nodes == 0) {
*res = 1;
return IGRAPH_SUCCESS;
}
already_added=igraph_Calloc(no_of_nodes, char);
if (already_added==0) {
IGRAPH_ERROR("is connected (weak) failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(free, already_added); /* TODO: hack */
IGRAPH_DQUEUE_INIT_FINALLY(&q, 10);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
/* Try to find at least two clusters */
already_added[0]=1;
IGRAPH_CHECK(igraph_dqueue_push(&q, 0));
j=1;
while ( !igraph_dqueue_empty(&q)) {
long int actnode=(long int) igraph_dqueue_pop(&q);
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) actnode,
IGRAPH_ALL));
for (i=0; i <igraph_vector_size(&neis); i++) {
long int neighbor=(long int) VECTOR(neis)[i];
if (already_added[neighbor] != 0) { continue; }
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
j++;
already_added[neighbor]++;
}
}
/* Connected? */
*res = (j == no_of_nodes);
igraph_Free(already_added);
igraph_dqueue_destroy(&q);
igraph_vector_destroy(&neis);
IGRAPH_FINALLY_CLEAN(3);
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;
}
/* call-seq:
* graph.constraint(vs,weights) -> Array
*
* Returns an Array of constraint measures for the vertices
* in the graph. Weights is an Array of weight measures for each edge.
*/
VALUE cIGraph_constraint(int argc, VALUE *argv, VALUE self){
igraph_t *graph;
igraph_vs_t vids;
igraph_vector_t vidv;
igraph_vector_t res;
igraph_vector_t wght;
int i;
VALUE constraints = rb_ary_new();
VALUE vs, weights;
rb_scan_args(argc,argv,"11",&vs, &weights);
//vector to hold the results of the degree calculations
IGRAPH_FINALLY(igraph_vector_destroy, &res);
IGRAPH_FINALLY(igraph_vector_destroy, &wght);
IGRAPH_FINALLY(igraph_vector_destroy, &vidv);
IGRAPH_CHECK(igraph_vector_init(&res,0));
IGRAPH_CHECK(igraph_vector_init(&wght,0));
Data_Get_Struct(self, igraph_t, graph);
//Convert an array of vertices to a vector of vertex ids
IGRAPH_CHECK(igraph_vector_init_int(&vidv,0));
cIGraph_vertex_arr_to_id_vec(self,vs,&vidv);
//create vertex selector from the vecotr of ids
igraph_vs_vector(&vids,&vidv);
if(weights == Qnil){
IGRAPH_CHECK(igraph_constraint(graph,&res,vids,NULL));
} else {
for(i=0;i<RARRAY_LEN(weights);i++){
IGRAPH_CHECK(igraph_vector_push_back(&wght,NUM2DBL(RARRAY_PTR(weights)[i])));
}
IGRAPH_CHECK(igraph_constraint(graph,&res,vids,&wght));
}
for(i=0;i<igraph_vector_size(&res);i++){
rb_ary_push(constraints,rb_float_new(VECTOR(res)[i]));
}
igraph_vector_destroy(&vidv);
igraph_vector_destroy(&res);
igraph_vector_destroy(&wght);
igraph_vs_destroy(&vids);
IGRAPH_FINALLY_CLEAN(3);
return constraints;
}
int igraph_lapack_dgetrf(igraph_matrix_t *a, igraph_vector_int_t *ipiv,
int *info) {
int m=(int) igraph_matrix_nrow(a);
int n=(int) igraph_matrix_ncol(a);
int lda=m > 0 ? m : 1;
igraph_vector_int_t *myipiv=ipiv, vipiv;
if (!ipiv) {
IGRAPH_CHECK(igraph_vector_int_init(&vipiv, m<n ? m : n));
IGRAPH_FINALLY(igraph_vector_int_destroy, &vipiv);
myipiv=&vipiv;
}
igraphdgetrf_(&m, &n, VECTOR(a->data), &lda, VECTOR(*myipiv), info);
if (*info > 0) {
IGRAPH_WARNING("LU: factor is exactly singular");
} else if (*info < 0) {
switch(*info) {
case -1:
IGRAPH_ERROR("Invalid number of rows", IGRAPH_ELAPACK);
break;
case -2:
IGRAPH_ERROR("Invalid number of columns", IGRAPH_ELAPACK);
break;
case -3:
IGRAPH_ERROR("Invalid input matrix", IGRAPH_ELAPACK);
break;
case -4:
IGRAPH_ERROR("Invalid LDA parameter", IGRAPH_ELAPACK);
break;
case -5:
IGRAPH_ERROR("Invalid pivot vector", IGRAPH_ELAPACK);
break;
case -6:
IGRAPH_ERROR("Invalid info argument", IGRAPH_ELAPACK);
break;
default:
IGRAPH_ERROR("Unknown LAPACK error", IGRAPH_ELAPACK);
break;
}
}
if (!ipiv) {
igraph_vector_int_destroy(&vipiv);
IGRAPH_FINALLY_CLEAN(1);
}
return 0;
}
int igraph_create_bipartite(igraph_t *graph, const igraph_vector_bool_t *types,
const igraph_vector_t *edges,
igraph_bool_t directed) {
igraph_integer_t no_of_nodes=
(igraph_integer_t) igraph_vector_bool_size(types);
long int no_of_edges=igraph_vector_size(edges);
igraph_real_t min_edge=0, max_edge=0;
igraph_bool_t min_type=0, max_type=0;
long int i;
if (no_of_edges % 2 != 0) {
IGRAPH_ERROR("Invalid (odd) edges vector", IGRAPH_EINVEVECTOR);
}
no_of_edges /= 2;
if (no_of_edges != 0) {
igraph_vector_minmax(edges, &min_edge, &max_edge);
}
if (min_edge < 0 || max_edge >= no_of_nodes) {
IGRAPH_ERROR("Invalid (negative) vertex id", IGRAPH_EINVVID);
}
/* Check types vector */
if (no_of_nodes != 0) {
igraph_vector_bool_minmax(types, &min_type, &max_type);
if (min_type < 0 || max_type > 1) {
IGRAPH_WARNING("Non-binary type vector when creating a bipartite graph");
}
}
/* Check bipartiteness */
for (i=0; i<no_of_edges*2; i+=2) {
long int from=(long int) VECTOR(*edges)[i];
long int to=(long int) VECTOR(*edges)[i+1];
long int t1=VECTOR(*types)[from];
long int t2=VECTOR(*types)[to];
if ( (t1 && t2) || (!t1 && !t2) ) {
IGRAPH_ERROR("Invalid edges, not a bipartite graph", IGRAPH_EINVAL);
}
}
IGRAPH_CHECK(igraph_empty(graph, no_of_nodes, directed));
IGRAPH_FINALLY(igraph_destroy, graph);
IGRAPH_CHECK(igraph_add_edges(graph, edges, 0));
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int igraph_dot_product_game(igraph_t *graph, const igraph_matrix_t *vecs,
igraph_bool_t directed) {
igraph_integer_t nrow=igraph_matrix_nrow(vecs);
igraph_integer_t ncol=igraph_matrix_ncol(vecs);
int i, j;
igraph_vector_t edges;
igraph_bool_t warned_neg=0, warned_big=0;
IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
RNG_BEGIN();
for (i = 0; i < ncol; i++) {
int from=directed ? 0 : i+1;
igraph_vector_t v1;
igraph_vector_view(&v1, &MATRIX(*vecs, 0, i), nrow);
for (j = from; j < ncol; j++) {
igraph_real_t prob;
igraph_vector_t v2;
if (i==j) { continue; }
igraph_vector_view(&v2, &MATRIX(*vecs, 0, j), nrow);
igraph_lapack_ddot(&v1, &v2, &prob);
if (prob < 0 && ! warned_neg) {
warned_neg=1;
IGRAPH_WARNING("Negative connection probability in "
"dot-product graph");
} else if (prob > 1 && ! warned_big) {
warned_big=1;
IGRAPH_WARNING("Greater than 1 connection probability in "
"dot-product graph");
IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
IGRAPH_CHECK(igraph_vector_push_back(&edges, j));
} else if (RNG_UNIF01() < prob) {
IGRAPH_CHECK(igraph_vector_push_back(&edges, i));
IGRAPH_CHECK(igraph_vector_push_back(&edges, j));
}
}
}
RNG_END();
igraph_create(graph, &edges, ncol, directed);
igraph_vector_destroy(&edges);
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
/*
* Converts a Java VertexSet to an igraph_vs_t
* @return: zero if everything went fine, 1 if a null pointer was passed
*/
int Java_net_sf_igraph_VertexSet_to_igraph_vs(JNIEnv *env, jobject jobj, igraph_vs_t *result) {
jint typeHint;
jobject idArray;
if (jobj == 0) {
IGRAPH_CHECK(igraph_vs_all(result));
return IGRAPH_SUCCESS;
}
typeHint = (*env)->CallIntMethod(env, jobj, net_sf_igraph_VertexSet_getTypeHint_mid);
if (typeHint != 1 && typeHint != 2) {
IGRAPH_CHECK(igraph_vs_all(result));
return IGRAPH_SUCCESS;
}
idArray = (*env)->CallObjectMethod(env, jobj, net_sf_igraph_VertexSet_getIdArray_mid);
if ((*env)->ExceptionCheck(env)) {
return IGRAPH_EINVAL;
}
if (typeHint == 1) {
/* Single vertex */
jlong id[1];
(*env)->GetLongArrayRegion(env, idArray, 0, 1, id);
IGRAPH_CHECK(igraph_vs_1(result, (igraph_integer_t)id[0]));
} else if (typeHint == 2) {
/* List of vertices */
jlong* ids;
igraph_vector_t vec;
long i, n;
ids = (*env)->GetLongArrayElements(env, idArray, 0);
n = (*env)->GetArrayLength(env, idArray);
IGRAPH_VECTOR_INIT_FINALLY(&vec, n);
for (i = 0; i < n; i++)
VECTOR(vec)[i] = ids[i];
IGRAPH_CHECK(igraph_vs_vector_copy(result, &vec));
igraph_vector_destroy(&vec);
IGRAPH_FINALLY_CLEAN(1);
(*env)->ReleaseLongArrayElements(env, idArray, ids, JNI_ABORT);
}
(*env)->DeleteLocalRef(env, idArray);
return IGRAPH_SUCCESS;
}
int igraph_adjlist_init_empty(igraph_adjlist_t *al, igraph_integer_t no_of_nodes) {
long int i;
al->length=no_of_nodes;
al->adjs=igraph_Calloc(al->length, igraph_vector_t);
if (al->adjs == 0) {
IGRAPH_ERROR("Cannot create adjlist view", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_adjlist_destroy, al);
for (i=0; i<al->length; i++) {
IGRAPH_CHECK(igraph_vector_init(&al->adjs[i], 0));
}
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int igraph_vector_order2(igraph_vector_t *v) {
igraph_indheap_t heap;
igraph_indheap_init_array(&heap, VECTOR(*v), igraph_vector_size(v));
IGRAPH_FINALLY(igraph_indheap_destroy, &heap);
igraph_vector_clear(v);
while (!igraph_indheap_empty(&heap)) {
IGRAPH_CHECK(igraph_vector_push_back(v, igraph_indheap_max_index(&heap)-1));
igraph_indheap_delete_max(&heap);
}
igraph_indheap_destroy(&heap);
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int igraph_inclist_init_empty(igraph_inclist_t *il, igraph_integer_t n) {
long int i;
il->length=n;
il->incs=igraph_Calloc(il->length, igraph_vector_t);
if (il->incs == 0) {
IGRAPH_ERROR("Cannot create incidence list view", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_inclist_destroy, il);
for (i=0; i<n; i++) {
IGRAPH_CHECK(igraph_vector_init(&il->incs[i], 0));
}
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int igraph_bipartite_projection(const igraph_t *graph,
const igraph_vector_bool_t *types,
igraph_t *proj1,
igraph_t *proj2,
igraph_vector_t *multiplicity1,
igraph_vector_t *multiplicity2,
igraph_integer_t probe1) {
long int no_of_nodes=igraph_vcount(graph);
/* t1 is -1 if proj1 is omitted, it is 0 if it belongs to type zero,
it is 1 if it belongs to type one. The same for t2 */
int t1, t2;
if (igraph_vector_bool_size(types) != no_of_nodes) {
IGRAPH_ERROR("Invalid bipartite type vector size", IGRAPH_EINVAL);
}
if (probe1 >= no_of_nodes) {
IGRAPH_ERROR("No such vertex to probe", IGRAPH_EINVAL);
}
if (probe1 >= 0 && !proj1) {
IGRAPH_ERROR("`probe1' given, but `proj1' is a null pointer", IGRAPH_EINVAL);
}
if (probe1 >=0) {
t1=VECTOR(*types)[(long int)probe1];
if (proj2) {
t2=1-t1;
} else {
t2=-1;
}
} else {
t1 = proj1 ? 0 : -1;
t2 = proj2 ? 1 : -1;
}
IGRAPH_CHECK(igraph_i_bipartite_projection(graph, types, proj1, t1, multiplicity1));
IGRAPH_FINALLY(igraph_destroy, proj1);
IGRAPH_CHECK(igraph_i_bipartite_projection(graph, types, proj2, t2, multiplicity2));
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int igraph_bridges(const igraph_t *graph, igraph_vector_t *bridges) {
igraph_inclist_t il;
igraph_vector_bool_t visited;
igraph_vector_int_t disc, low;
igraph_vector_int_t parent;
long n;
long i;
igraph_integer_t time;
n = igraph_vcount(graph);
IGRAPH_CHECK(igraph_inclist_init(graph, &il, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_inclist_destroy, &il);
IGRAPH_CHECK(igraph_vector_bool_init(&visited, n));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &visited);
IGRAPH_CHECK(igraph_vector_int_init(&disc, n));
IGRAPH_FINALLY(igraph_vector_int_destroy, &disc);
IGRAPH_CHECK(igraph_vector_int_init(&low, n));
IGRAPH_FINALLY(igraph_vector_int_destroy, &low);
IGRAPH_CHECK(igraph_vector_int_init(&parent, n));
IGRAPH_FINALLY(igraph_vector_int_destroy, &parent);
for (i=0; i < n; ++i)
VECTOR(parent)[i] = -1;
igraph_vector_clear(bridges);
time = 0;
for (i=0; i < n; ++i)
if (! VECTOR(visited)[i])
IGRAPH_CHECK(igraph_i_bridges_rec(graph, &il, i, &time, bridges, &visited, &disc, &low, &parent));
igraph_vector_int_destroy(&parent);
igraph_vector_int_destroy(&low);
igraph_vector_int_destroy(&disc);
igraph_vector_bool_destroy(&visited);
igraph_inclist_destroy(&il);
IGRAPH_FINALLY_CLEAN(5);
return IGRAPH_SUCCESS;
}
/* call-seq:
* graph.eigenvector_centrality(scale, weights) -> Array
*
* Returns a two-element arrar, the first element of which is an Array of
* eigenvector centrality scores for graph, and the second of which is the
* eigenvalue.
*
* scale is a boolean value. If true, the scores will be weighted so that the
* absolute value of the maximum centrality is one.
*
* weights is an Array giving the weights of the edges. If nil, the edges are unweighted.
*/
VALUE cIGraph_eigenvector_centrality(VALUE self, VALUE scale, VALUE weights) {
int i;
igraph_t *graph;
igraph_vector_t vec;
igraph_real_t val;
igraph_vector_t wgts;
igraph_arpack_options_t arpack_opt;
igraph_bool_t sc = 0;
VALUE eigenvector = rb_ary_new();
VALUE rb_res = rb_ary_new();
IGRAPH_FINALLY(igraph_vector_destroy, &vec);
IGRAPH_FINALLY(igraph_vector_destroy, &wgts);
IGRAPH_CHECK(igraph_vector_init(&vec,0));
IGRAPH_CHECK(igraph_vector_init(&wgts,0));
igraph_arpack_options_init(&arpack_opt);
if (scale == Qtrue) sc = 1;
Data_Get_Struct(self, igraph_t, graph);
if (weights == Qnil) {
IGRAPH_CHECK(igraph_eigenvector_centrality(graph, &vec, &val, sc, NULL, &arpack_opt));
} else {
for(i = 0; i < RARRAY_LEN(weights); i++)
IGRAPH_CHECK(igraph_vector_push_back(&wgts, NUM2DBL(RARRAY_PTR(weights)[i])));
IGRAPH_CHECK(igraph_eigenvector_centrality(graph, &vec, &val, sc, &wgts, &arpack_opt));
}
for(i = 0; i < igraph_vector_size(&vec); i++)
rb_ary_push(eigenvector, rb_float_new(VECTOR(vec)[i]));
igraph_vector_destroy(&vec);
igraph_vector_destroy(&wgts);
rb_ary_push(rb_res, eigenvector);
rb_ary_push(rb_res, rb_float_new(val));
IGRAPH_FINALLY_CLEAN(2);
return rb_res;
}
int igraph_disjoint_union_many(igraph_t *res,
const igraph_vector_ptr_t *graphs) {
long int no_of_graphs=igraph_vector_ptr_size(graphs);
igraph_bool_t directed=1;
igraph_vector_t edges;
long int no_of_edges=0;
long int shift=0;
igraph_t *graph;
long int i, j;
igraph_integer_t from, to;
if (no_of_graphs != 0) {
graph=VECTOR(*graphs)[0];
directed=igraph_is_directed(graph);
for (i=0; i<no_of_graphs; i++) {
graph=VECTOR(*graphs)[i];
no_of_edges += igraph_ecount(graph);
if (directed != igraph_is_directed(graph)) {
IGRAPH_ERROR("Cannot union directed and undirected graphs",
IGRAPH_EINVAL);
}
}
}
IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
IGRAPH_CHECK(igraph_vector_reserve(&edges, 2*no_of_edges));
for (i=0; i<no_of_graphs; i++) {
long int ec;
graph=VECTOR(*graphs)[i];
ec=igraph_ecount(graph);
for (j=0; j<ec; j++) {
igraph_edge(graph, (igraph_integer_t) j, &from, &to);
igraph_vector_push_back(&edges, from+shift);
igraph_vector_push_back(&edges, to+shift);
}
shift += igraph_vcount(graph);
}
IGRAPH_CHECK(igraph_create(res, &edges, (igraph_integer_t) shift, directed));
igraph_vector_destroy(&edges);
IGRAPH_FINALLY_CLEAN(1);
return 0;
}