int igraph_i_largest_cliques_store(const igraph_vector_t* clique, void* data, igraph_bool_t* cont) {
igraph_vector_ptr_t* result = (igraph_vector_ptr_t*)data;
igraph_vector_t* vec;
long int i, n;
/* Is the current clique at least as large as the others that we have found? */
if (!igraph_vector_ptr_empty(result)) {
n = igraph_vector_size(clique);
if (n < igraph_vector_size(VECTOR(*result)[0]))
return IGRAPH_SUCCESS;
if (n > igraph_vector_size(VECTOR(*result)[0])) {
for (i = 0; i < igraph_vector_ptr_size(result); i++)
igraph_vector_destroy(VECTOR(*result)[i]);
igraph_vector_ptr_free_all(result);
igraph_vector_ptr_resize(result, 0);
}
}
vec = igraph_Calloc(1, igraph_vector_t);
if (vec == 0)
IGRAPH_ERROR("cannot allocate memory for storing next clique", IGRAPH_ENOMEM);
IGRAPH_CHECK(igraph_vector_copy(vec, clique));
IGRAPH_CHECK(igraph_vector_ptr_push_back(result, vec));
return IGRAPH_SUCCESS;
}
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_maximal_cliques_store(const igraph_vector_t* clique, void* data, igraph_bool_t* cont) {
igraph_vector_ptr_t* result = (igraph_vector_ptr_t*)data;
igraph_vector_t* vec;
vec = igraph_Calloc(1, igraph_vector_t);
if (vec == 0)
IGRAPH_ERROR("cannot allocate memory for storing next clique", IGRAPH_ENOMEM);
IGRAPH_CHECK(igraph_vector_copy(vec, clique));
IGRAPH_CHECK(igraph_vector_ptr_push_back(result, vec));
return IGRAPH_SUCCESS;
}
int cliques_load_unordered_maximal_cliques_list(cliques *c, const char *path) {
FILE *input;
igraph_vector_t *k_clique_v;
int size, node_id;
int max_size=0,cur_size=0;
if (c == NULL || path == NULL)
return -1;
if ((input = fopen(path, "r")) == NULL)
return -2;
k_clique_v = (igraph_vector_t*) malloc(sizeof (igraph_vector_t));
igraph_vector_init(k_clique_v, 0);
// read the file and compute the maximum size
// of the cliques
while (fscanf(input, "%i", &node_id) != EOF) {
if (node_id == -1){
if(cur_size > max_size)
max_size = cur_size;
cur_size=0;
} else
cur_size++;
}
// initialize cliques structure internal vectors
// according to the size of the maximum clique
if((cliques_init_member_vectors(c, max_size)) < 0)
return -3;
// reset the file position indicator to the beginning of the file
fseek(input, 0L, SEEK_SET);
// load maximal cliques from the file
while (fscanf(input, "%i", &node_id) != EOF) {
if (node_id != -1){
igraph_vector_push_back(k_clique_v, node_id);
}else {
size = igraph_vector_size(k_clique_v);
igraph_vector_sort(k_clique_v);
igraph_vector_ptr_push_back(VECTOR(c->maximal_cliques_v_ptr)[size], k_clique_v);
k_clique_v = (igraph_vector_t*) malloc(sizeof (igraph_vector_t));
igraph_vector_init(k_clique_v, 0);
}
}
cliques_order_cliques_by_decreasing_k(c, NULL);
igraph_vector_destroy(k_clique_v);
return 0;
}
int igraph_i_maximal_cliques_store_size_check(const igraph_vector_t* clique, void* data_, igraph_bool_t* cont) {
igraph_i_maximal_clique_data_t* data = (igraph_i_maximal_clique_data_t*)data_;
igraph_vector_t* vec;
igraph_integer_t size = igraph_vector_size(clique);
if (size < data->min_size || size > data->max_size)
return IGRAPH_SUCCESS;
vec = igraph_Calloc(1, igraph_vector_t);
if (vec == 0)
IGRAPH_ERROR("cannot allocate memory for storing next clique", IGRAPH_ENOMEM);
IGRAPH_CHECK(igraph_vector_copy(vec, clique));
IGRAPH_CHECK(igraph_vector_ptr_push_back(data->result, vec));
return IGRAPH_SUCCESS;
}
static boolean collect_cliques_callback(set_t s, graph_t *g, clique_options *opt) {
igraph_vector_ptr_t *list;
igraph_vector_t *clique;
int i, j;
CLIQUER_ALLOW_INTERRUPTION();
list = (igraph_vector_ptr_t *) opt->user_data;
clique = (igraph_vector_t *) malloc(sizeof(igraph_vector_t));
igraph_vector_init(clique, set_size(s));
i = -1; j = 0;
while ((i = set_return_next(s,i)) >= 0)
VECTOR(*clique)[j++] = i;
igraph_vector_ptr_push_back(list, clique);
return TRUE;
}
int igraph_attribute_combination_add(igraph_attribute_combination_t *comb,
const char *name,
igraph_attribute_combination_type_t type,
void *func) {
long int i, n=igraph_vector_ptr_size(&comb->list);
/* Search, in case it is already there */
for (i=0; i<n; i++) {
igraph_attribute_combination_record_t *r=VECTOR(comb->list)[i];
const char *n=r->name;
if ( (!name && !n) ||
(name && n && !strcmp(n, name)) ) {
r->type=type;
r->func=func;
break;
}
}
if (i==n) {
/* This is a new attribute name */
igraph_attribute_combination_record_t *rec=
igraph_Calloc(1, igraph_attribute_combination_record_t);
if (!rec) {
IGRAPH_ERROR("Cannot create attribute combination data",
IGRAPH_ENOMEM);
}
if (!name) {
rec->name=0;
} else {
rec->name=strdup(name);
}
rec->type=type;
rec->func=func;
IGRAPH_CHECK(igraph_vector_ptr_push_back(&comb->list, rec));
}
return 0;
}
void test4() {
int i, j;
igraph_vector_ptr_t graphs4;
// Verify that no two 4-vertex graphs of distinct isoclasses are considered isomorphic by Bliss or VF2.
igraph_vector_ptr_init(&graphs4, 0);
IGRAPH_VECTOR_PTR_SET_ITEM_DESTRUCTOR(&graphs4, igraph_destroy);
for (i=0; i < 218; i++) {
igraph_t *g;
g = (igraph_t *) malloc(sizeof(igraph_t));
igraph_vector_ptr_push_back(&graphs4, g);
igraph_isoclass_create(g, 4, i, /* directed = */ 1);
}
for (i=0; i < 218; i++)
for (j=i+1; j < 218; j++) {
igraph_bool_t iso;
igraph_isomorphic_bliss(
(igraph_t *) VECTOR(graphs4)[i], (igraph_t *) VECTOR(graphs4)[j],
NULL, NULL, &iso, NULL, NULL, IGRAPH_BLISS_F, NULL, NULL);
if (iso)
printf("Bliss failure, 4 vertex directed graphs of isoclass %d and %d are not isomorphic. Bliss reports otherwise.\n", i, j);
}
for (i=0; i < 218; i++)
for (j=i+1; j < 218; j++) {
igraph_bool_t iso;
igraph_isomorphic_vf2(
(igraph_t *) VECTOR(graphs4)[i], (igraph_t *) VECTOR(graphs4)[j],
NULL, NULL, NULL, NULL, &iso, NULL, NULL, NULL, NULL, NULL);
if (iso)
printf("VF2 failure, 4 vertex directed graphs of isoclass %d and %d are not isomorphic. VF2 reports otherwise.\n", i, j);
}
igraph_vector_ptr_destroy_all(&graphs4);
}
int igraph_cohesive_blocks(const igraph_t *graph,
igraph_vector_ptr_t *blocks,
igraph_vector_t *cohesion,
igraph_vector_t *parent,
igraph_t *block_tree) {
/* Some implementation comments. Everything is relatively
straightforward, except, that we need to follow the vertex ids
of the various subgraphs, without having to store two-way
mappings at each level. The subgraphs can overlap, this
complicates things a bit.
The 'Q' vector is used as a double ended queue and it contains
the subgraphs to work on in the future. Some other vectors are
associated with it. 'Qparent' gives the parent graph of a graph
in Q. Qmapping gives the mapping of the vertices from the graph
to the parent graph. Qcohesion is the vertex connectivity of the
graph.
Qptr is an integer and points to the next graph to work on.
*/
igraph_vector_ptr_t Q;
igraph_vector_ptr_t Qmapping;
igraph_vector_long_t Qparent;
igraph_vector_long_t Qcohesion;
igraph_vector_bool_t Qcheck;
long int Qptr=0;
igraph_integer_t conn;
igraph_bool_t is_simple;
igraph_t *graph_copy;
igraph_vector_ptr_t separators;
igraph_vector_t compvertices;
igraph_vector_long_t components;
igraph_vector_bool_t marked;
igraph_vector_long_t compid;
igraph_dqueue_t bfsQ;
igraph_vector_t neis;
if (igraph_is_directed(graph)) {
IGRAPH_ERROR("Cohesive blocking only works on undirected graphs",
IGRAPH_EINVAL);
}
IGRAPH_CHECK(igraph_is_simple(graph, &is_simple));
if (!is_simple) {
IGRAPH_ERROR("Cohesive blocking only works on simple graphs",
IGRAPH_EINVAL);
}
IGRAPH_STATUS("Starting cohesive block calculation.\n", 0);
if (blocks) { igraph_vector_ptr_clear(blocks); }
if (cohesion) { igraph_vector_clear(cohesion); }
if (parent) { igraph_vector_clear(parent); }
IGRAPH_CHECK(igraph_vector_ptr_init(&Q, 1));
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &Q);
IGRAPH_FINALLY(igraph_i_cohesive_blocks_free, &Q);
IGRAPH_CHECK(igraph_vector_ptr_init(&Qmapping, 1));
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &Qmapping);
IGRAPH_FINALLY(igraph_i_cohesive_blocks_free2, &Qmapping);
IGRAPH_CHECK(igraph_vector_long_init(&Qparent, 1));
IGRAPH_FINALLY(igraph_vector_long_destroy, &Qparent);
IGRAPH_CHECK(igraph_vector_long_init(&Qcohesion, 1));
IGRAPH_FINALLY(igraph_vector_long_destroy, &Qcohesion);
IGRAPH_CHECK(igraph_vector_bool_init(&Qcheck, 1));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &Qcheck);
IGRAPH_CHECK(igraph_vector_ptr_init(&separators, 0));
IGRAPH_FINALLY(igraph_vector_ptr_destroy, &separators);
IGRAPH_VECTOR_INIT_FINALLY(&compvertices, 0);
IGRAPH_CHECK(igraph_vector_bool_init(&marked, 0));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &marked);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
IGRAPH_CHECK(igraph_dqueue_init(&bfsQ, 100));
IGRAPH_FINALLY(igraph_dqueue_destroy, &bfsQ);
IGRAPH_CHECK(igraph_vector_long_init(&compid, 0));
IGRAPH_FINALLY(igraph_vector_long_destroy, &compid);
IGRAPH_CHECK(igraph_vector_long_init(&components, 0));
IGRAPH_FINALLY(igraph_vector_long_destroy, &components);
/* Put the input graph in the queue */
graph_copy=igraph_Calloc(1, igraph_t);
if (!graph_copy) {
IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
}
IGRAPH_CHECK(igraph_copy(graph_copy, graph));
VECTOR(Q)[0] = graph_copy;
VECTOR(Qmapping)[0] = 0; /* Identity mapping */
VECTOR(Qparent)[0] = -1; /* Has no parent */
IGRAPH_CHECK(igraph_vertex_connectivity(graph, &conn, /*checks=*/ 1));
VECTOR(Qcohesion)[0] = conn;
VECTOR(Qcheck)[0] = 0;
/* Then work until the queue is empty */
while (Qptr < igraph_vector_ptr_size(&Q)) {
igraph_t *mygraph=VECTOR(Q)[Qptr];
igraph_bool_t mycheck=VECTOR(Qcheck)[Qptr];
long int mynodes=igraph_vcount(mygraph);
long int i, nsep;
long int no, kept=0;
long int cptr=0;
long int nsepv=0;
igraph_bool_t addedsep=0;
IGRAPH_STATUSF(("Candidate %li: %li vertices,",
0, Qptr, mynodes));
IGRAPH_ALLOW_INTERRUPTION();
/* Get the separators */
IGRAPH_CHECK(igraph_minimum_size_separators(mygraph, &separators));
IGRAPH_FINALLY(igraph_i_cohesive_blocks_free3, &separators);
nsep=igraph_vector_ptr_size(&separators);
IGRAPH_STATUSF((" %li separators,", 0, nsep));
/* Remove them from the graph, also mark them */
IGRAPH_CHECK(igraph_vector_bool_resize(&marked, mynodes));
igraph_vector_bool_null(&marked);
for (i=0; i<nsep; i++) {
igraph_vector_t *v=VECTOR(separators)[i];
long int j, n=igraph_vector_size(v);
for (j=0; j<n; j++) {
long int vv=(long int) VECTOR(*v)[j];
if (!VECTOR(marked)[vv]) {
nsepv++;
VECTOR(marked)[vv] = 1;
}
}
}
/* Find the connected components, omitting the separator vertices,
but including the neighboring separator vertices
*/
IGRAPH_CHECK(igraph_i_cb_components(mygraph, &marked,
&components, &no,
&compid, &bfsQ, &neis));
/* Add the separator vertices themselves, as another component,
but only if there is at least one vertex not included in any
separator. */
if (nsepv != mynodes) {
addedsep=1;
for (i=0; i<mynodes; i++) {
if (VECTOR(marked)[i]) {
IGRAPH_CHECK(igraph_vector_long_push_back(&components, i));
}
}
IGRAPH_CHECK(igraph_vector_long_push_back(&components, -1));
no++;
}
IGRAPH_STATUSF((" %li new candidates,", 0, no));
for (i=0; i<no; i++) {
igraph_vector_t *newmapping;
igraph_t *newgraph;
igraph_integer_t maxdeg;
igraph_vector_clear(&compvertices);
while (1) {
long int v=VECTOR(components)[cptr++];
if (v < 0) { break; }
IGRAPH_CHECK(igraph_vector_push_back(&compvertices, v));
}
newmapping=igraph_Calloc(1, igraph_vector_t);
if (!newmapping) {
IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, newmapping);
IGRAPH_VECTOR_INIT_FINALLY(newmapping, 0);
newgraph=igraph_Calloc(1, igraph_t);
if (!newgraph) {
IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, newgraph);
IGRAPH_CHECK(igraph_induced_subgraph_map(mygraph, newgraph,
igraph_vss_vector(&compvertices),
IGRAPH_SUBGRAPH_AUTO,
/*map=*/ 0,
/*invmap=*/ newmapping));
IGRAPH_FINALLY(igraph_destroy, newgraph);
IGRAPH_CHECK(igraph_maxdegree(newgraph, &maxdeg, igraph_vss_all(),
IGRAPH_ALL, IGRAPH_LOOPS));
if (maxdeg > VECTOR(Qcohesion)[Qptr]) {
igraph_integer_t newconn;
kept++;
IGRAPH_CHECK(igraph_vector_ptr_push_back(&Q, newgraph));
IGRAPH_FINALLY_CLEAN(2);
IGRAPH_CHECK(igraph_vector_ptr_push_back(&Qmapping, newmapping));
IGRAPH_FINALLY_CLEAN(2);
IGRAPH_CHECK(igraph_vertex_connectivity(newgraph, &newconn,
/*checks=*/ 1));
IGRAPH_CHECK(igraph_vector_long_push_back(&Qcohesion, newconn));
IGRAPH_CHECK(igraph_vector_long_push_back(&Qparent, Qptr));
IGRAPH_CHECK(igraph_vector_bool_push_back(&Qcheck,
mycheck || addedsep));
} else {
igraph_destroy(newgraph);
igraph_free(newgraph);
igraph_vector_destroy(newmapping);
igraph_free(newmapping);
IGRAPH_FINALLY_CLEAN(4);
}
}
IGRAPH_STATUSF((" keeping %li.\n", 0, kept));
igraph_destroy(mygraph);
igraph_free(mygraph);
VECTOR(Q)[Qptr] = 0;
igraph_i_cohesive_blocks_free3(&separators);
IGRAPH_FINALLY_CLEAN(1);
Qptr++;
}
igraph_vector_long_destroy(&components);
igraph_vector_long_destroy(&compid);
igraph_dqueue_destroy(&bfsQ);
igraph_vector_destroy(&neis);
igraph_vector_bool_destroy(&marked);
igraph_vector_destroy(&compvertices);
igraph_vector_ptr_destroy(&separators);
IGRAPH_FINALLY_CLEAN(7);
if (blocks || cohesion || parent || block_tree) {
igraph_integer_t noblocks=(igraph_integer_t) Qptr, badblocks=0;
igraph_vector_bool_t removed;
long int i, resptr=0;
igraph_vector_long_t rewritemap;
IGRAPH_CHECK(igraph_vector_bool_init(&removed, noblocks));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &removed);
IGRAPH_CHECK(igraph_vector_long_init(&rewritemap, noblocks));
IGRAPH_FINALLY(igraph_vector_long_destroy, &rewritemap);
for (i=1; i<noblocks; i++) {
long int p=VECTOR(Qparent)[i];
while (VECTOR(removed)[p]) { p=VECTOR(Qparent)[p]; }
if (VECTOR(Qcohesion)[p] >= VECTOR(Qcohesion)[i]) {
VECTOR(removed)[i]=1;
badblocks++;
}
}
/* Rewrite the mappings */
for (i=1; i<Qptr; i++) {
long int p=VECTOR(Qparent)[i];
igraph_vector_t *mapping=VECTOR(Qmapping)[i];
igraph_vector_t *pmapping=VECTOR(Qmapping)[p];
long int j, n=igraph_vector_size(mapping);
if (!pmapping) { continue; }
for (j=0; j<n; j++) {
long int v=(long int) VECTOR(*mapping)[j];
VECTOR(*mapping)[j] = VECTOR(*pmapping)[v];
}
}
/* Because we also put the separator vertices in the queue, it is
not ensured that the found blocks are not subsets of each other.
We check this now. */
for (i=1; i<noblocks; i++) {
long int j, ic;
igraph_vector_t *ivec;
if (!VECTOR(Qcheck)[i] || VECTOR(removed)[i]) { continue; }
ivec=VECTOR(Qmapping)[i];
ic=VECTOR(Qcohesion)[i];
for (j=1; j<noblocks; j++) {
igraph_vector_t *jvec;
long int jc;
if (j==i || !VECTOR(Qcheck)[j] || VECTOR(removed)[j]) { continue; }
jvec=VECTOR(Qmapping)[j];
jc=VECTOR(Qcohesion)[j];
if (igraph_i_cb_isin(ivec, jvec) && jc >= ic) {
badblocks++;
VECTOR(removed)[i]=1;
break;
}
}
}
noblocks -= badblocks;
if (blocks) { IGRAPH_CHECK(igraph_vector_ptr_resize(blocks, noblocks)); }
if (cohesion) { IGRAPH_CHECK(igraph_vector_resize(cohesion, noblocks)); }
if (parent) { IGRAPH_CHECK(igraph_vector_resize(parent, noblocks)); }
for (i=0; i<Qptr; i++) {
if (VECTOR(removed)[i]) {
IGRAPH_STATUSF(("Candidate %li ignored.\n", 0, i));
continue;
} else {
IGRAPH_STATUSF(("Candidate %li is a cohesive (sub)block\n", 0, i));
}
VECTOR(rewritemap)[i] = resptr;
if (cohesion) { VECTOR(*cohesion)[resptr]=VECTOR(Qcohesion)[i]; }
if (parent || block_tree) {
long int p=VECTOR(Qparent)[i];
while (p>=0 && VECTOR(removed)[p]) { p=VECTOR(Qparent)[p]; }
if (p>=0) { p=VECTOR(rewritemap)[p]; }
VECTOR(Qparent)[i]=p;
if (parent) { VECTOR(*parent)[resptr]=p; }
}
if (blocks) {
VECTOR(*blocks)[resptr]=VECTOR(Qmapping)[i];
VECTOR(Qmapping)[i]=0;
}
resptr++;
}
/* Plus the original graph */
if (blocks) {
igraph_vector_t *orig=igraph_Calloc(1, igraph_vector_t);
if (!orig) {
IGRAPH_ERROR("Cannot do cohesive blocking", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, orig);
IGRAPH_CHECK(igraph_vector_init_seq(orig, 0, igraph_vcount(graph)-1));
VECTOR(*blocks)[0]=orig;
IGRAPH_FINALLY_CLEAN(1);
}
if (block_tree) {
igraph_vector_t edges;
long int eptr=0;
IGRAPH_VECTOR_INIT_FINALLY(&edges, noblocks*2-2);
for (i=1; i<Qptr; i++) {
if (VECTOR(removed)[i]) { continue; }
VECTOR(edges)[eptr++] = VECTOR(Qparent)[i];
VECTOR(edges)[eptr++] = VECTOR(rewritemap)[i];
}
IGRAPH_CHECK(igraph_create(block_tree, &edges, noblocks,
IGRAPH_DIRECTED));
igraph_vector_destroy(&edges);
IGRAPH_FINALLY_CLEAN(1);
}
igraph_vector_long_destroy(&rewritemap);
igraph_vector_bool_destroy(&removed);
IGRAPH_FINALLY_CLEAN(2);
}
igraph_vector_bool_destroy(&Qcheck);
igraph_vector_long_destroy(&Qcohesion);
igraph_vector_long_destroy(&Qparent);
igraph_i_cohesive_blocks_free2(&Qmapping);
IGRAPH_FINALLY_CLEAN(4);
igraph_vector_ptr_destroy(&Qmapping);
igraph_vector_ptr_destroy(&Q);
IGRAPH_FINALLY_CLEAN(3); /* + the elements of Q, they were
already destroyed */
IGRAPH_STATUS("Cohesive blocking done.\n", 0);
return 0;
}
/**
* \function igraph_community_fastgreedy
* \brief Finding community structure by greedy optimization of modularity
*
* This function implements the fast greedy modularity optimization
* algorithm for finding community structure, see
* A Clauset, MEJ Newman, C Moore: Finding community structure in very
* large networks, http://www.arxiv.org/abs/cond-mat/0408187 for the
* details.
*
* </para><para>
* Some improvements proposed in K Wakita, T Tsurumi: Finding community
* structure in mega-scale social networks,
* http://www.arxiv.org/abs/cs.CY/0702048v1 have also been implemented.
*
* \param graph The input graph. It must be a simple graph, i.e. a graph
* without multiple and without loop edges. This is checked and an
* error message is given for non-simple graphs.
* \param weights Potentially a numeric vector containing edge
* weights. Supply a null pointer here for unweighted graphs. The
* weights are expected to be non-negative.
* \param merges Pointer to an initialized matrix or NULL, the result of the
* computation is stored here. The matrix has two columns and each
* merge corresponds to one merge, the ids of the two merged
* components are stored. The component ids are numbered from zero and
* the first \c n components are the individual vertices, \c n is
* the number of vertices in the graph. Component \c n is created
* in the first merge, component \c n+1 in the second merge, etc.
* The matrix will be resized as needed. If this argument is NULL
* then it is ignored completely.
* \param modularity Pointer to an initialized matrix or NULL pointer,
* in the former case the modularity scores along the stages of the
* computation are recorded here. The vector will be resized as
* needed.
* \return Error code.
*
* \sa \ref igraph_community_walktrap(), \ref
* igraph_community_edge_betweenness() for other community detection
* algorithms, \ref igraph_community_to_membership() to convert the
* dendrogram to a membership vector.
*
* Time complexity: O(|E||V|log|V|) in the worst case,
* O(|E|+|V|log^2|V|) typically, |V| is the number of vertices, |E| is
* the number of edges.
*/
int igraph_community_fastgreedy(const igraph_t *graph,
const igraph_vector_t *weights,
igraph_matrix_t *merges, igraph_vector_t *modularity) {
long int no_of_edges, no_of_nodes, no_of_joins, total_joins;
long int i, j, k, n, m, from, to, dummy;
igraph_integer_t ffrom, fto;
igraph_eit_t edgeit;
igraph_i_fastgreedy_commpair *pairs, *p1, *p2;
igraph_i_fastgreedy_community_list communities;
igraph_vector_t a;
igraph_real_t q, maxq, *dq, weight_sum;
igraph_bool_t simple;
/*long int join_order[] = { 16,5, 5,6, 6,0, 4,0, 10,0, 26,29, 29,33, 23,33, 27,33, 25,24, 24,31, 12,3, 21,1, 30,8, 8,32, 9,2, 17,1, 11,0, 7,3, 3,2, 13,2, 1,2, 28,31, 31,33, 22,32, 18,32, 20,32, 32,33, 15,33, 14,33, 0,19, 19,2, -1,-1 };*/
/*long int join_order[] = { 43,42, 42,41, 44,41, 41,36, 35,36, 37,36, 36,29, 38,29, 34,29, 39,29, 33,29, 40,29, 32,29, 14,29, 30,29, 31,29, 6,18, 18,4, 23,4, 21,4, 19,4, 27,4, 20,4, 22,4, 26,4, 25,4, 24,4, 17,4, 0,13, 13,2, 1,2, 11,2, 8,2, 5,2, 3,2, 10,2, 9,2, 7,2, 2,28, 28,15, 12,15, 29,16, 4,15, -1,-1 };*/
no_of_nodes = igraph_vcount(graph);
no_of_edges = igraph_ecount(graph);
if (igraph_is_directed(graph)) {
IGRAPH_ERROR("fast greedy community detection works for undirected graphs only", IGRAPH_UNIMPLEMENTED);
}
total_joins=no_of_nodes-1;
if (weights != 0) {
if (igraph_vector_size(weights) < igraph_ecount(graph))
IGRAPH_ERROR("fast greedy community detection: weight vector too short", IGRAPH_EINVAL);
if (igraph_vector_any_smaller(weights, 0))
IGRAPH_ERROR("weights must be positive", IGRAPH_EINVAL);
weight_sum = igraph_vector_sum(weights);
} else weight_sum = no_of_edges;
IGRAPH_CHECK(igraph_is_simple(graph, &simple));
if (!simple) {
IGRAPH_ERROR("fast-greedy community finding works only on simple graphs", IGRAPH_EINVAL);
}
if (merges != 0) {
IGRAPH_CHECK(igraph_matrix_resize(merges, total_joins, 2));
igraph_matrix_null(merges);
}
if (modularity != 0) {
IGRAPH_CHECK(igraph_vector_resize(modularity, total_joins+1));
}
/* Create degree vector */
IGRAPH_VECTOR_INIT_FINALLY(&a, no_of_nodes);
if (weights) {
debug("Calculating weighted degrees\n");
for (i=0; i < no_of_edges; i++) {
VECTOR(a)[(long int)IGRAPH_FROM(graph, i)] += VECTOR(*weights)[i];
VECTOR(a)[(long int)IGRAPH_TO(graph, i)] += VECTOR(*weights)[i];
}
} else {
debug("Calculating degrees\n");
IGRAPH_CHECK(igraph_degree(graph, &a, igraph_vss_all(), IGRAPH_ALL, 0));
}
/* Create list of communities */
debug("Creating community list\n");
communities.n = no_of_nodes;
communities.no_of_communities = no_of_nodes;
communities.e = (igraph_i_fastgreedy_community*)calloc(no_of_nodes, sizeof(igraph_i_fastgreedy_community));
if (communities.e == 0) {
IGRAPH_ERROR("can't run fast greedy community detection", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(free, communities.e);
communities.heap = (igraph_i_fastgreedy_community**)calloc(no_of_nodes, sizeof(igraph_i_fastgreedy_community*));
if (communities.heap == 0) {
IGRAPH_ERROR("can't run fast greedy community detection", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(free, communities.heap);
communities.heapindex = (igraph_integer_t*)calloc(no_of_nodes, sizeof(igraph_integer_t));
if (communities.heapindex == 0) {
IGRAPH_ERROR("can't run fast greedy community detection", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY_CLEAN(2);
IGRAPH_FINALLY(igraph_i_fastgreedy_community_list_destroy, &communities);
for (i=0; i<no_of_nodes; i++) {
igraph_vector_ptr_init(&communities.e[i].neis, 0);
communities.e[i].id = i;
communities.e[i].size = 1;
}
/* Create list of community pairs from edges */
debug("Allocating dq vector\n");
dq = (igraph_real_t*)calloc(no_of_edges, sizeof(igraph_real_t));
if (dq == 0) {
IGRAPH_ERROR("can't run fast greedy community detection", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(free, dq);
debug("Creating community pair list\n");
IGRAPH_CHECK(igraph_eit_create(graph, igraph_ess_all(0), &edgeit));
IGRAPH_FINALLY(igraph_eit_destroy, &edgeit);
pairs = (igraph_i_fastgreedy_commpair*)calloc(2*no_of_edges, sizeof(igraph_i_fastgreedy_commpair));
if (pairs == 0) {
IGRAPH_ERROR("can't run fast greedy community detection", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(free, pairs);
i=j=0;
while (!IGRAPH_EIT_END(edgeit)) {
long int eidx = IGRAPH_EIT_GET(edgeit);
igraph_edge(graph, eidx, &ffrom, &fto);
/* Create the pairs themselves */
from = (long int)ffrom; to = (long int)fto;
if (from == to) {
IGRAPH_ERROR("loop edge detected, simplify the graph before starting community detection", IGRAPH_EINVAL);
}
if (from>to) {
dummy=from; from=to; to=dummy;
}
if (weights) {
dq[j]=2*(VECTOR(*weights)[eidx]/(weight_sum*2.0) - VECTOR(a)[from]*VECTOR(a)[to]/(4.0*weight_sum*weight_sum));
} else {
dq[j]=2*(1.0/(no_of_edges*2.0) - VECTOR(a)[from]*VECTOR(a)[to]/(4.0*no_of_edges*no_of_edges));
}
pairs[i].first = from;
pairs[i].second = to;
pairs[i].dq = &dq[j];
pairs[i].opposite = &pairs[i+1];
pairs[i+1].first = to;
pairs[i+1].second = from;
pairs[i+1].dq = pairs[i].dq;
pairs[i+1].opposite = &pairs[i];
/* Link the pair to the communities */
igraph_vector_ptr_push_back(&communities.e[from].neis, &pairs[i]);
igraph_vector_ptr_push_back(&communities.e[to].neis, &pairs[i+1]);
/* Update maximums */
if (communities.e[from].maxdq==0 || *communities.e[from].maxdq->dq < *pairs[i].dq)
communities.e[from].maxdq = &pairs[i];
if (communities.e[to].maxdq==0 || *communities.e[to].maxdq->dq < *pairs[i+1].dq)
communities.e[to].maxdq = &pairs[i+1];
/* Iterate */
i+=2; j++;
IGRAPH_EIT_NEXT(edgeit);
}
igraph_eit_destroy(&edgeit);
IGRAPH_FINALLY_CLEAN(1);
/* Sorting community neighbor lists by community IDs */
debug("Sorting community neighbor lists\n");
for (i=0, j=0; i<no_of_nodes; i++) {
igraph_vector_ptr_sort(&communities.e[i].neis, igraph_i_fastgreedy_commpair_cmp);
/* Isolated vertices won't be stored in the heap (to avoid maxdq == 0) */
if (VECTOR(a)[i] > 0) {
communities.heap[j] = &communities.e[i];
communities.heapindex[i] = j;
j++;
} else {
communities.heapindex[i] = -1;
}
}
communities.no_of_communities = j;
/* Calculate proper vector a (see paper) and initial modularity */
q=0;
igraph_vector_scale(&a, 1.0/(2.0 * (weights ? weight_sum : no_of_edges)));
for (i=0; i<no_of_nodes; i++)
q -= VECTOR(a)[i]*VECTOR(a)[i];
maxq=q;
/* Initializing community heap */
debug("Initializing community heap\n");
igraph_i_fastgreedy_community_list_build_heap(&communities);
debug("Initial modularity: %.4f\n", q);
/* Let's rock ;) */
no_of_joins=0;
while (no_of_joins<total_joins) {
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_PROGRESS("fast greedy community detection", no_of_joins*100.0/total_joins, 0);
/* Store the modularity */
if (modularity) VECTOR(*modularity)[no_of_joins] = q;
/* Some debug info if needed */
/* igraph_i_fastgreedy_community_list_check_heap(&communities); */
#ifdef DEBUG
debug("===========================================\n");
for (i=0; i<communities.n; i++) {
if (communities.e[i].maxdq == 0) {
debug("Community #%ld: PASSIVE\n", i);
continue;
}
debug("Community #%ld\n ", i);
for (j=0; j<igraph_vector_ptr_size(&communities.e[i].neis); j++) {
p1=(igraph_i_fastgreedy_commpair*)VECTOR(communities.e[i].neis)[j];
debug(" (%ld,%ld,%.4f)", p1->first, p1->second, *p1->dq);
}
p1=communities.e[i].maxdq;
debug("\n Maxdq: (%ld,%ld,%.4f)\n", p1->first, p1->second, *p1->dq);
}
debug("Global maxdq is: (%ld,%ld,%.4f)\n", communities.heap[0]->maxdq->first,
communities.heap[0]->maxdq->second, *communities.heap[0]->maxdq->dq);
for (i=0; i<communities.no_of_communities; i++)
debug("(%ld,%ld,%.4f) ", communities.heap[i]->maxdq->first, communities.heap[i]->maxdq->second, *communities.heap[0]->maxdq->dq);
debug("\n");
#endif
if (communities.heap[0] == 0) break; /* no more communities */
if (communities.heap[0]->maxdq == 0) break; /* there are only isolated comms */
to=communities.heap[0]->maxdq->second;
from=communities.heap[0]->maxdq->first;
debug("Q[%ld] = %.7f\tdQ = %.7f\t |H| = %ld\n",
no_of_joins, q, *communities.heap[0]->maxdq->dq, no_of_nodes-no_of_joins-1);
/* DEBUG */
/* from=join_order[no_of_joins*2]; to=join_order[no_of_joins*2+1];
if (to == -1) break;
for (i=0; i<igraph_vector_ptr_size(&communities.e[to].neis); i++) {
p1=(igraph_i_fastgreedy_commpair*)VECTOR(communities.e[to].neis)[i];
if (p1->second == from) communities.maxdq = p1;
} */
n = igraph_vector_ptr_size(&communities.e[to].neis);
m = igraph_vector_ptr_size(&communities.e[from].neis);
/*if (n>m) {
dummy=n; n=m; m=dummy;
dummy=to; to=from; from=dummy;
}*/
debug(" joining: %ld <- %ld\n", to, from);
q += *communities.heap[0]->maxdq->dq;
/* Merge the second community into the first */
i = j = 0;
while (i<n && j<m) {
p1 = (igraph_i_fastgreedy_commpair*)VECTOR(communities.e[to].neis)[i];
p2 = (igraph_i_fastgreedy_commpair*)VECTOR(communities.e[from].neis)[j];
debug("Pairs: %ld-%ld and %ld-%ld\n", p1->first, p1->second,
p2->first, p2->second);
if (p1->second < p2->second) {
/* Considering p1 from now on */
debug(" Considering: %ld-%ld\n", p1->first, p1->second);
if (p1->second == from) {
debug(" WILL REMOVE: %ld-%ld\n", to, from);
} else {
/* chain, case 1 */
debug(" CHAIN(1): %ld-%ld %ld, now=%.7f, adding=%.7f, newdq(%ld,%ld)=%.7f\n",
to, p1->second, from, *p1->dq, -2*VECTOR(a)[from]*VECTOR(a)[p1->second], p1->first, p1->second, *p1->dq-2*VECTOR(a)[from]*VECTOR(a)[p1->second]);
igraph_i_fastgreedy_community_update_dq(&communities, p1, *p1->dq - 2*VECTOR(a)[from]*VECTOR(a)[p1->second]);
}
i++;
} else if (p1->second == p2->second) {
/* p1->first, p1->second and p2->first form a triangle */
debug(" Considering: %ld-%ld and %ld-%ld\n", p1->first, p1->second,
p2->first, p2->second);
/* Update dq value */
debug(" TRIANGLE: %ld-%ld-%ld, now=%.7f, adding=%.7f, newdq(%ld,%ld)=%.7f\n",
to, p1->second, from, *p1->dq, *p2->dq, p1->first, p1->second, *p1->dq+*p2->dq);
igraph_i_fastgreedy_community_update_dq(&communities, p1, *p1->dq + *p2->dq);
igraph_i_fastgreedy_community_remove_nei(&communities, p1->second, from);
i++;
j++;
} else {
debug(" Considering: %ld-%ld\n", p2->first, p2->second);
if (p2->second == to) {
debug(" WILL REMOVE: %ld-%ld\n", p2->second, p2->first);
} else {
/* chain, case 2 */
debug(" CHAIN(2): %ld %ld-%ld, newdq(%ld,%ld)=%.7f\n",
to, p2->second, from, to, p2->second, *p2->dq-2*VECTOR(a)[to]*VECTOR(a)[p2->second]);
p2->opposite->second=to;
/* need to re-sort community nei list `p2->second` */
/* TODO: quicksort is O(n*logn), although we could do a deletion and
* insertion which can be done in O(logn) if deletion is O(1) */
debug(" Re-sorting community %ld\n", p2->second);
igraph_vector_ptr_sort(&communities.e[p2->second].neis, igraph_i_fastgreedy_commpair_cmp);
/* link from.neis[j] to the current place in to.neis if
* from.neis[j] != to */
p2->first=to;
IGRAPH_CHECK(igraph_vector_ptr_insert(&communities.e[to].neis,i,p2));
n++; i++;
if (*p2->dq > *communities.e[to].maxdq->dq) {
communities.e[to].maxdq = p2;
k=igraph_i_fastgreedy_community_list_find_in_heap(&communities, to);
igraph_i_fastgreedy_community_list_sift_up(&communities, k);
}
igraph_i_fastgreedy_community_update_dq(&communities, p2, *p2->dq - 2*VECTOR(a)[to]*VECTOR(a)[p2->second]);
}
j++;
}
}
while (i<n) {
p1 = (igraph_i_fastgreedy_commpair*)VECTOR(communities.e[to].neis)[i];
if (p1->second == from) {
debug(" WILL REMOVE: %ld-%ld\n", p1->first, from);
} else {
/* chain, case 1 */
debug(" CHAIN(1): %ld-%ld %ld, now=%.7f, adding=%.7f, newdq(%ld,%ld)=%.7f\n",
to, p1->second, from, *p1->dq, -2*VECTOR(a)[from]*VECTOR(a)[p1->second], p1->first, p1->second, *p1->dq-2*VECTOR(a)[from]*VECTOR(a)[p1->second]);
igraph_i_fastgreedy_community_update_dq(&communities, p1, *p1->dq - 2*VECTOR(a)[from]*VECTOR(a)[p1->second]);
}
i++;
}
while (j<m) {
p2 = (igraph_i_fastgreedy_commpair*)VECTOR(communities.e[from].neis)[j];
if (to == p2->second) { j++; continue; }
/* chain, case 2 */
debug(" CHAIN(2): %ld %ld-%ld, newdq(%ld,%ld)=%.7f\n",
to, p2->second, from, p1->first, p2->second, *p2->dq-2*VECTOR(a)[to]*VECTOR(a)[p2->second]);
p2->opposite->second=to;
/* need to re-sort community nei list `p2->second` */
/* TODO: quicksort is O(n*logn), although we could do a deletion and
* insertion which can be done in O(logn) if deletion is O(1) */
debug(" Re-sorting community %ld\n", p2->second);
igraph_vector_ptr_sort(&communities.e[p2->second].neis, igraph_i_fastgreedy_commpair_cmp);
/* link from.neis[j] to the current place in to.neis if
* from.neis[j] != to */
p2->first=to;
IGRAPH_CHECK(igraph_vector_ptr_push_back(&communities.e[to].neis,p2));
if (*p2->dq > *communities.e[to].maxdq->dq) {
communities.e[to].maxdq = p2;
k=igraph_i_fastgreedy_community_list_find_in_heap(&communities, to);
igraph_i_fastgreedy_community_list_sift_up(&communities, k);
}
igraph_i_fastgreedy_community_update_dq(&communities, p2, *p2->dq-2*VECTOR(a)[to]*VECTOR(a)[p2->second]);
j++;
}
/* Now, remove community `from` from the neighbors of community `to` */
if (communities.no_of_communities > 2) {
debug(" REMOVING: %ld-%ld\n", to, from);
igraph_i_fastgreedy_community_remove_nei(&communities, to, from);
i=igraph_i_fastgreedy_community_list_find_in_heap(&communities, from);
igraph_i_fastgreedy_community_list_remove(&communities, i);
}
communities.e[from].maxdq=0;
/* Update community sizes */
communities.e[to].size += communities.e[from].size;
communities.e[from].size = 0;
/* record what has been merged */
/* igraph_vector_ptr_clear is not enough here as it won't free
* the memory consumed by communities.e[from].neis. Thanks
* to Tom Gregorovic for pointing that out. */
igraph_vector_ptr_destroy(&communities.e[from].neis);
if (merges) {
MATRIX(*merges, no_of_joins, 0) = communities.e[to].id;
MATRIX(*merges, no_of_joins, 1) = communities.e[from].id;
communities.e[to].id = no_of_nodes+no_of_joins;
}
/* Update vector a */
VECTOR(a)[to] += VECTOR(a)[from];
VECTOR(a)[from] = 0.0;
no_of_joins++;
}
/* TODO: continue merging when some isolated communities remained. Always
* joining the communities with the least number of nodes results in the
* smallest decrease in modularity every step. Now we're simply deleting
* the excess rows from the merge matrix */
if (no_of_joins < total_joins) {
long int *ivec;
ivec=igraph_Calloc(igraph_matrix_nrow(merges), long int);
if (ivec == 0)
IGRAPH_ERROR("can't run fast greedy community detection", IGRAPH_ENOMEM);
IGRAPH_FINALLY(free, ivec);
for (i=0; i<no_of_joins; i++) ivec[i] = i+1;
igraph_matrix_permdelete_rows(merges, ivec, total_joins-no_of_joins);
free(ivec);
IGRAPH_FINALLY_CLEAN(1);
}
void igraph_i_graphml_add_attribute_key(const xmlChar** attrs,
struct igraph_i_graphml_parser_state *state) {
xmlChar **it;
igraph_trie_t *trie=0;
igraph_vector_ptr_t *ptrvector=0;
long int id;
int ret;
igraph_i_graphml_attribute_record_t *rec=
igraph_Calloc(1, igraph_i_graphml_attribute_record_t);
if (!state->successful) return;
if (rec==0) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__,
IGRAPH_ENOMEM);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
IGRAPH_FINALLY(igraph_free, rec);
for (it=(xmlChar**)attrs; *it; it+=2) {
if (xmlStrEqual(*it, toXmlChar("id"))) {
const char *id=(const char*)(*(it+1));
rec->id=strdup(id);
} else if (xmlStrEqual(*it, toXmlChar("attr.name"))) {
const char *name=fromXmlChar(*(it+1));
rec->record.name=strdup(name);
} else if (xmlStrEqual(*it, toXmlChar("attr.type"))) {
if (xmlStrEqual(*(it+1), (xmlChar*)"boolean")) {
rec->type=I_GRAPHML_BOOLEAN;
rec->record.type=IGRAPH_ATTRIBUTE_NUMERIC;
} else if (xmlStrEqual(*(it+1), toXmlChar("string"))) {
rec->type=I_GRAPHML_STRING;
rec->record.type=IGRAPH_ATTRIBUTE_STRING;
} else if (xmlStrEqual(*(it+1), toXmlChar("float"))) {
rec->type=I_GRAPHML_FLOAT;
rec->record.type=IGRAPH_ATTRIBUTE_NUMERIC;
} else if (xmlStrEqual(*(it+1), toXmlChar("double"))) {
rec->type=I_GRAPHML_DOUBLE;
rec->record.type=IGRAPH_ATTRIBUTE_NUMERIC;
} else if (xmlStrEqual(*(it+1), toXmlChar("int"))) {
rec->type=I_GRAPHML_INTEGER;
rec->record.type=IGRAPH_ATTRIBUTE_NUMERIC;
} else if (xmlStrEqual(*(it+1), toXmlChar("long"))) {
rec->type=I_GRAPHML_LONG;
rec->record.type=IGRAPH_ATTRIBUTE_NUMERIC;
} else {
igraph_error("Cannot parse GraphML file, unknown attribute type",
__FILE__, __LINE__, IGRAPH_PARSEERROR);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file, unknown attribute type");
return;
}
} else if (xmlStrEqual(*it, toXmlChar("for"))) {
/* graph, vertex or edge attribute? */
if (xmlStrEqual(*(it+1), toXmlChar("graph"))) {
trie=&state->g_names;
ptrvector=&state->g_attrs;
} else if (xmlStrEqual(*(it+1), toXmlChar("node"))) {
trie=&state->v_names;
ptrvector=&state->v_attrs;
} else if (xmlStrEqual(*(it+1), toXmlChar("edge"))) {
trie=&state->e_names;
ptrvector=&state->e_attrs;
} else {
igraph_error("Cannot parse GraphML file, unknown attribute type",
__FILE__, __LINE__, IGRAPH_PARSEERROR);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file, unknown attribute type");
return;
}
}
}
if (trie == 0 && state->successful) {
igraph_error("Cannot parse GraphML file, missing 'for' attribute", __FILE__, __LINE__, IGRAPH_PARSEERROR);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file, missing 'for' attribute");
return;
}
/* add to trie, attribues */
igraph_trie_get(trie, rec->id, &id);
if (id != igraph_trie_size(trie)-1) {
igraph_error("Cannot parse GraphML file, duplicate attribute",
__FILE__, __LINE__, IGRAPH_PARSEERROR);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file, duplicate attribute");
return;
}
ret=igraph_vector_ptr_push_back(ptrvector, rec);
if (ret) {
igraph_error("Cannot read GraphML file", __FILE__, __LINE__, ret);
igraph_i_graphml_sax_handler_error(state, "Cannot read GraphML file");
return;
}
/* create the attribute values */
switch (rec->record.type) {
igraph_vector_t *vec;
igraph_strvector_t *strvec;
case IGRAPH_ATTRIBUTE_NUMERIC:
vec=igraph_Calloc(1, igraph_vector_t);
if (vec==0) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__,
IGRAPH_ENOMEM);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
rec->record.value=vec;
igraph_vector_init(vec, 0);
break;
case IGRAPH_ATTRIBUTE_STRING:
strvec=igraph_Calloc(1, igraph_strvector_t);
if (strvec==0) {
igraph_error("Cannot parse GraphML file", __FILE__, __LINE__,
IGRAPH_ENOMEM);
igraph_i_graphml_sax_handler_error(state, "Cannot parse GraphML file");
return;
}
rec->record.value=strvec;
igraph_strvector_init(strvec, 0);
break;
default: break;
}
IGRAPH_FINALLY_CLEAN(1); /* rec */
}
int igraph_i_maximal_independent_vertex_sets_backtrack(const igraph_t *graph,
igraph_vector_ptr_t *res,
igraph_i_max_ind_vsets_data_t *clqdata,
igraph_integer_t level) {
long int v1, v2, v3, c, j, k;
igraph_vector_t *neis1, *neis2;
igraph_bool_t f;
igraph_integer_t j1;
long int it_state;
IGRAPH_ALLOW_INTERRUPTION();
if (level >= clqdata->matrix_size-1) {
igraph_integer_t size=0;
if (res) {
igraph_vector_t *vec;
vec = igraph_Calloc(1, igraph_vector_t);
if (vec == 0)
IGRAPH_ERROR("igraph_i_maximal_independent_vertex_sets failed", IGRAPH_ENOMEM);
IGRAPH_VECTOR_INIT_FINALLY(vec, 0);
for (v1=0; v1<clqdata->matrix_size; v1++)
if (clqdata->IS[v1] == 0) {
IGRAPH_CHECK(igraph_vector_push_back(vec, v1));
}
size=igraph_vector_size(vec);
if (!clqdata->keep_only_largest)
IGRAPH_CHECK(igraph_vector_ptr_push_back(res, vec));
else {
if (size > clqdata->largest_set_size) {
/* We are keeping only the largest sets, and we've found one that's
* larger than all previous sets, so we have to clear the list */
j=igraph_vector_ptr_size(res);
for (v1=0; v1<j; v1++) {
igraph_vector_destroy(VECTOR(*res)[v1]);
free(VECTOR(*res)[v1]);
}
igraph_vector_ptr_clear(res);
IGRAPH_CHECK(igraph_vector_ptr_push_back(res, vec));
} else if (size == clqdata->largest_set_size) {
IGRAPH_CHECK(igraph_vector_ptr_push_back(res, vec));
} else {
igraph_vector_destroy(vec);
free(vec);
}
}
IGRAPH_FINALLY_CLEAN(1);
} else {
for (v1=0, size=0; v1<clqdata->matrix_size; v1++)
if (clqdata->IS[v1] == 0) size++;
}
if (size>clqdata->largest_set_size) clqdata->largest_set_size=size;
} else {
v1 = level+1;
/* Count the number of vertices with an index less than v1 that have
* an IS value of zero */
neis1 = igraph_adjlist_get(&clqdata->adj_list, v1);
c = 0;
j = 0;
while (j<VECTOR(clqdata->deg)[v1] && (v2=VECTOR(*neis1)[j]) <= level) {
if (clqdata->IS[v2] == 0) c++;
j++;
}
if (c == 0) {
/* If there are no such nodes... */
j = 0;
while (j<VECTOR(clqdata->deg)[v1] && (v2=VECTOR(*neis1)[j]) <= level) {
clqdata->IS[v2]++;
j++;
}
IGRAPH_CHECK(igraph_i_maximal_independent_vertex_sets_backtrack(graph,res,clqdata,v1));
j = 0;
while (j<VECTOR(clqdata->deg)[v1] && (v2=VECTOR(*neis1)[j]) <= level) {
clqdata->IS[v2]--;
j++;
}
} else {
/* If there are such nodes, store the count in the IS value of v1 */
clqdata->IS[v1] = c;
IGRAPH_CHECK(igraph_i_maximal_independent_vertex_sets_backtrack(graph,res,clqdata,v1));
clqdata->IS[v1] = 0;
f=1;
j=0;
while (j<VECTOR(clqdata->deg)[v1] && (v2=VECTOR(*neis1)[j]) <= level) {
if (clqdata->IS[v2] == 0) {
IGRAPH_CHECK(igraph_set_add(&clqdata->buckets[v1], j));
neis2 = igraph_adjlist_get(&clqdata->adj_list, v2);
k = 0;
while (k<VECTOR(clqdata->deg)[v2] && (v3=VECTOR(*neis2)[k])<=level) {
clqdata->IS[v3]--;
if (clqdata->IS[v3] == 0) f=0;
k++;
}
}
clqdata->IS[v2]++;
j++;
}
if (f)
IGRAPH_CHECK(igraph_i_maximal_independent_vertex_sets_backtrack(graph,res,clqdata,v1));
j=0;
while (j<VECTOR(clqdata->deg)[v1] && (v2=VECTOR(*neis1)[j]) <= level) {
clqdata->IS[v2]--;
j++;
}
it_state=0;
while (igraph_set_iterate(&clqdata->buckets[v1], &it_state, &j1)) {
j=(long)j1;
v2=VECTOR(*neis1)[j];
neis2 = igraph_adjlist_get(&clqdata->adj_list, v2);
k = 0;
while (k<VECTOR(clqdata->deg)[v2] && (v3=VECTOR(*neis2)[k])<=level) {
clqdata->IS[v3]++;
k++;
}
}
igraph_set_clear(&clqdata->buckets[v1]);
}
}
return 0;
}
void custom_destructor(void* ptr) {
igraph_vector_ptr_push_back(&custom_destructor_stack, ptr);
}
int igraph_biconnected_components(const igraph_t *graph,
igraph_integer_t *no,
igraph_vector_ptr_t *tree_edges,
igraph_vector_ptr_t *component_edges,
igraph_vector_ptr_t *components,
igraph_vector_t *articulation_points) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_long_t nextptr;
igraph_vector_long_t num, low;
igraph_vector_bool_t found;
igraph_vector_int_t *adjedges;
igraph_stack_t path;
igraph_vector_t edgestack;
igraph_inclist_t inclist;
long int i, counter, rootdfs=0;
igraph_vector_long_t vertex_added;
long int comps=0;
igraph_vector_ptr_t *mycomponents=components, vcomponents;
IGRAPH_CHECK(igraph_vector_long_init(&nextptr, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &nextptr);
IGRAPH_CHECK(igraph_vector_long_init(&num, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &num);
IGRAPH_CHECK(igraph_vector_long_init(&low, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &low);
IGRAPH_CHECK(igraph_vector_bool_init(&found, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &found);
IGRAPH_CHECK(igraph_stack_init(&path, 100));
IGRAPH_FINALLY(igraph_stack_destroy, &path);
IGRAPH_VECTOR_INIT_FINALLY(&edgestack, 0);
IGRAPH_CHECK(igraph_vector_reserve(&edgestack, 100));
IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_inclist_destroy, &inclist);
IGRAPH_CHECK(igraph_vector_long_init(&vertex_added, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &vertex_added);
if (no) {
*no=0;
}
if (tree_edges) {
igraph_vector_ptr_clear(tree_edges);
}
if (components) {
igraph_vector_ptr_clear(components);
}
if (component_edges) {
igraph_vector_ptr_clear(component_edges);
}
if (articulation_points) {
igraph_vector_clear(articulation_points);
}
if (component_edges && !components) {
mycomponents=&vcomponents;
IGRAPH_CHECK(igraph_vector_ptr_init(mycomponents, 0));
IGRAPH_FINALLY(igraph_i_free_vectorlist, mycomponents);
}
for (i=0; i<no_of_nodes; i++) {
if (VECTOR(low)[i] != 0) { continue; } /* already visited */
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_stack_push(&path, i));
counter=1;
rootdfs=0;
VECTOR(low)[i]=VECTOR(num)[i]=counter++;
while (!igraph_stack_empty(&path)) {
long int n;
long int act=(long int) igraph_stack_top(&path);
long int actnext=VECTOR(nextptr)[act];
adjedges=igraph_inclist_get(&inclist, act);
n=igraph_vector_int_size(adjedges);
if (actnext < n) {
/* Step down (maybe) */
long int edge=(long int) VECTOR(*adjedges)[actnext];
long int nei=IGRAPH_OTHER(graph, edge, act);
if (VECTOR(low)[nei] == 0) {
if (act==i) { rootdfs++; }
IGRAPH_CHECK(igraph_vector_push_back(&edgestack, edge));
IGRAPH_CHECK(igraph_stack_push(&path, nei));
VECTOR(low)[nei] = VECTOR(num)[nei]=counter++;
} else {
/* Update low value if needed */
if (VECTOR(num)[nei] < VECTOR(low)[act]) {
VECTOR(low)[act]=VECTOR(num)[nei];
}
}
VECTOR(nextptr)[act] += 1;
} else {
/* Step up */
igraph_stack_pop(&path);
if (!igraph_stack_empty(&path)) {
long int prev=(long int) igraph_stack_top(&path);
/* Update LOW value if needed */
if (VECTOR(low)[act] < VECTOR(low)[prev]) {
VECTOR(low)[prev] = VECTOR(low)[act];
}
/* Check for articulation point */
if (VECTOR(low)[act] >= VECTOR(num)[prev]) {
if (articulation_points && !VECTOR(found)[prev]
&& prev != i /* the root */) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, prev));
VECTOR(found)[prev] = 1;
}
if (no) { *no += 1; }
/*------------------------------------*/
/* Record the biconnected component just found */
if (tree_edges || mycomponents) {
igraph_vector_t *v = 0, *v2 = 0;
comps++;
if (tree_edges) {
v=igraph_Calloc(1, igraph_vector_t);
if (!v) { IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM); }
IGRAPH_CHECK(igraph_vector_init(v, 0));
IGRAPH_FINALLY(igraph_vector_destroy, v);
}
if (mycomponents) {
v2=igraph_Calloc(1, igraph_vector_t);
if (!v2) { IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM); }
IGRAPH_CHECK(igraph_vector_init(v2, 0));
IGRAPH_FINALLY(igraph_vector_destroy, v2);
}
while (!igraph_vector_empty(&edgestack)) {
long int e=(long int) igraph_vector_pop_back(&edgestack);
long int from=IGRAPH_FROM(graph,e);
long int to=IGRAPH_TO(graph,e);
if (tree_edges) {
IGRAPH_CHECK(igraph_vector_push_back(v, e));
}
if (mycomponents) {
if (VECTOR(vertex_added)[from] != comps) {
VECTOR(vertex_added)[from] = comps;
IGRAPH_CHECK(igraph_vector_push_back(v2, from));
}
if (VECTOR(vertex_added)[to] != comps) {
VECTOR(vertex_added)[to] = comps;
IGRAPH_CHECK(igraph_vector_push_back(v2, to));
}
}
if (from==prev || to==prev) {
break;
}
}
if (mycomponents) {
IGRAPH_CHECK(igraph_vector_ptr_push_back(mycomponents, v2));
IGRAPH_FINALLY_CLEAN(1);
}
if (tree_edges) {
IGRAPH_CHECK(igraph_vector_ptr_push_back(tree_edges, v));
IGRAPH_FINALLY_CLEAN(1);
}
if (component_edges) {
igraph_vector_t *nodes=VECTOR(*mycomponents)[comps-1];
igraph_vector_t *vv=igraph_Calloc(1, igraph_vector_t);
long int ii, no_vert=igraph_vector_size(nodes);
if (!vv) { IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM); }
IGRAPH_CHECK(igraph_vector_init(vv, 0));
IGRAPH_FINALLY(igraph_vector_destroy, vv);
for (ii=0; ii<no_vert; ii++) {
long int vert=(long int) VECTOR(*nodes)[ii];
igraph_vector_int_t *edges=igraph_inclist_get(&inclist,
vert);
long int j, nn=igraph_vector_int_size(edges);
for (j=0; j<nn; j++) {
long int e=(long int) VECTOR(*edges)[j];
long int nei=IGRAPH_OTHER(graph, e, vert);
if (VECTOR(vertex_added)[nei] == comps && nei<vert) {
IGRAPH_CHECK(igraph_vector_push_back(vv, e));
}
}
}
IGRAPH_CHECK(igraph_vector_ptr_push_back(component_edges, vv));
IGRAPH_FINALLY_CLEAN(1);
}
} /* record component if requested */
/*------------------------------------*/
}
} /* !igraph_stack_empty(&path) */
}
} /* !igraph_stack_empty(&path) */
if (articulation_points && rootdfs >= 2) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, i));
}
} /* i < no_of_nodes */
if (mycomponents != components) {
igraph_i_free_vectorlist(mycomponents);
IGRAPH_FINALLY_CLEAN(1);
}
igraph_vector_long_destroy(&vertex_added);
igraph_inclist_destroy(&inclist);
igraph_vector_destroy(&edgestack);
igraph_stack_destroy(&path);
igraph_vector_bool_destroy(&found);
igraph_vector_long_destroy(&low);
igraph_vector_long_destroy(&num);
igraph_vector_long_destroy(&nextptr);
IGRAPH_FINALLY_CLEAN(8);
return 0;
}
/* Internal function for calculating cliques or independent vertex sets.
* They are practically the same except that the complementer of the graph
* should be used in the latter case.
*/
int igraph_i_cliques(const igraph_t *graph, igraph_vector_ptr_t *res,
igraph_integer_t min_size, igraph_integer_t max_size,
igraph_bool_t independent_vertices) {
igraph_integer_t no_of_nodes;
igraph_vector_t neis;
igraph_real_t *member_storage=0, *new_member_storage, *c1;
long int i, j, k, clique_count, old_clique_count;
if (igraph_is_directed(graph))
IGRAPH_WARNING("directionality of edges is ignored for directed graphs");
no_of_nodes = igraph_vcount(graph);
if (min_size < 0) { min_size = 0; }
if (max_size > no_of_nodes || max_size <= 0) { max_size = no_of_nodes; }
igraph_vector_ptr_clear(res);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
IGRAPH_FINALLY(igraph_i_cliques_free_res, res);
/* Will be resized later, if needed. */
member_storage=igraph_Calloc(1, igraph_real_t);
if (member_storage==0) {
IGRAPH_ERROR("cliques failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, member_storage);
/* Find all 1-cliques: every vertex will be a clique */
new_member_storage=igraph_Calloc(no_of_nodes, igraph_real_t);
if (new_member_storage==0) {
IGRAPH_ERROR("cliques failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, new_member_storage);
for (i=0; i<no_of_nodes; i++) {
new_member_storage[i] = i;
}
clique_count = no_of_nodes;
old_clique_count = 0;
/* Add size 1 cliques if requested */
if (min_size <= 1) {
IGRAPH_CHECK(igraph_vector_ptr_resize(res, no_of_nodes));
igraph_vector_ptr_null(res);
for (i=0; i<no_of_nodes; i++) {
igraph_vector_t *p=igraph_Calloc(1, igraph_vector_t);
if (p==0) {
IGRAPH_ERROR("cliques failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, p);
IGRAPH_CHECK(igraph_vector_init(p, 1));
VECTOR(*p)[0]=i;
VECTOR(*res)[i]=p;
IGRAPH_FINALLY_CLEAN(1);
}
}
for (i=2; i<=max_size && clique_count > 1; i++) {
/* Here new_member_storage contains the cliques found in the previous
iteration. Save this into member_storage, might be needed later */
c1=member_storage;
member_storage=new_member_storage;
new_member_storage=c1;
old_clique_count=clique_count;
IGRAPH_ALLOW_INTERRUPTION();
/* Calculate the cliques */
IGRAPH_FINALLY_CLEAN(2);
IGRAPH_CHECK(igraph_i_find_k_cliques(graph, i, member_storage,
&new_member_storage,
old_clique_count,
&clique_count,
&neis,
independent_vertices));
IGRAPH_FINALLY(igraph_free, member_storage);
IGRAPH_FINALLY(igraph_free, new_member_storage);
/* Add the cliques just found to the result if requested */
if (i>=min_size && i<=max_size) {
for (j=0, k=0; j<clique_count; j++, k+=i) {
igraph_vector_t *p=igraph_Calloc(1, igraph_vector_t);
if (p==0) {
IGRAPH_ERROR("cliques failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, p);
IGRAPH_CHECK(igraph_vector_init_copy(p, &new_member_storage[k], i));
IGRAPH_FINALLY(igraph_vector_destroy, p);
IGRAPH_CHECK(igraph_vector_ptr_push_back(res, p));
IGRAPH_FINALLY_CLEAN(2);
}
}
} /* i <= max_size && clique_count != 0 */
igraph_free(member_storage);
igraph_free(new_member_storage);
igraph_vector_destroy(&neis);
IGRAPH_FINALLY_CLEAN(4); /* 3 here, +1 is igraph_i_cliques_free_res */
return 0;
}
int igraph_decompose(const igraph_t *graph, igraph_vector_ptr_t *components,
igraph_connectedness_t mode,
long int maxcompno, long int minelements) {
long int actstart;
long int no_of_nodes=igraph_vcount(graph);
long int resco=0; /* number of graphs created so far */
char *already_added;
igraph_dqueue_t q;
igraph_vector_t verts;
igraph_vector_t neis;
long int i;
igraph_t *newg;
if (!igraph_is_directed(graph)) {
mode=IGRAPH_WEAK;
}
if (mode != IGRAPH_WEAK) {
IGRAPH_ERROR("only 'IGRAPH_WEAK' is implemented", IGRAPH_EINVAL);
}
if (maxcompno<0) {
maxcompno=LONG_MAX;
}
igraph_vector_ptr_clear(components);
IGRAPH_FINALLY(igraph_decompose_destroy, components);
already_added=igraph_Calloc(no_of_nodes, char);
if (already_added==0) {
IGRAPH_ERROR("Cannot decompose graph", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, already_added);
IGRAPH_CHECK(igraph_dqueue_init(&q, 100));
IGRAPH_FINALLY(igraph_dqueue_destroy, &q);
IGRAPH_VECTOR_INIT_FINALLY(&verts, 0);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
for(actstart=0; resco<maxcompno && actstart < no_of_nodes; actstart++) {
if (already_added[actstart]) { continue; }
IGRAPH_ALLOW_INTERRUPTION();
igraph_vector_clear(&verts);
already_added[actstart]=1;
IGRAPH_CHECK(igraph_vector_push_back(&verts, actstart));
IGRAPH_CHECK(igraph_dqueue_push(&q, actstart));
while (!igraph_dqueue_empty(&q) ) {
long int actvert=(long int) igraph_dqueue_pop(&q);
IGRAPH_CHECK(igraph_neighbors(graph, &neis, (igraph_integer_t) actvert,
IGRAPH_ALL));
for (i=0; i<igraph_vector_size(&neis); i++) {
long int neighbor=(long int) VECTOR(neis)[i];
if (already_added[neighbor]==1) { continue; }
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
IGRAPH_CHECK(igraph_vector_push_back(&verts, neighbor));
already_added[neighbor]=1;
}
}
/* ok, we have a component */
if (igraph_vector_size(&verts)<minelements) { continue; }
newg=igraph_Calloc(1, igraph_t);
if (newg==0) {
IGRAPH_ERROR("Cannot decompose graph", IGRAPH_ENOMEM);
}
IGRAPH_CHECK(igraph_vector_ptr_push_back(components, newg));
IGRAPH_CHECK(igraph_induced_subgraph(graph, newg,
igraph_vss_vector(&verts),
IGRAPH_SUBGRAPH_AUTO));
resco++;
} /* for actstart++ */
igraph_vector_destroy(&neis);
igraph_vector_destroy(&verts);
igraph_dqueue_destroy(&q);
igraph_free(already_added);
IGRAPH_FINALLY_CLEAN(5); /* + components */
return 0;
}
/* call-seq:
* graph.get_shortest_paths(from,to_array,mode) -> Array
*
* Calculates the paths from the vertex specified as from to each vertex in the
* to_array Array. Returns an Array of Arrays. Each top level Array represents
* a path and each entry in each Array is a vertex on the path. mode
* represents the type of shortest paths to be calculated: IGraph::OUT
* the outgoing paths are calculated. IGraph::IN the incoming paths are
* calculated. IGraph::ALL the directed graph is considered as an undirected
* one for the computation.
*/
VALUE cIGraph_get_dijkstra_shortest_paths(VALUE self, VALUE from, VALUE to, VALUE weights, VALUE mode){
igraph_t *graph;
igraph_integer_t from_vid;
igraph_vs_t to_vids;
igraph_vector_t to_vidv;
igraph_vector_t wghts;
igraph_neimode_t pmode = NUM2INT(mode);
igraph_vector_ptr_t res;
igraph_vector_t *path_v;
int i;
int j;
VALUE path;
VALUE matrix = rb_ary_new();
int n_paths;
Data_Get_Struct(self, igraph_t, graph);
n_paths = RARRAY_LEN(to);
//vector to hold the results of the calculations
igraph_vector_ptr_init(&res,0);
for(i=0;i<n_paths;i++){
path_v = malloc(sizeof(igraph_vector_t));
igraph_vector_init(path_v,0);
igraph_vector_ptr_push_back(&res,path_v);
}
igraph_vector_init(&wghts,RARRAY_LEN(weights));
for(i=0;i<RARRAY_LEN(weights);i++){
VECTOR(wghts)[i] = NUM2DBL(RARRAY_PTR(weights)[i]);
}
//Convert an array of vertices to a vector of vertex ids
igraph_vector_init_int(&to_vidv,0);
cIGraph_vertex_arr_to_id_vec(self,to,&to_vidv);
//create vertex selector from the vecotr of ids
igraph_vs_vector(&to_vids,&to_vidv);
//The id of the vertex from where we are counting
from_vid = cIGraph_get_vertex_id(self, from);
//igraph_get_shortest_paths(graph,&res,from_vid,to_vids,pmode);
igraph_get_shortest_paths_dijkstra(graph,&res,from_vid,to_vids,igraph_vector_size(&wghts) > 0 ? &wghts : NULL,pmode);
for(i=0; i<n_paths; i++){
path = rb_ary_new();
rb_ary_push(matrix,path);
path_v = VECTOR(res)[i];
for(j=0; j<igraph_vector_size(VECTOR(res)[i]); j++){
rb_ary_push(path,cIGraph_get_vertex_object(self,VECTOR(*path_v)[j]));
}
}
for(i=0;i<n_paths;i++){
igraph_vector_destroy(VECTOR(res)[i]);
free(VECTOR(res)[i]);
}
igraph_vector_destroy(&to_vidv);
igraph_vector_ptr_destroy(&res);
igraph_vs_destroy(&to_vids);
igraph_vector_destroy(&wghts);
return matrix;
/*
igraph_t *graph;
igraph_integer_t from_vid;
igraph_vs_t to_vids;
igraph_vector_t to_vidv;
igraph_vector_t wghts;
igraph_neimode_t pmode = NUM2INT(mode);
igraph_vector_ptr_t res;
igraph_vector_t *path_v;
int i;
int j;
VALUE path;
VALUE matrix = rb_ary_new();
int n_paths = 0;
Data_Get_Struct(self, igraph_t, graph);
n_paths = RARRAY_LEN(to);
//vector to hold the results of the calculations
igraph_vector_ptr_init(&res,0);
for(i=0;i<n_paths;i++)
{
path_v = malloc(sizeof(igraph_vector_t));
igraph_vector_init(path_v,0);
igraph_vector_ptr_push_back(&res,path_v);
}
igraph_vector_init(&wghts,RARRAY_LEN(weights));
for(i=0;i<RARRAY_LEN(weights);i++){
VECTOR(wghts)[i] = NUM2DBL(RARRAY_PTR(weights)[i]);
}
//Convert an array of vertices to a vector of vertex ids
igraph_vector_init_int(&to_vidv,0);
cIGraph_vertex_arr_to_id_vec(self,to,&to_vidv);
//create vertex selector from the vecotr of ids
igraph_vs_vector(&to_vids,&to_vidv);
//The id of the vertex from where we are counting
from_vid = cIGraph_get_vertex_id(self, from);
igraph_get_shortest_paths(graph,&res,from_vid,to_vids,pmode);
//igraph_get_shortest_paths_dijkstra(graph,&res,from_vid,to_vids,igraph_vector_size(&wghts) > 0 ? &wghts : NULL,pmode);
for(i=0; i<n_paths; i++){
path = rb_ary_new();
rb_ary_push(matrix,path);
path_v = VECTOR(res)[i];
for(j=0; j<igraph_vector_size(VECTOR(res)[i]); j++){
rb_ary_push(path,cIGraph_get_vertex_object(self,VECTOR(*path_v)[j]));
}
}
for(i=0;i<n_paths;i++){
igraph_vector_destroy(VECTOR(res)[i]);
free(VECTOR(res)[i]);
}
igraph_vector_destroy(&to_vidv);
igraph_vector_ptr_destroy(&res);
igraph_vs_destroy(&to_vids);
igraph_vector_destroy(&wghts);
return matrix;
*/
}
VALUE cIGraph_initialize(int argc, VALUE *argv, VALUE self){
igraph_t *graph;
igraph_vector_t edge_v;
VALUE vertex;
VALUE directed;
VALUE edges;
VALUE attrs;
VALUE v_ary;
int vertex_n = 0;
int current_vertex_id;
int i;
igraph_vector_ptr_t vertex_attr;
igraph_vector_ptr_t edge_attr;
igraph_i_attribute_record_t v_attr_rec;
v_attr_rec.name = "__RUBY__";
v_attr_rec.type = IGRAPH_ATTRIBUTE_PY_OBJECT;
v_attr_rec.value = (void*)rb_ary_new();
igraph_i_attribute_record_t e_attr_rec;
e_attr_rec.name = "__RUBY__";
e_attr_rec.type = IGRAPH_ATTRIBUTE_PY_OBJECT;
e_attr_rec.value = (void*)rb_ary_new();
rb_scan_args(argc,argv,"12", &edges, &directed, &attrs);
//Initialize edge vector
IGRAPH_FINALLY(igraph_vector_destroy,&edge_v);
IGRAPH_FINALLY(igraph_vector_ptr_destroy,&vertex_attr);
IGRAPH_FINALLY(igraph_vector_ptr_destroy,&edge_attr);
IGRAPH_CHECK(igraph_vector_init_int(&edge_v,0));
IGRAPH_CHECK(igraph_vector_ptr_init(&vertex_attr,0));
IGRAPH_CHECK(igraph_vector_ptr_init(&edge_attr,0));
Data_Get_Struct(self, igraph_t, graph);
v_ary = rb_ary_new();
if(!directed)
IGRAPH_CHECK(igraph_to_undirected(graph,IGRAPH_TO_UNDIRECTED_COLLAPSE));
//Loop through objects in edge Array
for (i=0; i<RARRAY_LEN(edges); i++) {
vertex = RARRAY_PTR(edges)[i];
if(rb_ary_includes(v_ary,vertex)){
//If @vertices includes this vertex then look up the vertex number
current_vertex_id = NUM2INT(rb_funcall(v_ary,rb_intern("index"),1,vertex));
} else {
//Otherwise add to the list of vertices
rb_ary_push(v_ary,vertex);
current_vertex_id = vertex_n;
vertex_n++;
//Add object to list of vertex attributes
rb_ary_push((VALUE)v_attr_rec.value,vertex);
}
IGRAPH_CHECK(igraph_vector_push_back(&edge_v,current_vertex_id));
if (i % 2){
if (attrs != Qnil){
rb_ary_push((VALUE)e_attr_rec.value,RARRAY_PTR(attrs)[i/2]);
} else {
rb_ary_push((VALUE)e_attr_rec.value,Qnil);
}
}
}
IGRAPH_CHECK(igraph_vector_ptr_push_back(&vertex_attr, &v_attr_rec));
IGRAPH_CHECK(igraph_vector_ptr_push_back(&edge_attr, &e_attr_rec));
if(igraph_vector_size(&edge_v) > 0){
IGRAPH_CHECK(igraph_add_vertices(graph,vertex_n,&vertex_attr));
IGRAPH_CHECK(igraph_add_edges(graph,&edge_v,&edge_attr));
}
igraph_vector_destroy(&edge_v);
igraph_vector_ptr_destroy(&vertex_attr);
igraph_vector_ptr_destroy(&edge_attr);
IGRAPH_FINALLY_CLEAN(3);
return self;
}
int igraph_biconnected_components(const igraph_t *graph,
igraph_integer_t *no,
igraph_vector_ptr_t *components,
igraph_vector_t *articulation_points) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_long_t nextptr;
igraph_vector_long_t num, low;
igraph_vector_bool_t found;
igraph_vector_t *adjedges;
igraph_stack_t path;
igraph_vector_t edgestack;
igraph_adjedgelist_t adjedgelist;
long int i, counter, rootdfs=0;
IGRAPH_CHECK(igraph_vector_long_init(&nextptr, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &nextptr);
IGRAPH_CHECK(igraph_vector_long_init(&num, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &num);
IGRAPH_CHECK(igraph_vector_long_init(&low, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &low);
IGRAPH_CHECK(igraph_vector_bool_init(&found, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &found);
IGRAPH_CHECK(igraph_stack_init(&path, 100));
IGRAPH_FINALLY(igraph_stack_destroy, &path);
IGRAPH_VECTOR_INIT_FINALLY(&edgestack, 0);
IGRAPH_CHECK(igraph_vector_reserve(&edgestack, 100));
IGRAPH_CHECK(igraph_adjedgelist_init(graph, &adjedgelist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjedgelist_destroy, &adjedgelist);
if (no) {
*no=0;
}
if (components) {
igraph_vector_ptr_clear(components);
}
if (articulation_points) {
igraph_vector_clear(articulation_points);
}
for (i=0; i<no_of_nodes; i++) {
if (VECTOR(low)[i] != 0) {
continue; /* already visited */
}
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_stack_push(&path, i));
counter=1;
rootdfs=0;
VECTOR(low)[i]=VECTOR(num)[i]=counter++;
while (!igraph_stack_empty(&path)) {
long int n;
long int act=igraph_stack_top(&path);
long int actnext=VECTOR(nextptr)[act];
adjedges=igraph_adjedgelist_get(&adjedgelist, act);
n=igraph_vector_size(adjedges);
if (actnext < n) {
/* Step down (maybe) */
long int edge=VECTOR(*adjedges)[actnext];
long int nei=IGRAPH_OTHER(graph, edge, act);
if (VECTOR(low)[nei] == 0) {
if (act==i) {
rootdfs++;
}
IGRAPH_CHECK(igraph_vector_push_back(&edgestack, edge));
IGRAPH_CHECK(igraph_stack_push(&path, nei));
VECTOR(low)[nei] = VECTOR(num)[nei]=counter++;
} else {
/* Update low value if needed */
if (VECTOR(num)[nei] < VECTOR(low)[act]) {
VECTOR(low)[act]=VECTOR(num)[nei];
}
}
VECTOR(nextptr)[act] += 1;
} else {
/* Step up */
igraph_stack_pop(&path);
if (!igraph_stack_empty(&path)) {
long int prev=igraph_stack_top(&path);
/* Update LOW value if needed */
if (VECTOR(low)[act] < VECTOR(low)[prev]) {
VECTOR(low)[prev] = VECTOR(low)[act];
}
/* Check for articulation point */
if (VECTOR(low)[act] >= VECTOR(num)[prev]) {
if (articulation_points && !VECTOR(found)[prev]
&& prev != i /* the root */) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, prev));
VECTOR(found)[prev] = 1;
}
if (no) {
*no += 1;
}
if (components) {
igraph_vector_t *v=igraph_Calloc(1, igraph_vector_t);
IGRAPH_CHECK(igraph_vector_init(v, 0));
while (!igraph_vector_empty(&edgestack)) {
long int e=igraph_vector_pop_back(&edgestack);
IGRAPH_CHECK(igraph_vector_push_back(v, e));
if (IGRAPH_FROM(graph,e)==prev || IGRAPH_TO(graph,e)==prev) {
break;
}
}
IGRAPH_CHECK(igraph_vector_ptr_push_back(components, v));
}
}
} /* !igraph_stack_empty(&path) */
}
} /* !igraph_stack_empty(&path) */
if (articulation_points && rootdfs >= 2) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, i));
}
} /* i < no_of_nodes */
igraph_adjedgelist_destroy(&adjedgelist);
igraph_vector_destroy(&edgestack);
igraph_stack_destroy(&path);
igraph_vector_bool_destroy(&found);
igraph_vector_long_destroy(&low);
igraph_vector_long_destroy(&num);
igraph_vector_long_destroy(&nextptr);
IGRAPH_FINALLY_CLEAN(7);
return 0;
}
int main() {
igraph_vector_ptr_t v1, v2;
igraph_vector_ptr_t v3=IGRAPH_VECTOR_PTR_NULL;
int i;
void ** ptr;
int d1=1, d2=2, d3=3, d4=4, d5=5;
char *block1=0, *block2=0;
/* igraph_vector_ptr_init, igraph_vector_ptr_destroy */
igraph_vector_ptr_init(&v1, 10);
igraph_vector_ptr_destroy(&v1);
igraph_vector_ptr_init(&v1, 0);
igraph_vector_ptr_destroy(&v1);
/* igraph_vector_ptr_free_all, igraph_vector_ptr_destroy_all */
igraph_vector_ptr_init(&v1, 5);
for (i=0; i<igraph_vector_ptr_size(&v1); i++) {
VECTOR(v1)[i]=(void*)malloc(i*10);
}
igraph_vector_ptr_free_all(&v1);
for (i=0; i<igraph_vector_ptr_size(&v1); i++) {
VECTOR(v1)[i]=(void*)malloc(i*10);
}
igraph_vector_ptr_destroy_all(&v1);
/* igraph_vector_ptr_reserve */
igraph_vector_ptr_init(&v1, 0);
igraph_vector_ptr_reserve(&v1, 5);
igraph_vector_ptr_reserve(&v1, 15);
igraph_vector_ptr_reserve(&v1, 1);
igraph_vector_ptr_reserve(&v1, 0);
igraph_vector_ptr_destroy(&v1);
/* igraph_vector_ptr_empty, igraph_vector_ptr_clear */
igraph_vector_ptr_init(&v1, 10);
if (igraph_vector_ptr_empty(&v1)) {
return 1;
}
igraph_vector_ptr_clear(&v1);
if (!igraph_vector_ptr_empty(&v1)) {
return 2;
}
/* igraph_vector_ptr_size */
if (igraph_vector_ptr_size(&v1) != 0) {
return 3;
}
igraph_vector_ptr_resize(&v1, 10);
if (igraph_vector_ptr_size(&v1) != 10) {
return 4;
}
igraph_vector_ptr_destroy(&v1);
/* igraph_vector_ptr_push_back */
igraph_vector_ptr_init(&v1, 0);
for (i=0; i<10; i++) {
igraph_vector_ptr_push_back(&v1, (void*)malloc(i*10));
}
igraph_vector_ptr_destroy_all(&v1);
/* igraph_vector_ptr_e */
igraph_vector_ptr_init(&v1, 5);
VECTOR(v1)[0]=&d1;
VECTOR(v1)[1]=&d2;
VECTOR(v1)[2]=&d3;
VECTOR(v1)[3]=&d4;
VECTOR(v1)[4]=&d5;
if (igraph_vector_ptr_e(&v1, 0) != &d1) {
return 5;
}
if (igraph_vector_ptr_e(&v1, 1) != &d2) {
return 6;
}
if (igraph_vector_ptr_e(&v1, 2) != &d3) {
return 7;
}
if (igraph_vector_ptr_e(&v1, 3) != &d4) {
return 8;
}
if (igraph_vector_ptr_e(&v1, 4) != &d5) {
return 9;
}
igraph_vector_ptr_destroy(&v1);
/* igraph_vector_ptr_set */
igraph_vector_ptr_init(&v1, 5);
igraph_vector_ptr_set(&v1, 0, &d1);
igraph_vector_ptr_set(&v1, 1, &d2);
igraph_vector_ptr_set(&v1, 2, &d3);
igraph_vector_ptr_set(&v1, 3, &d4);
igraph_vector_ptr_set(&v1, 4, &d5);
if (igraph_vector_ptr_e(&v1, 0) != &d1) {
return 5;
}
if (igraph_vector_ptr_e(&v1, 1) != &d2) {
return 6;
}
if (igraph_vector_ptr_e(&v1, 2) != &d3) {
return 7;
}
if (igraph_vector_ptr_e(&v1, 3) != &d4) {
return 8;
}
if (igraph_vector_ptr_e(&v1, 4) != &d5) {
return 9;
}
igraph_vector_ptr_destroy(&v1);
/* igraph_vector_ptr_null */
igraph_vector_ptr_init(&v1, 5);
igraph_vector_ptr_set(&v1, 0, &d1);
igraph_vector_ptr_set(&v1, 1, &d2);
igraph_vector_ptr_set(&v1, 2, &d3);
igraph_vector_ptr_set(&v1, 3, &d4);
igraph_vector_ptr_set(&v1, 4, &d5);
igraph_vector_ptr_null(&v1);
for (i=0; i<igraph_vector_ptr_size(&v1); i++) {
if (VECTOR(v1)[i] != 0) {
return 10;
}
}
igraph_vector_ptr_destroy(&v1);
/* igraph_vector_ptr_resize */
igraph_vector_ptr_init(&v1, 10);
igraph_vector_ptr_set(&v1, 0, &d1);
igraph_vector_ptr_set(&v1, 1, &d2);
igraph_vector_ptr_set(&v1, 2, &d3);
igraph_vector_ptr_set(&v1, 3, &d4);
igraph_vector_ptr_set(&v1, 4, &d5);
igraph_vector_ptr_resize(&v1, 10);
igraph_vector_ptr_resize(&v1, 15);
igraph_vector_ptr_resize(&v1, 5);
if (igraph_vector_ptr_size(&v1) != 5) {
return 11;
}
if (igraph_vector_ptr_e(&v1, 0) != &d1) {
return 12;
}
if (igraph_vector_ptr_e(&v1, 1) != &d2) {
return 13;
}
if (igraph_vector_ptr_e(&v1, 2) != &d3) {
return 14;
}
if (igraph_vector_ptr_e(&v1, 3) != &d4) {
return 15;
}
if (igraph_vector_ptr_e(&v1, 4) != &d5) {
return 16;
}
igraph_vector_ptr_destroy(&v1);
/* igraph_vector_ptr_view */
ptr=(void**) malloc(5 * sizeof(void*));
igraph_vector_ptr_view(&v3, ptr, 5);
ptr[0]=&d1; ptr[1]=&d2; ptr[2]=&d3; ptr[3]=&d4; ptr[4]=&d5;
for (i=0; i<igraph_vector_ptr_size(&v3); i++) {
if ( *((int*)VECTOR(v3)[i]) != i+1) {
return 17;
}
}
/* igraph_vector_ptr_init_copy */
igraph_vector_ptr_init_copy(&v1, ptr, 5);
for (i=0; i<igraph_vector_ptr_size(&v1); i++) {
if ( *((int*)VECTOR(v1)[i]) != i+1) {
return 18;
}
}
/* igraph_vector_ptr_copy_to */
igraph_vector_ptr_copy_to(&v1, ptr);
for (i=0; i<igraph_vector_ptr_size(&v1); i++) {
if ( *((int*)ptr[i]) != i+1) {
return 19;
}
}
free(ptr);
igraph_vector_ptr_destroy(&v1);
/* igraph_vector_ptr_copy */
igraph_vector_ptr_init(&v1, 5);
igraph_vector_ptr_set(&v1, 0, &d1);
igraph_vector_ptr_set(&v1, 1, &d2);
igraph_vector_ptr_set(&v1, 2, &d3);
igraph_vector_ptr_set(&v1, 3, &d4);
igraph_vector_ptr_set(&v1, 4, &d5);
igraph_vector_ptr_copy(&v2, &v1);
igraph_vector_ptr_destroy(&v1);
for (i=0; i<igraph_vector_ptr_size(&v2); i++) {
if ( *((int*)VECTOR(v2)[i]) != i+1) {
return 20;
}
}
/* igraph_vector_ptr_remove */
igraph_vector_ptr_remove(&v2, 0);
igraph_vector_ptr_remove(&v2, 3);
if ( *((int*)VECTOR(v2)[0]) != 2) {
return 21;
}
if ( *((int*)VECTOR(v2)[1]) != 3) {
return 22;
}
if ( *((int*)VECTOR(v2)[2]) != 4) {
return 23;
}
igraph_vector_ptr_destroy(&v2);
/* Testing destructor */
igraph_vector_ptr_init(&custom_destructor_stack, 0);
igraph_vector_ptr_init(&v1, 2);
block1 = igraph_Calloc(32, char);
block2 = igraph_Calloc(64, char);
VECTOR(v1)[0] = block1; VECTOR(v1)[1] = block2;
if (igraph_vector_ptr_get_item_destructor(&v1) != 0) {
return 24;
}
if (igraph_vector_ptr_set_item_destructor(&v1, &custom_destructor) != 0) {
return 25;
}
/* Okay, let's clear the vector. This should push the blocks in the
* custom destructor stack */
igraph_vector_ptr_clear(&v1);
/* Put the blocks back and destroy the vector */
igraph_vector_ptr_push_back(&v1, block1);
igraph_vector_ptr_push_back(&v1, block2);
igraph_vector_ptr_destroy_all(&v1);
if (VECTOR(custom_destructor_stack)[0] != block1 ||
VECTOR(custom_destructor_stack)[1] != block2 ||
VECTOR(custom_destructor_stack)[2] != block1 ||
VECTOR(custom_destructor_stack)[3] != block2
)
return 26;
igraph_vector_ptr_destroy(&custom_destructor_stack);
if (IGRAPH_FINALLY_STACK_SIZE() != 0) return 27;
return 0;
}
