/**
* \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_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;
}
int dfs_d(const igraph_t *graph, igraph_integer_t root,
igraph_neimode_t mode, igraph_bool_t unreachable,
igraph_vector_t *order,
igraph_vector_t *order_out, igraph_vector_t *father,
igraph_vector_t *dist, igraph_dfshandler_t *in_callback,
igraph_dfshandler_t *out_callback,
void *extra) {
long int no_of_nodes=igraph_vcount(graph);
igraph_lazy_adjlist_t adjlist;
igraph_stack_t stack;
igraph_vector_char_t added;
igraph_vector_long_t nptr;
long int actroot;
long int act_rank=0;
long int rank_out=0;
long int act_dist=0;
if (root < 0 || root >= no_of_nodes) {
IGRAPH_ERROR("Invalid root vertex for DFS", IGRAPH_EINVAL);
}
if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
mode != IGRAPH_ALL) {
IGRAPH_ERROR("Invalid mode argument", IGRAPH_EINVMODE);
}
if (!igraph_is_directed(graph)) { mode=IGRAPH_ALL; }
IGRAPH_CHECK(igraph_vector_char_init(&added, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_char_destroy, &added);
IGRAPH_CHECK(igraph_stack_init(&stack, 100));
IGRAPH_FINALLY(igraph_stack_destroy, &stack);
IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &adjlist, mode, /*simplify=*/ 0));
IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adjlist);
IGRAPH_CHECK(igraph_vector_long_init(&nptr, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &nptr);
# define FREE_ALL() do { \
igraph_vector_long_destroy(&nptr); \
igraph_lazy_adjlist_destroy(&adjlist); \
igraph_stack_destroy(&stack); \
igraph_vector_char_destroy(&added); \
IGRAPH_FINALLY_CLEAN(4); } while (0)
/* Resize result vectors and fill them with IGRAPH_NAN */
# define VINIT(v) if (v) { \
igraph_vector_resize(v, no_of_nodes); \
igraph_vector_fill(v, IGRAPH_NAN); }
VINIT(order);
VINIT(order_out);
VINIT(father);
VINIT(dist);
# undef VINIT
IGRAPH_CHECK(igraph_stack_push(&stack, root));
VECTOR(added)[(long int)root] = 1;
if (father) { VECTOR(*father)[(long int)root] = -1; }
if (order) { VECTOR(*order)[act_rank++] = root; }
if (dist) { VECTOR(*dist)[(long int)root] = 0; }
if (in_callback) {
igraph_bool_t terminate=in_callback(graph, root, 0, extra);
if (terminate) { FREE_ALL(); return 0; }
}
for (actroot=0; actroot<no_of_nodes; actroot++) {
/* 'root' first, then all other vertices */
if (igraph_stack_empty(&stack)) {
if (!unreachable) { break; }
if (VECTOR(added)[actroot]) { continue; }
IGRAPH_CHECK(igraph_stack_push(&stack, actroot));
VECTOR(added)[actroot] = 1;
if (father) { VECTOR(*father)[actroot] = -1; }
if (order) { VECTOR(*order)[act_rank++] = actroot; }
if (dist) { VECTOR(*dist)[actroot] = 0; }
if (in_callback) {
igraph_bool_t terminate=in_callback(graph, (igraph_integer_t) actroot,
0, extra);
if (terminate) { FREE_ALL(); return 0; }
}
}
while (!igraph_stack_empty(&stack)) {
long int actvect=(long int) igraph_stack_top(&stack);
igraph_vector_t *neis=igraph_lazy_adjlist_get(&adjlist,
(igraph_integer_t) actvect);
long int n=igraph_vector_size(neis);
long int *ptr=igraph_vector_long_e_ptr(&nptr, actvect);
igraph_vector_shuffle(neis);
igraph_vector_print(neis);
/* Search for a neighbor that was not yet visited */
igraph_bool_t any=0;
long int nei;
while (!any && (*ptr) <n) {
nei=(long int) VECTOR(*neis)[(*ptr)];
any=!VECTOR(added)[nei];
(*ptr) ++;
}
if (any) {
/* There is such a neighbor, add it */
IGRAPH_CHECK(igraph_stack_push(&stack, nei));
VECTOR(added)[nei] = 1;
if (father) { VECTOR(*father)[ nei ] = actvect; }
if (order) { VECTOR(*order)[act_rank++] = nei; }
act_dist++;
if (dist) { VECTOR(*dist)[nei] = act_dist; }
if (in_callback) {
igraph_bool_t terminate=in_callback(graph, (igraph_integer_t) nei,
(igraph_integer_t) act_dist,
extra);
if (terminate) { FREE_ALL(); return 0; }
}
} else {
/* There is no such neighbor, finished with the subtree */
igraph_stack_pop(&stack);
if (order_out) { VECTOR(*order_out)[rank_out++] = actvect; }
act_dist--;
if (out_callback) {
igraph_bool_t terminate=out_callback(graph, (igraph_integer_t)
actvect, (igraph_integer_t)
act_dist, extra);
if (terminate) { FREE_ALL(); return 0; }
}
}
}
}
FREE_ALL();
# undef FREE_ALL
return 0;
}
/* #include "igraph_visitor.h"
#include "igraph_memory.h"
#include "igraph_adjlist.h"
#include "igraph_interface.h"
#include "igraph_dqueue.h"
#include "igraph_stack.h"
#include "config.h"*/
int igraph_bfsr(const igraph_t *graph,
igraph_integer_t root,igraph_vector_t *roots,
igraph_neimode_t mode, igraph_bool_t unreachable,
const igraph_vector_t *restricted,
igraph_vector_t *order, igraph_vector_t *rank,
igraph_vector_t *father,
igraph_vector_t *pred, igraph_vector_t *succ,
igraph_vector_t *dist, igraph_bfshandler_t *callback,
void *extra) {
igraph_dqueue_t Q;
long int no_of_nodes=igraph_vcount(graph);
long int actroot=0;
igraph_vector_char_t added;
igraph_lazy_adjlist_t adjlist;
long int act_rank=0;
long int pred_vec=-1;
long int rootpos=0;
long int noroots= roots ? igraph_vector_size(roots) : 1;
if (!roots && (root < 0 || root >= no_of_nodes)) {
IGRAPH_ERROR("Invalid root vertex in BFS", IGRAPH_EINVAL);
}
if (roots) {
igraph_real_t min, max;
igraph_vector_minmax(roots, &min, &max);
if (min < 0 || max >= no_of_nodes) {
IGRAPH_ERROR("Invalid root vertex in BFS", IGRAPH_EINVAL);
}
}
if (restricted) {
igraph_real_t min, max;
igraph_vector_minmax(restricted, &min, &max);
if (min < 0 || max >= no_of_nodes) {
IGRAPH_ERROR("Invalid vertex id in restricted set", IGRAPH_EINVAL);
}
}
if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
mode != IGRAPH_ALL) {
IGRAPH_ERROR("Invalid mode argument", IGRAPH_EINVMODE);
}
if (!igraph_is_directed(graph)) { mode=IGRAPH_ALL; }
IGRAPH_CHECK(igraph_vector_char_init(&added, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_char_destroy, &added);
IGRAPH_CHECK(igraph_dqueue_init(&Q, 100));
IGRAPH_FINALLY(igraph_dqueue_destroy, &Q);
IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &adjlist, mode, /*simplify=*/ 0));
IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adjlist);
/* Mark the vertices that are not in the restricted set, as already
found. Special care must be taken for vertices that are not in
the restricted set, but are to be used as 'root' vertices. */
if (restricted) {
long int i, n=igraph_vector_size(restricted);
igraph_vector_char_fill(&added, 1);
for (i=0; i<n; i++) {
long int v=(long int) VECTOR(*restricted)[i];
VECTOR(added)[v]=0;
}
}
/* Resize result vectors, and fill them with IGRAPH_NAN */
# define VINIT(v) if (v) { \
igraph_vector_resize((v), no_of_nodes); \
igraph_vector_fill((v), IGRAPH_NAN); }
VINIT(order);
VINIT(rank);
VINIT(father);
VINIT(pred);
VINIT(succ);
VINIT(dist);
# undef VINIT
while (1) {
/* Get the next root vertex, if any */
if (roots && rootpos < noroots) {
/* We are still going through the 'roots' vector */
actroot=(long int) VECTOR(*roots)[rootpos++];
} else if (!roots && rootpos==0) {
/* We have a single root vertex given, and start now */
actroot=root;
rootpos++;
} else if (rootpos==noroots && unreachable) {
/* We finished the given root(s), but other vertices are also
tried as root */
actroot=0;
rootpos++;
} else if (unreachable && actroot+1 < no_of_nodes) {
/* We are already doing the other vertices, take the next one */
actroot++;
} else {
/* No more root nodes to do */
break;
}
/* OK, we have a new root, start BFS */
if (VECTOR(added)[actroot]) { continue; }
IGRAPH_CHECK(igraph_dqueue_push(&Q, actroot));
IGRAPH_CHECK(igraph_dqueue_push(&Q, 0));
VECTOR(added)[actroot] = 1;
if (father) { VECTOR(*father)[actroot] = -1; }
pred_vec=-1;
while (!igraph_dqueue_empty(&Q)) {
long int actvect=(long int) igraph_dqueue_pop(&Q);
long int actdist=(long int) igraph_dqueue_pop(&Q);
long int succ_vec;
igraph_vector_t *neis=igraph_lazy_adjlist_get(&adjlist,
(igraph_integer_t) actvect);
long int i, n=igraph_vector_size(neis);
if (pred) { VECTOR(*pred)[actvect] = pred_vec; }
if (rank) { VECTOR(*rank) [actvect] = act_rank; }
if (order) { VECTOR(*order)[act_rank++] = actvect; }
if (dist) { VECTOR(*dist)[actvect] = actdist; }
igraph_vector_shuffle(neis);
for (i=0; i<n; i++) {
long int nei=(long int) VECTOR(*neis)[i];
if (! VECTOR(added)[nei]) {
VECTOR(added)[nei] = 1;
IGRAPH_CHECK(igraph_dqueue_push(&Q, nei));
IGRAPH_CHECK(igraph_dqueue_push(&Q, actdist+1));
if (father) { VECTOR(*father)[nei] = actvect; }
}
}
succ_vec = igraph_dqueue_empty(&Q) ? -1L :
(long int) igraph_dqueue_head(&Q);
if (callback) {
igraph_bool_t terminate=
callback(graph, (igraph_integer_t) actvect, (igraph_integer_t)
pred_vec, (igraph_integer_t) succ_vec,
(igraph_integer_t) act_rank-1, (igraph_integer_t) actdist,
extra);
if (terminate) {
igraph_lazy_adjlist_destroy(&adjlist);
igraph_dqueue_destroy(&Q);
igraph_vector_char_destroy(&added);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
}
if (succ) { VECTOR(*succ)[actvect] = succ_vec; }
pred_vec=actvect;
} /* while Q !empty */
} /* for actroot < no_of_nodes */
igraph_lazy_adjlist_destroy(&adjlist);
igraph_dqueue_destroy(&Q);
igraph_vector_char_destroy(&added);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
/**
* \ingroup structural
* \function igraph_similarity_jaccard_pairs
* \brief Jaccard similarity coefficient for given vertex pairs.
*
* </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 a list of vertex pairs.
*
* \param graph The graph object to analyze
* \param res Pointer to a vector, the result of the calculation will
* be stored here. The number of elements is the same as the number
* of pairs in \p pairs.
* \param pairs A vector that contains the pairs for which the similarity
* will be calculated. Each pair is defined by two consecutive elements,
* i.e. the first and second element of the vector specifies the first
* pair, the third and fourth element specifies the second pair and so on.
* \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(nd), n is the number of pairs in the given vector, d is
* the (maximum) degree of the vertices in the graph.
*
* \sa \ref igraph_similarity_jaccard() to calculate the Jaccard similarity
* between all pairs of a vertex set, or \ref igraph_similarity_dice() and
* \ref igraph_similarity_dice_pairs() for a measure very similar to the
* Jaccard coefficient
*
* \example examples/simple/igraph_similarity.c
*/
int igraph_similarity_jaccard_pairs(const igraph_t *graph, igraph_vector_t *res,
const igraph_vector_t *pairs, igraph_neimode_t mode, igraph_bool_t loops) {
igraph_lazy_adjlist_t al;
long int i, j, k, u, v;
long int len_union, len_intersection;
igraph_vector_t *v1, *v2;
igraph_bool_t *seen;
k = igraph_vector_size(pairs);
if (k % 2 != 0)
IGRAPH_ERROR("number of elements in `pairs' must be even", IGRAPH_EINVAL);
IGRAPH_CHECK(igraph_vector_resize(res, k/2));
IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &al, mode, IGRAPH_SIMPLIFY));
IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &al);
if (loops) {
/* Add the loop edges */
i = igraph_vcount(graph);
seen = igraph_Calloc(i, igraph_bool_t);
if (seen == 0)
IGRAPH_ERROR("cannot calculate Jaccard similarity", IGRAPH_ENOMEM);
IGRAPH_FINALLY(free, seen);
for (i = 0; i < k; i++) {
j = (long int) VECTOR(*pairs)[i];
if (seen[j])
continue;
seen[j] = 1;
v1=igraph_lazy_adjlist_get(&al, (igraph_integer_t) j);
if (!igraph_vector_binsearch(v1, j, &u))
igraph_vector_insert(v1, u, j);
}
free(seen);
IGRAPH_FINALLY_CLEAN(1);
}
for (i = 0, j = 0; i < k; i += 2, j++) {
u = (long int) VECTOR(*pairs)[i];
v = (long int) VECTOR(*pairs)[i+1];
if (u == v) {
VECTOR(*res)[j] = 1.0;
continue;
}
v1 = igraph_lazy_adjlist_get(&al, (igraph_integer_t) u);
v2 = igraph_lazy_adjlist_get(&al, (igraph_integer_t) v);
igraph_i_neisets_intersect(v1, v2, &len_union, &len_intersection);
if (len_union > 0)
VECTOR(*res)[j] = ((igraph_real_t)len_intersection) / len_union;
else
VECTOR(*res)[j] = 0.0;
}
igraph_lazy_adjlist_destroy(&al);
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
