int igraph_running_mean(const igraph_vector_t *data, igraph_vector_t *res,
igraph_integer_t binwidth) {
double sum=0;
long int i;
/* Check */
if (igraph_vector_size(data) < binwidth) {
IGRAPH_ERROR("Vector too short for this binwidth", IGRAPH_EINVAL);
}
/* Memory for result */
IGRAPH_CHECK(igraph_vector_resize(res, (long int)(igraph_vector_size(data)-binwidth+1)));
/* Initial bin */
for (i=0; i<binwidth; i++) {
sum += VECTOR(*data)[i];
}
VECTOR(*res)[0]=sum/binwidth;
for (i=1; i<igraph_vector_size(data)-binwidth+1; i++) {
IGRAPH_ALLOW_INTERRUPTION();
sum -= VECTOR(*data)[i-1];
sum += VECTOR(*data)[ (long int)(i+binwidth-1)];
VECTOR(*res)[i] = sum/binwidth;
}
return 0;
}
int igraph_i_local_scan_1_directed(const igraph_t *graph,
igraph_vector_t *res,
const igraph_vector_t *weights,
igraph_neimode_t mode) {
int no_of_nodes=igraph_vcount(graph);
igraph_inclist_t incs;
int i, node;
igraph_vector_int_t neis;
IGRAPH_CHECK(igraph_inclist_init(graph, &incs, mode));
IGRAPH_FINALLY(igraph_inclist_destroy, &incs);
igraph_vector_int_init(&neis, no_of_nodes);
IGRAPH_FINALLY(igraph_vector_int_destroy, &neis);
igraph_vector_resize(res, no_of_nodes);
igraph_vector_null(res);
for (node=0; node < no_of_nodes; node++) {
igraph_vector_int_t *edges1=igraph_inclist_get(&incs, node);
int edgeslen1=igraph_vector_int_size(edges1);
IGRAPH_ALLOW_INTERRUPTION();
/* Mark neighbors and self*/
VECTOR(neis)[node] = node+1;
for (i=0; i<edgeslen1; i++) {
int e=VECTOR(*edges1)[i];
int nei=IGRAPH_OTHER(graph, e, node);
igraph_real_t w= weights ? VECTOR(*weights)[e] : 1;
VECTOR(neis)[nei] = node+1;
VECTOR(*res)[node] += w;
}
/* Crawl neighbors */
for (i=0; i<edgeslen1; i++) {
int e2=VECTOR(*edges1)[i];
int nei=IGRAPH_OTHER(graph, e2, node);
igraph_vector_int_t *edges2=igraph_inclist_get(&incs, nei);
int j, edgeslen2=igraph_vector_int_size(edges2);
for (j=0; j<edgeslen2; j++) {
int e2=VECTOR(*edges2)[j];
int nei2=IGRAPH_OTHER(graph, e2, nei);
igraph_real_t w2= weights ? VECTOR(*weights)[e2] : 1;
if (VECTOR(neis)[nei2] == node+1) {
VECTOR(*res)[node] += w2;
}
}
}
} /* node < no_of_nodes */
igraph_vector_int_destroy(&neis);
igraph_inclist_destroy(&incs);
IGRAPH_FINALLY_CLEAN(2);
return 0;
}
int igraph_adjlist_init(const igraph_t *graph, igraph_adjlist_t *al,
igraph_neimode_t mode) {
long int i;
if (mode != IGRAPH_IN && mode != IGRAPH_OUT && mode != IGRAPH_ALL) {
IGRAPH_ERROR("Cannot create 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 adjlist view", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_adjlist_destroy, al);
for (i=0; i<al->length; i++) {
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_vector_init(&al->adjs[i], 0));
IGRAPH_CHECK(igraph_neighbors(graph, &al->adjs[i], i, mode));
}
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
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;
}
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_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_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_revolver_error_d_d(const igraph_t *graph,
igraph_lazy_inclist_t *inclist,
const igraph_matrix_t *kernel,
const igraph_vector_t *st,
const igraph_vector_t *vtime,
const igraph_vector_t *vtimeidx,
const igraph_vector_t *etime,
const igraph_vector_t *etimeidx,
igraph_integer_t pno_of_events,
igraph_integer_t pmaxdegree,
igraph_real_t *logprob,
igraph_real_t *lognull) {
long int no_of_events=pno_of_events;
long int no_of_nodes=igraph_vcount(graph);
long int no_of_edges=igraph_ecount(graph);
igraph_vector_long_t degree;
long int timestep, nptr=0, eptr=0, eptr_save;
long int edges=0, vertices=0;
igraph_real_t rlogprob, rlognull, *mylogprob=logprob, *mylognull=lognull;
IGRAPH_CHECK(igraph_vector_long_init(°ree, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, °ree);
if (!logprob) {
mylogprob=&rlogprob;
}
if (!lognull) {
mylognull=&rlognull;
}
*mylogprob=0;
*mylognull=0;
for (timestep=0; timestep<no_of_events; timestep++) {
IGRAPH_ALLOW_INTERRUPTION();
while (nptr < no_of_nodes &&
VECTOR(*vtime)[ (long int) VECTOR(*vtimeidx)[nptr] ] == timestep) {
vertices++;
nptr++;
}
eptr_save=eptr;
while (eptr < no_of_edges &&
VECTOR(*etime)[ (long int) VECTOR(*etimeidx)[eptr] ] == timestep) {
long int edge=(long int) VECTOR(*etimeidx)[eptr];
long int from=IGRAPH_FROM(graph, edge);
long int to=IGRAPH_TO(graph, edge);
long int xidx=VECTOR(degree)[from];
long int yidx=VECTOR(degree)[to];
igraph_real_t prob=MATRIX(*kernel, xidx, yidx)/VECTOR(*st)[timestep];
igraph_real_t nullprob=1.0/(vertices*(vertices-1)/2-eptr_save);
*mylogprob += log(prob);
*mylognull += log(nullprob);
edges++;
eptr++;
}
eptr=eptr_save;
while (eptr < no_of_edges &&
VECTOR(*etime)[ (long int) VECTOR(*etimeidx)[eptr] ] == timestep) {
long int edge=(long int) VECTOR(*etimeidx)[eptr];
long int from=IGRAPH_FROM(graph, edge);
long int to=IGRAPH_TO(graph, edge);
VECTOR(degree)[from] += 1;
VECTOR(degree)[to] += 1;
eptr++;
}
}
igraph_vector_long_destroy(°ree);
IGRAPH_FINALLY_CLEAN(1);
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_i_community_spinglass_orig(const igraph_t *graph,
const igraph_vector_t *weights,
igraph_real_t *modularity,
igraph_real_t *temperature,
igraph_vector_t *membership,
igraph_vector_t *csize,
igraph_integer_t spins,
igraph_bool_t parupdate,
igraph_real_t starttemp,
igraph_real_t stoptemp,
igraph_real_t coolfact,
igraph_spincomm_update_t update_rule,
igraph_real_t gamma) {
unsigned long changes, runs;
igraph_bool_t use_weights=0;
bool zeroT;
double kT, acc, prob;
ClusterList<NNode*> *cl_cur;
network *net;
PottsModel *pm;
/* Check arguments */
if (spins < 2 || spins > 500) {
IGRAPH_ERROR("Invalid number of spins", IGRAPH_EINVAL);
}
if (update_rule != IGRAPH_SPINCOMM_UPDATE_SIMPLE &&
update_rule != IGRAPH_SPINCOMM_UPDATE_CONFIG) {
IGRAPH_ERROR("Invalid update rule", IGRAPH_EINVAL);
}
if (weights) {
if (igraph_vector_size(weights) != igraph_ecount(graph)) {
IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
}
use_weights=1;
}
if (coolfact < 0 || coolfact>=1.0) {
IGRAPH_ERROR("Invalid cooling factor", IGRAPH_EINVAL);
}
if (gamma < 0.0) {
IGRAPH_ERROR("Invalid gamme value", IGRAPH_EINVAL);
}
if (starttemp/stoptemp<1.0) {
IGRAPH_ERROR("starttemp should be larger in absolute value than stoptemp",
IGRAPH_EINVAL);
}
/* Check whether we have a single component */
igraph_bool_t conn;
IGRAPH_CHECK(igraph_is_connected(graph, &conn, IGRAPH_WEAK));
if (!conn) {
IGRAPH_ERROR("Cannot work with unconnected graph", IGRAPH_EINVAL);
}
net = new network;
net->node_list =new DL_Indexed_List<NNode*>();
net->link_list =new DL_Indexed_List<NLink*>();
net->cluster_list=new DL_Indexed_List<ClusterList<NNode*>*>();
/* Transform the igraph_t */
IGRAPH_CHECK(igraph_i_read_network(graph, weights,
net, use_weights, 0));
prob=2.0*net->sum_weights/double(net->node_list->Size())
/double(net->node_list->Size()-1);
pm=new PottsModel(net,(unsigned int)spins,update_rule);
/* initialize the random number generator */
RNG_BEGIN();
if ((stoptemp==0.0) && (starttemp==0.0)) zeroT=true; else zeroT=false;
if (!zeroT) kT=pm->FindStartTemp(gamma, prob, starttemp); else kT=stoptemp;
/* assign random initial configuration */
pm->assign_initial_conf(-1);
runs=0;
changes=1;
while (changes>0 && (kT/stoptemp>1.0 || (zeroT && runs<150))) {
IGRAPH_ALLOW_INTERRUPTION(); /* This is not clean.... */
runs++;
if (!zeroT) {
kT*=coolfact;
if (parupdate) {
changes=pm->HeatBathParallelLookup(gamma, prob, kT, 50);
} else {
acc=pm->HeatBathLookup(gamma, prob, kT, 50);
if (acc<(1.0-1.0/double(spins))*0.01) {
changes=0;
} else {
changes=1;
}
}
} else {
if (parupdate) {
changes=pm->HeatBathParallelLookupZeroTemp(gamma, prob, 50);
} else {
acc=pm->HeatBathLookupZeroTemp(gamma, prob, 50);
/* less than 1 percent acceptance ratio */
if (acc<(1.0-1.0/double(spins))*0.01) {
changes=0;
} else {
changes=1;
}
}
}
} /* while loop */
pm->WriteClusters(modularity, temperature, csize, membership, kT, gamma);
while (net->link_list->Size()) delete net->link_list->Pop();
while (net->node_list->Size()) delete net->node_list->Pop();
while (net->cluster_list->Size())
{
cl_cur=net->cluster_list->Pop();
while (cl_cur->Size()) cl_cur->Pop();
delete cl_cur;
}
delete net->link_list;
delete net->node_list;
delete net->cluster_list;
RNG_END();
delete net;
delete pm;
return 0;
}
int igraph_i_community_spinglass_negative(const igraph_t *graph,
const igraph_vector_t *weights,
igraph_real_t *modularity,
igraph_real_t *temperature,
igraph_vector_t *membership,
igraph_vector_t *csize,
igraph_integer_t spins,
igraph_bool_t parupdate,
igraph_real_t starttemp,
igraph_real_t stoptemp,
igraph_real_t coolfact,
igraph_spincomm_update_t update_rule,
igraph_real_t gamma,
/* igraph_matrix_t *adhesion, */
/* igraph_matrix_t *normalised_adhesion, */
/* igraph_real_t *polarization, */
igraph_real_t gamma_minus) {
unsigned long changes, runs;
igraph_bool_t use_weights=0;
bool zeroT;
double kT, acc;
ClusterList<NNode*> *cl_cur;
network *net;
PottsModelN *pm;
igraph_real_t d_n;
igraph_real_t d_p;
/* Check arguments */
if (parupdate) {
IGRAPH_ERROR("Parallel spin update not implemented with "
"negative gamma", IGRAPH_UNIMPLEMENTED);
}
if (spins < 2 || spins > 500) {
IGRAPH_ERROR("Invalid number of spins", IGRAPH_EINVAL);
}
if (update_rule != IGRAPH_SPINCOMM_UPDATE_SIMPLE &&
update_rule != IGRAPH_SPINCOMM_UPDATE_CONFIG) {
IGRAPH_ERROR("Invalid update rule", IGRAPH_EINVAL);
}
if (weights) {
if (igraph_vector_size(weights) != igraph_ecount(graph)) {
IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
}
use_weights=1;
}
if (coolfact < 0 || coolfact>=1.0) {
IGRAPH_ERROR("Invalid cooling factor", IGRAPH_EINVAL);
}
if (gamma < 0.0) {
IGRAPH_ERROR("Invalid gamma value", IGRAPH_EINVAL);
}
if (starttemp/stoptemp<1.0) {
IGRAPH_ERROR("starttemp should be larger in absolute value than stoptemp",
IGRAPH_EINVAL);
}
/* Check whether we have a single component */
igraph_bool_t conn;
IGRAPH_CHECK(igraph_is_connected(graph, &conn, IGRAPH_WEAK));
if (!conn) {
IGRAPH_ERROR("Cannot work with unconnected graph", IGRAPH_EINVAL);
}
igraph_vector_minmax(weights, &d_n, &d_p);
if (d_n > 0) { d_n=0; }
if (d_p < 0) { d_p=0; }
d_n = -d_n;
net = new network;
net->node_list =new DL_Indexed_List<NNode*>();
net->link_list =new DL_Indexed_List<NLink*>();
net->cluster_list=new DL_Indexed_List<ClusterList<NNode*>*>();
/* Transform the igraph_t */
IGRAPH_CHECK(igraph_i_read_network(graph, weights,
net, use_weights, 0));
bool directed = igraph_is_directed(graph);
pm=new PottsModelN(net,(unsigned int)spins, directed);
/* initialize the random number generator */
RNG_BEGIN();
if ((stoptemp==0.0) && (starttemp==0.0)) zeroT=true; else zeroT=false;
//Begin at a high enough temperature
kT=pm->FindStartTemp(gamma, gamma_minus, starttemp);
/* assign random initial configuration */
pm->assign_initial_conf(true);
runs=0;
changes=1;
acc = 0;
while (changes>0 && (kT/stoptemp>1.0 || (zeroT && runs<150)))
{
IGRAPH_ALLOW_INTERRUPTION(); /* This is not clean.... */
runs++;
kT = kT*coolfact;
acc=pm->HeatBathLookup(gamma, gamma_minus, kT, 50);
if (acc<(1.0-1.0/double(spins))*0.001)
changes=0;
else
changes=1;
} /* while loop */
/* These are needed, otherwise 'modularity' is not calculated */
igraph_matrix_t adhesion, normalized_adhesion;
igraph_real_t polarization;
IGRAPH_MATRIX_INIT_FINALLY(&adhesion, 0, 0);
IGRAPH_MATRIX_INIT_FINALLY(&normalized_adhesion, 0, 0);
pm->WriteClusters(modularity, temperature, csize, membership,
&adhesion, &normalized_adhesion, &polarization,
kT, d_p, d_n, gamma, gamma_minus);
igraph_matrix_destroy(&normalized_adhesion);
igraph_matrix_destroy(&adhesion);
IGRAPH_FINALLY_CLEAN(2);
while (net->link_list->Size()) delete net->link_list->Pop();
while (net->node_list->Size()) delete net->node_list->Pop();
while (net->cluster_list->Size())
{
cl_cur=net->cluster_list->Pop();
while (cl_cur->Size()) cl_cur->Pop();
delete cl_cur;
}
RNG_END();
return 0;
}
int igraph_revolver_st_d_d(const igraph_t *graph,
igraph_lazy_inclist_t *inclist,
igraph_vector_t *st,
const igraph_matrix_t *kernel,
const igraph_vector_t *vtime,
const igraph_vector_t *vtimeidx,
const igraph_vector_t *etime,
const igraph_vector_t *etimeidx,
igraph_integer_t pno_of_events) {
long int no_of_events=pno_of_events;
long int maxdegree=igraph_matrix_nrow(kernel)-1;
long int no_of_nodes=igraph_vcount(graph);
long int no_of_edges=igraph_ecount(graph);
long int timestep=0;
igraph_vector_long_t degree;
igraph_vector_long_t ntk;
igraph_vector_char_t added;
igraph_vector_t *adjedges;
long int i;
long int nptr=0, eptr=0;
IGRAPH_CHECK(igraph_vector_long_init(&ntk, maxdegree+1));
IGRAPH_FINALLY(igraph_vector_long_destroy, &ntk);
IGRAPH_CHECK(igraph_vector_long_init(°ree, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, °ree);
IGRAPH_CHECK(igraph_vector_char_init(&added, no_of_edges));
IGRAPH_FINALLY(igraph_vector_char_destroy, &added);
IGRAPH_CHECK(igraph_vector_resize(st, no_of_events));
VECTOR(*st)[0]=0;
for (timestep=0; timestep<no_of_events-1; timestep++) {
IGRAPH_ALLOW_INTERRUPTION();
/* add the new nodes */
while (nptr < no_of_nodes &&
VECTOR(*vtime)[ (long int) VECTOR(*vtimeidx)[nptr] ] == timestep) {
for (i=0; i<maxdegree+1; i++) {
VECTOR(*st)[timestep] += VECTOR(ntk)[i]*MATRIX(*kernel, i, 0);
}
VECTOR(ntk)[0]++;
nptr++;
}
/* add the new edges as well, but this is for the next timestep
already */
VECTOR(*st)[timestep+1] = VECTOR(*st)[timestep];
while (eptr < no_of_edges &&
VECTOR(*etime)[ (long int) VECTOR(*etimeidx)[eptr] ] == timestep) {
long int edge=(long int) VECTOR(*etimeidx)[eptr];
long int from=IGRAPH_FROM(graph, edge);
long int to=IGRAPH_TO(graph, edge);
long int xidx=VECTOR(degree)[from];
long int yidx=VECTOR(degree)[to];
igraph_real_t inc=0;
long int n;
inc -= MATRIX(*kernel, xidx, yidx);
for (i=0; i<maxdegree+1; i++) {
inc += VECTOR(ntk)[i] * (MATRIX(*kernel, i, xidx+1) -
MATRIX(*kernel, i, xidx) +
MATRIX(*kernel, i, yidx+1) -
MATRIX(*kernel, i, yidx));
}
inc -= MATRIX(*kernel, xidx+1, xidx+1);
inc -= MATRIX(*kernel, yidx+1, yidx+1);
inc += MATRIX(*kernel, xidx, xidx);
inc += MATRIX(*kernel, yidx, yidx);
VECTOR(ntk)[xidx]--;
VECTOR(ntk)[yidx]--;
VECTOR(ntk)[xidx+1]++;
VECTOR(ntk)[yidx+1]++;
adjedges=igraph_lazy_inclist_get(inclist, (igraph_integer_t) from);
n=igraph_vector_size(adjedges);
for (i=0; i<n; i++) {
long int edge=(long int) VECTOR(*adjedges)[i];
if (VECTOR(added)[edge]) {
long int otherv=IGRAPH_OTHER(graph, edge, from);
long int deg=VECTOR(degree)[otherv];
inc += MATRIX(*kernel, xidx, deg);
inc -= MATRIX(*kernel, xidx+1, deg);
}
}
adjedges=igraph_lazy_inclist_get(inclist, (igraph_integer_t) to);
n=igraph_vector_size(adjedges);
for (i=0; i<n; i++) {
long int edge=(long int) VECTOR(*adjedges)[i];
if (VECTOR(added)[edge]) {
long int otherv=IGRAPH_OTHER(graph, edge, to);
long int deg=VECTOR(degree)[otherv];
inc += MATRIX(*kernel, yidx, deg);
inc -= MATRIX(*kernel, yidx+1, deg);
}
}
VECTOR(degree)[from] += 1;
VECTOR(degree)[to] += 1;
VECTOR(added)[edge]=1;
VECTOR(*st)[timestep+1] += inc;
eptr++;
}
}
igraph_vector_char_destroy(&added);
igraph_vector_long_destroy(°ree);
igraph_vector_long_destroy(&ntk);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
int igraph_zeroin( /* An estimate of the root */
igraph_real_t *ax, /* Left border | of the range */
igraph_real_t *bx, /* Right border| the root is seeked*/
igraph_real_t (*f)(igraph_real_t x, void *info), /* Function under investigation */
void *info, /* Add'l info passed on to f */
igraph_real_t *Tol, /* Acceptable tolerance */
int *Maxit, /* Max # of iterations */
igraph_real_t *res) /* Result is stored here */
{
igraph_real_t a,b,c, /* Abscissae, descr. see above */
fa, fb, fc; /* f(a), f(b), f(c) */
igraph_real_t tol;
int maxit;
a = *ax; b = *bx; fa = (*f)(a, info); fb = (*f)(b, info);
c = a; fc = fa;
maxit = *Maxit + 1; tol = * Tol;
/* First test if we have found a root at an endpoint */
if(fa == 0.0) {
*Tol = 0.0;
*Maxit = 0;
*res=a;
return 0;
}
if(fb == 0.0) {
*Tol = 0.0;
*Maxit = 0;
*res=b;
return 0;
}
while(maxit--) /* Main iteration loop */
{
igraph_real_t prev_step = b-a; /* Distance from the last but one
to the last approximation */
igraph_real_t tol_act; /* Actual tolerance */
igraph_real_t p; /* Interpolation step is calcu- */
igraph_real_t q; /* lated in the form p/q; divi-
* sion operations is delayed
* until the last moment */
igraph_real_t new_step; /* Step at this iteration */
IGRAPH_ALLOW_INTERRUPTION();
if( fabs(fc) < fabs(fb) )
{ /* Swap data for b to be the */
a = b; b = c; c = a; /* best approximation */
fa=fb; fb=fc; fc=fa;
}
tol_act = 2*EPSILON*fabs(b) + tol/2;
new_step = (c-b)/2;
if( fabs(new_step) <= tol_act || fb == (igraph_real_t)0 )
{
*Maxit -= maxit;
*Tol = fabs(c-b);
*res=b;
return 0; /* Acceptable approx. is found */
}
/* Decide if the interpolation can be tried */
if( fabs(prev_step) >= tol_act /* If prev_step was large enough*/
&& fabs(fa) > fabs(fb) ) { /* and was in true direction,
* Interpolation may be tried */
register igraph_real_t t1,cb,t2;
cb = c-b;
if( a==c ) { /* If we have only two distinct */
/* points linear interpolation */
t1 = fb/fa; /* can only be applied */
p = cb*t1;
q = 1.0 - t1;
}
else { /* Quadric inverse interpolation*/
q = fa/fc; t1 = fb/fc; t2 = fb/fa;
p = t2 * ( cb*q*(q-t1) - (b-a)*(t1-1.0) );
q = (q-1.0) * (t1-1.0) * (t2-1.0);
}
if( p>(igraph_real_t)0 ) /* p was calculated with the */
q = -q; /* opposite sign; make p positive */
else /* and assign possible minus to */
p = -p; /* q */
if( p < (0.75*cb*q-fabs(tol_act*q)/2) /* If b+p/q falls in [b,c]*/
&& p < fabs(prev_step*q/2) ) /* and isn't too large */
new_step = p/q; /* it is accepted
* If p/q is too large then the
* bisection procedure can
* reduce [b,c] range to more
* extent */
}
if( fabs(new_step) < tol_act) { /* Adjust the step to be not less*/
if( new_step > (igraph_real_t)0 ) /* than tolerance */
new_step = tol_act;
else
new_step = -tol_act;
}
a = b; fa = fb; /* Save the previous approx. */
b += new_step; fb = (*f)(b, info); /* Do step to a new approxim. */
if( (fb > 0 && fc > 0) || (fb < 0 && fc < 0) ) {
/* Adjust c for it to have a sign opposite to that of b */
c = a; fc = fa;
}
}
/* failed! */
*Tol = fabs(c-b);
*Maxit = -1;
*res=b;
return IGRAPH_DIVERGED;
}
int igraph_i_local_scan_1_sumweights(const igraph_t *graph,
igraph_vector_t *res,
const igraph_vector_t *weights) {
long int no_of_nodes=igraph_vcount(graph);
long int node, i, j, nn;
igraph_inclist_t allinc;
igraph_vector_int_t *neis1, *neis2;
long int neilen1, neilen2;
long int *neis;
long int maxdegree;
igraph_vector_int_t order;
igraph_vector_int_t rank;
igraph_vector_t degree, *edge1=°ree; /* reuse degree as edge1 */
if (igraph_vector_size(weights) != igraph_ecount(graph)) {
IGRAPH_ERROR("Invalid weight vector length", IGRAPH_EINVAL);
}
igraph_vector_int_init(&order, no_of_nodes);
IGRAPH_FINALLY(igraph_vector_int_destroy, &order);
IGRAPH_VECTOR_INIT_FINALLY(°ree, no_of_nodes);
IGRAPH_CHECK(igraph_degree(graph, °ree, igraph_vss_all(), IGRAPH_ALL,
IGRAPH_LOOPS));
maxdegree=(long int) igraph_vector_max(°ree)+1;
igraph_vector_order1_int(°ree, &order, maxdegree);
igraph_vector_int_init(&rank, no_of_nodes);
IGRAPH_FINALLY(igraph_vector_int_destroy, &rank);
for (i=0; i<no_of_nodes; i++) {
VECTOR(rank)[ VECTOR(order)[i] ] = no_of_nodes-i-1;
}
IGRAPH_CHECK(igraph_inclist_init(graph, &allinc, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_inclist_destroy, &allinc);
IGRAPH_CHECK(igraph_i_trans4_il_simplify(graph, &allinc, &rank));
neis=igraph_Calloc(no_of_nodes, long int);
if (neis==0) {
IGRAPH_ERROR("undirected local transitivity failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, neis);
IGRAPH_CHECK(igraph_strength(graph, res, igraph_vss_all(), IGRAPH_ALL,
IGRAPH_LOOPS, weights));
for (nn=no_of_nodes-1; nn>=0; nn--) {
node=VECTOR(order)[nn];
IGRAPH_ALLOW_INTERRUPTION();
neis1=igraph_inclist_get(&allinc, node);
neilen1=igraph_vector_int_size(neis1);
/* Mark the neighbors of the node */
for (i=0; i<neilen1; i++) {
int edge = VECTOR(*neis1)[i];
int nei = IGRAPH_OTHER(graph, edge, node);
VECTOR(*edge1)[nei] = VECTOR(*weights)[edge];
neis[nei] = node+1;
}
for (i=0; i<neilen1; i++) {
long int edge=VECTOR(*neis1)[i];
long int nei=IGRAPH_OTHER(graph, edge, node);
igraph_real_t w=VECTOR(*weights)[edge];
neis2=igraph_inclist_get(&allinc, nei);
neilen2=igraph_vector_int_size(neis2);
for (j=0; j<neilen2; j++) {
long int edge2=VECTOR(*neis2)[j];
long int nei2=IGRAPH_OTHER(graph, edge2, nei);
igraph_real_t w2=VECTOR(*weights)[edge2];
if (neis[nei2] == node+1) {
VECTOR(*res)[node] += w2;
VECTOR(*res)[nei2] += w;
VECTOR(*res)[nei] += VECTOR(*edge1)[nei2];
}
}
}
}
igraph_free(neis);
igraph_inclist_destroy(&allinc);
igraph_vector_int_destroy(&rank);
igraph_vector_destroy(°ree);
igraph_vector_int_destroy(&order);
IGRAPH_FINALLY_CLEAN(5);
return 0;
}
int igraph_i_maximal_cliques(const igraph_t *graph, igraph_i_maximal_clique_func_t func, void* data) {
int directed=igraph_is_directed(graph);
long int i, j, k, l;
igraph_integer_t no_of_nodes, nodes_to_check, nodes_done;
igraph_integer_t best_cand = 0, best_cand_degree = 0, best_fini_cand_degree;
igraph_adjlist_t adj_list;
igraph_stack_ptr_t stack;
igraph_i_maximal_cliques_stack_frame frame, *new_frame_ptr;
igraph_vector_t clique, new_cand, new_fini, cn, best_cand_nbrs, best_fini_cand_nbrs;
igraph_bool_t cont = 1;
int assret;
if (directed)
IGRAPH_WARNING("directionality of edges is ignored for directed graphs");
no_of_nodes = igraph_vcount(graph);
if (no_of_nodes == 0)
return IGRAPH_SUCCESS;
/* Construct an adjacency list representation */
IGRAPH_CHECK(igraph_adjlist_init(graph, &adj_list, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adj_list);
IGRAPH_CHECK(igraph_adjlist_simplify(&adj_list));
igraph_adjlist_sort(&adj_list);
/* Initialize stack */
IGRAPH_CHECK(igraph_stack_ptr_init(&stack, 0));
IGRAPH_FINALLY(igraph_i_maximal_cliques_stack_destroy, &stack);
/* Create the initial (empty) clique */
IGRAPH_VECTOR_INIT_FINALLY(&clique, 0);
/* Initialize new_cand, new_fini, cn, best_cand_nbrs and best_fini_cand_nbrs (will be used later) */
IGRAPH_VECTOR_INIT_FINALLY(&new_cand, 0);
IGRAPH_VECTOR_INIT_FINALLY(&new_fini, 0);
IGRAPH_VECTOR_INIT_FINALLY(&cn, 0);
IGRAPH_VECTOR_INIT_FINALLY(&best_cand_nbrs, 0);
IGRAPH_VECTOR_INIT_FINALLY(&best_fini_cand_nbrs, 0);
/* Find the vertex with the highest degree */
best_cand = 0; best_cand_degree = igraph_vector_size(igraph_adjlist_get(&adj_list, 0));
for (i = 1; i < no_of_nodes; i++) {
j = igraph_vector_size(igraph_adjlist_get(&adj_list, i));
if (j > best_cand_degree) {
best_cand = i;
best_cand_degree = j;
}
}
/* Create the initial stack frame */
IGRAPH_CHECK(igraph_vector_init_seq(&frame.cand, 0, no_of_nodes-1));
IGRAPH_FINALLY(igraph_vector_destroy, &frame.cand);
IGRAPH_CHECK(igraph_vector_init(&frame.fini, 0));
IGRAPH_FINALLY(igraph_vector_destroy, &frame.fini);
IGRAPH_CHECK(igraph_vector_init(&frame.cand_filtered, 0));
IGRAPH_FINALLY(igraph_vector_destroy, &frame.cand_filtered);
IGRAPH_CHECK(igraph_vector_difference_sorted(&frame.cand,
igraph_adjlist_get(&adj_list, best_cand), &frame.cand_filtered));
IGRAPH_FINALLY_CLEAN(3);
IGRAPH_FINALLY(igraph_i_maximal_cliques_stack_frame_destroy, &frame);
/* TODO: frame.cand and frame.fini should be a set instead of a vector */
/* Main loop starts here */
nodes_to_check = igraph_vector_size(&frame.cand_filtered); nodes_done = 0;
while (!igraph_vector_empty(&frame.cand_filtered) || !igraph_stack_ptr_empty(&stack)) {
if (igraph_vector_empty(&frame.cand_filtered)) {
/* No candidates left to check in this stack frame, pop out the previous stack frame */
igraph_i_maximal_cliques_stack_frame *newframe = igraph_stack_ptr_pop(&stack);
igraph_i_maximal_cliques_stack_frame_destroy(&frame);
frame = *newframe;
free(newframe);
if (igraph_stack_ptr_size(&stack) == 1) {
/* We will be using the next candidate node in the next iteration, so we can increase
* nodes_done by 1 */
nodes_done++;
}
/* For efficiency reasons, we only check for interruption and show progress here */
IGRAPH_PROGRESS("Maximal cliques: ", 100.0 * nodes_done / nodes_to_check, NULL);
IGRAPH_ALLOW_INTERRUPTION();
igraph_vector_pop_back(&clique);
continue;
}
/* Try the next node in the clique */
i = igraph_vector_pop_back(&frame.cand_filtered);
IGRAPH_CHECK(igraph_vector_push_back(&clique, i));
/* Remove the node from the candidate list */
assret=igraph_vector_binsearch(&frame.cand, i, &j); assert(assret);
igraph_vector_remove(&frame.cand, j);
/* Add the node to the finished list */
assret = !igraph_vector_binsearch(&frame.fini, i, &j); assert(assret);
IGRAPH_CHECK(igraph_vector_insert(&frame.fini, j, i));
/* Create new_cand and new_fini */
IGRAPH_CHECK(igraph_vector_intersect_sorted(&frame.cand, igraph_adjlist_get(&adj_list, i), &new_cand));
IGRAPH_CHECK(igraph_vector_intersect_sorted(&frame.fini, igraph_adjlist_get(&adj_list, i), &new_fini));
/* Do we have anything more to search? */
if (igraph_vector_empty(&new_cand)) {
if (igraph_vector_empty(&new_fini)) {
/* We have a maximal clique here */
IGRAPH_CHECK(func(&clique, data, &cont));
if (!cont) {
/* The callback function requested to stop the search */
break;
}
}
igraph_vector_pop_back(&clique);
continue;
}
if (igraph_vector_empty(&new_fini) && igraph_vector_size(&new_cand) == 1) {
/* Shortcut: only one node left */
IGRAPH_CHECK(igraph_vector_push_back(&clique, VECTOR(new_cand)[0]));
IGRAPH_CHECK(func(&clique, data, &cont));
if (!cont) {
/* The callback function requested to stop the search */
break;
}
igraph_vector_pop_back(&clique);
igraph_vector_pop_back(&clique);
continue;
}
/* Find the next best candidate node in new_fini */
l = igraph_vector_size(&new_cand);
best_cand_degree = -1;
j = igraph_vector_size(&new_fini);
for (i = 0; i < j; i++) {
k = (long int)VECTOR(new_fini)[i];
IGRAPH_CHECK(igraph_vector_intersect_sorted(&new_cand, igraph_adjlist_get(&adj_list, k), &cn));
if (igraph_vector_size(&cn) > best_cand_degree) {
best_cand_degree = igraph_vector_size(&cn);
IGRAPH_CHECK(igraph_vector_update(&best_fini_cand_nbrs, &cn));
if (best_cand_degree == l) {
/* Cool, we surely have the best candidate node here as best_cand_degree can't get any better */
break;
}
}
}
/* Shortcut here: we don't have to examine new_cand */
if (best_cand_degree == l) {
igraph_vector_pop_back(&clique);
continue;
}
/* Still finding best candidate node */
best_fini_cand_degree = best_cand_degree;
best_cand_degree = -1;
j = igraph_vector_size(&new_cand);
l = l - 1;
for (i = 0; i < j; i++) {
k = (long int)VECTOR(new_cand)[i];
IGRAPH_CHECK(igraph_vector_intersect_sorted(&new_cand, igraph_adjlist_get(&adj_list, k), &cn));
if (igraph_vector_size(&cn) > best_cand_degree) {
best_cand_degree = igraph_vector_size(&cn);
IGRAPH_CHECK(igraph_vector_update(&best_cand_nbrs, &cn));
if (best_cand_degree == l) {
/* Cool, we surely have the best candidate node here as best_cand_degree can't get any better */
break;
}
}
}
/* Create a new stack frame in case we back out later */
new_frame_ptr = igraph_Calloc(1, igraph_i_maximal_cliques_stack_frame);
if (new_frame_ptr == 0) {
IGRAPH_ERROR("cannot allocate new stack frame", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, new_frame_ptr);
*new_frame_ptr = frame;
memset(&frame, 0, sizeof(frame));
IGRAPH_CHECK(igraph_stack_ptr_push(&stack, new_frame_ptr));
IGRAPH_FINALLY_CLEAN(1); /* ownership of new_frame_ptr taken by the stack */
/* Ownership of the current frame and its vectors (frame.cand, frame.done, frame.cand_filtered)
* is taken by the stack from now on. Vectors in frame must be re-initialized with new_cand,
* new_fini and stuff. The old frame.cand and frame.fini won't be leaked because they are
* managed by the stack now. */
frame.cand = new_cand;
frame.fini = new_fini;
IGRAPH_CHECK(igraph_vector_init(&new_cand, 0));
IGRAPH_CHECK(igraph_vector_init(&new_fini, 0));
IGRAPH_CHECK(igraph_vector_init(&frame.cand_filtered, 0));
/* Adjust frame.cand_filtered */
if (best_cand_degree < best_fini_cand_degree) {
IGRAPH_CHECK(igraph_vector_difference_sorted(&frame.cand, &best_fini_cand_nbrs, &frame.cand_filtered));
} else {
IGRAPH_CHECK(igraph_vector_difference_sorted(&frame.cand, &best_cand_nbrs, &frame.cand_filtered));
}
}
IGRAPH_PROGRESS("Maximal cliques: ", 100.0, NULL);
igraph_adjlist_destroy(&adj_list);
igraph_vector_destroy(&clique);
igraph_vector_destroy(&new_cand);
igraph_vector_destroy(&new_fini);
igraph_vector_destroy(&cn);
igraph_vector_destroy(&best_cand_nbrs);
igraph_vector_destroy(&best_fini_cand_nbrs);
igraph_i_maximal_cliques_stack_frame_destroy(&frame);
igraph_i_maximal_cliques_stack_destroy(&stack);
IGRAPH_FINALLY_CLEAN(9);
return IGRAPH_SUCCESS;
}
int igraph_forest_fire_game(igraph_t *graph, igraph_integer_t nodes,
igraph_real_t fw_prob, igraph_real_t bw_factor,
igraph_integer_t pambs, igraph_bool_t directed) {
igraph_vector_long_t visited;
long int no_of_nodes=nodes, actnode, i;
igraph_vector_t edges;
igraph_vector_t *inneis, *outneis;
igraph_i_forest_fire_data_t data;
igraph_dqueue_t neiq;
long int ambs=pambs;
igraph_real_t param_geom_out=1-fw_prob;
igraph_real_t param_geom_in=1-fw_prob*bw_factor;
if (fw_prob < 0) {
IGRAPH_ERROR("Forest fire model: 'fw_prob' should be between non-negative",
IGRAPH_EINVAL);
}
if (bw_factor < 0) {
IGRAPH_ERROR("Forest fire model: 'bw_factor' should be non-negative",
IGRAPH_EINVAL);
}
if (ambs < 0) {
IGRAPH_ERROR("Number of ambassadors ('ambs') should be non-negative",
IGRAPH_EINVAL);
}
if (fw_prob == 0 || ambs == 0) {
IGRAPH_WARNING("'fw_prob or ambs is zero, creating empty graph");
IGRAPH_CHECK(igraph_empty(graph, nodes, directed));
return 0;
}
IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
inneis=igraph_Calloc(no_of_nodes, igraph_vector_t);
if (!inneis) {
IGRAPH_ERROR("Cannot run forest fire model", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, inneis);
outneis=igraph_Calloc(no_of_nodes, igraph_vector_t);
if (!outneis) {
IGRAPH_ERROR("Cannot run forest fire model", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, outneis);
data.inneis=inneis;
data.outneis=outneis;
data.no_of_nodes=no_of_nodes;
IGRAPH_FINALLY(igraph_i_forest_fire_free, &data);
for (i=0; i<no_of_nodes; i++) {
IGRAPH_CHECK(igraph_vector_init(inneis+i, 0));
IGRAPH_CHECK(igraph_vector_init(outneis+i, 0));
}
IGRAPH_CHECK(igraph_vector_long_init(&visited, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &visited);
IGRAPH_DQUEUE_INIT_FINALLY(&neiq, 10);
RNG_BEGIN();
#define ADD_EDGE_TO(nei) \
if (VECTOR(visited)[(nei)] != actnode+1) { \
VECTOR(visited)[(nei)] = actnode+1; \
IGRAPH_CHECK(igraph_dqueue_push(&neiq, nei)); \
IGRAPH_CHECK(igraph_vector_push_back(&edges, actnode)); \
IGRAPH_CHECK(igraph_vector_push_back(&edges, nei)); \
IGRAPH_CHECK(igraph_vector_push_back(outneis+actnode, nei)); \
IGRAPH_CHECK(igraph_vector_push_back(inneis+nei, actnode)); \
}
IGRAPH_PROGRESS("Forest fire: ", 0.0, NULL);
for (actnode=1; actnode < no_of_nodes; actnode++) {
IGRAPH_PROGRESS("Forest fire: ", 100.0*actnode/no_of_nodes, NULL);
IGRAPH_ALLOW_INTERRUPTION();
/* We don't want to visit the current vertex */
VECTOR(visited)[actnode] = actnode+1;
/* Choose ambassador(s) */
for (i=0; i<ambs; i++) {
long int a=RNG_INTEGER(0, actnode-1);
ADD_EDGE_TO(a);
}
while (!igraph_dqueue_empty(&neiq)) {
long int actamb=(long int) igraph_dqueue_pop(&neiq);
igraph_vector_t *outv=outneis+actamb;
igraph_vector_t *inv=inneis+actamb;
long int no_in=igraph_vector_size(inv);
long int no_out=igraph_vector_size(outv);
long int neis_out=(long int) RNG_GEOM(param_geom_out);
long int neis_in=(long int) RNG_GEOM(param_geom_in);
/* outgoing neighbors */
if (neis_out >= no_out) {
for (i=0; i<no_out; i++) {
long int nei=(long int) VECTOR(*outv)[i];
ADD_EDGE_TO(nei);
}
} else {
long int oleft=no_out;
for (i=0; i<neis_out && oleft > 0; ) {
long int which=RNG_INTEGER(0, oleft-1);
long int nei=(long int) VECTOR(*outv)[which];
VECTOR(*outv)[which] = VECTOR(*outv)[oleft-1];
VECTOR(*outv)[oleft-1] = nei;
if (VECTOR(visited)[nei] != actnode+1) {
ADD_EDGE_TO(nei);
i++;
}
oleft--;
}
}
/* incoming neighbors */
if (neis_in >= no_in) {
for (i=0; i<no_in; i++) {
long int nei=(long int) VECTOR(*inv)[i];
ADD_EDGE_TO(nei);
}
} else {
long int ileft=no_in;
for (i=0; i<neis_in && ileft > 0; ) {
long int which=RNG_INTEGER(0, ileft-1);
long int nei=(long int) VECTOR(*inv)[which];
VECTOR(*inv)[which] = VECTOR(*inv)[ileft-1];
VECTOR(*inv)[ileft-1] = nei;
if (VECTOR(visited)[nei] != actnode+1) {
ADD_EDGE_TO(nei);
i++;
}
ileft--;
}
}
} /* while neiq not empty */
} /* actnode < no_of_nodes */
#undef ADD_EDGE_TO
RNG_END();
IGRAPH_PROGRESS("Forest fire: ", 100.0, NULL);
igraph_dqueue_destroy(&neiq);
igraph_vector_long_destroy(&visited);
igraph_i_forest_fire_free(&data);
igraph_free(outneis);
igraph_free(inneis);
IGRAPH_FINALLY_CLEAN(5);
IGRAPH_CHECK(igraph_create(graph, &edges, nodes, directed));
igraph_vector_destroy(&edges);
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int igraph_clusters_strong(const igraph_t *graph, igraph_vector_t *membership,
igraph_vector_t *csize, igraph_integer_t *no) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_t next_nei=IGRAPH_VECTOR_NULL;
long int i;
igraph_dqueue_t q=IGRAPH_DQUEUE_NULL;
long int no_of_clusters=1;
long int act_cluster_size;
igraph_vector_t out=IGRAPH_VECTOR_NULL;
igraph_vector_t tmp=IGRAPH_VECTOR_NULL;
/* The result */
IGRAPH_VECTOR_INIT_FINALLY(&next_nei, no_of_nodes);
IGRAPH_VECTOR_INIT_FINALLY(&out, 0);
IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
IGRAPH_VECTOR_INIT_FINALLY(&tmp, 0);
if (membership) {
IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
}
IGRAPH_CHECK(igraph_vector_reserve(&out, no_of_nodes));
igraph_vector_null(&out);
if (csize) {
igraph_vector_clear(csize);
}
for (i=0; i<no_of_nodes; i++) {
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_neighbors(graph, &tmp, (igraph_integer_t) i,
IGRAPH_OUT));
if (VECTOR(next_nei)[i] > igraph_vector_size(&tmp)) { continue; }
IGRAPH_CHECK(igraph_dqueue_push(&q, i));
while (!igraph_dqueue_empty(&q)) {
long int act_node=(long int) igraph_dqueue_back(&q);
IGRAPH_CHECK(igraph_neighbors(graph, &tmp, (igraph_integer_t) act_node,
IGRAPH_OUT));
if (VECTOR(next_nei)[act_node]==0) {
/* this is the first time we've met this vertex */
VECTOR(next_nei)[act_node]++;
} else if (VECTOR(next_nei)[act_node] <= igraph_vector_size(&tmp)) {
/* we've already met this vertex but it has more children */
long int neighbor=(long int) VECTOR(tmp)[(long int)
VECTOR(next_nei)[act_node]-1];
if (VECTOR(next_nei)[neighbor] == 0) {
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
}
VECTOR(next_nei)[act_node]++;
} else {
/* we've met this vertex and it has no more children */
IGRAPH_CHECK(igraph_vector_push_back(&out, act_node));
igraph_dqueue_pop_back(&q);
}
} /* while q */
} /* for */
/* OK, we've the 'out' values for the nodes, let's use them in
decreasing order with the help of a heap */
igraph_vector_null(&next_nei); /* mark already
added vertices */
while (!igraph_vector_empty(&out)) {
long int grandfather=(long int) igraph_vector_pop_back(&out);
IGRAPH_ALLOW_INTERRUPTION();
if (VECTOR(next_nei)[grandfather] != 0) { continue; }
VECTOR(next_nei)[grandfather]=1;
act_cluster_size=1;
if (membership) {
VECTOR(*membership)[grandfather]=no_of_clusters-1;
}
IGRAPH_CHECK(igraph_dqueue_push(&q, grandfather));
while (!igraph_dqueue_empty(&q)) {
long int act_node=(long int) igraph_dqueue_pop_back(&q);
IGRAPH_CHECK(igraph_neighbors(graph, &tmp, (igraph_integer_t) act_node,
IGRAPH_IN));
for (i=0; i<igraph_vector_size(&tmp); i++) {
long int neighbor=(long int) VECTOR(tmp)[i];
if (VECTOR(next_nei)[neighbor] != 0) { continue; }
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
VECTOR(next_nei)[neighbor]=1;
act_cluster_size++;
if (membership) {
VECTOR(*membership)[neighbor]=no_of_clusters-1;
}
}
}
no_of_clusters++;
if (csize) {
IGRAPH_CHECK(igraph_vector_push_back(csize, act_cluster_size));
}
}
if (no) { *no=(igraph_integer_t) no_of_clusters-1; }
/* Clean up, return */
igraph_vector_destroy(&out);
igraph_vector_destroy(&tmp);
igraph_dqueue_destroy(&q);
igraph_vector_destroy(&next_nei);
IGRAPH_FINALLY_CLEAN(4);
return 0;
}
int igraph_cocitation_real(const igraph_t *graph, igraph_matrix_t *res,
igraph_vs_t vids,
igraph_neimode_t mode,
igraph_vector_t *weights) {
long int no_of_nodes=igraph_vcount(graph);
long int no_of_vids;
long int from, i, j, k, l, u, v;
igraph_vector_t neis=IGRAPH_VECTOR_NULL;
igraph_vector_t vid_reverse_index;
igraph_vit_t vit;
IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
no_of_vids = IGRAPH_VIT_SIZE(vit);
/* Create a mapping from vertex IDs to the row of the matrix where
* the result for this vertex will appear */
IGRAPH_VECTOR_INIT_FINALLY(&vid_reverse_index, no_of_nodes);
igraph_vector_fill(&vid_reverse_index, -1);
for (IGRAPH_VIT_RESET(vit), i = 0; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit), i++) {
v = IGRAPH_VIT_GET(vit);
if (v < 0 || v >= no_of_nodes)
IGRAPH_ERROR("invalid vertex ID in vertex selector", IGRAPH_EINVAL);
VECTOR(vid_reverse_index)[v] = i;
}
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
IGRAPH_CHECK(igraph_matrix_resize(res, no_of_vids, no_of_nodes));
igraph_matrix_null(res);
/* The result */
for (from=0; from<no_of_nodes; from++) {
igraph_real_t weight = 1;
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_neighbors(graph, &neis,
(igraph_integer_t) from, mode));
if (weights)
weight = VECTOR(*weights)[from];
for (i=0; i < igraph_vector_size(&neis)-1; i++) {
u = (long int) VECTOR(neis)[i];
k = (long int) VECTOR(vid_reverse_index)[u];
for (j=i+1; j<igraph_vector_size(&neis); j++) {
v = (long int) VECTOR(neis)[j];
l = (long int) VECTOR(vid_reverse_index)[v];
if (k != -1)
MATRIX(*res, k, v) += weight;
if (l != -1)
MATRIX(*res, l, u) += weight;
}
}
}
/* Clean up */
igraph_vector_destroy(&neis);
igraph_vector_destroy(&vid_reverse_index);
igraph_vit_destroy(&vit);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
/**
* \ingroup communities
* \function igraph_i_community_multilevel_step
* \brief Performs a single step of the multi-level modularity optimization method
*
* This function implements a single step of the multi-level modularity optimization
* algorithm for finding community structure, see VD Blondel, J-L Guillaume,
* R Lambiotte and E Lefebvre: Fast unfolding of community hierarchies in large
* networks, http://arxiv.org/abs/0803.0476 for the details.
*
* This function was contributed by Tom Gregorovic.
*
* \param graph The input graph. It must be an undirected graph.
* \param weights Numeric vector containing edge weights. If \c NULL, every edge
* has equal weight. The weights are expected to be non-negative.
* \param membership The membership vector, the result is returned here.
* For each vertex it gives the ID of its community.
* \param modularity The modularity of the partition is returned here.
* \c NULL means that the modularity is not needed.
* \return Error code.
*
* Time complexity: in average near linear on sparse graphs.
*/
int igraph_i_community_multilevel_step(igraph_t *graph,
igraph_vector_t *weights, igraph_vector_t *membership,
igraph_real_t *modularity) {
long int i, j;
long int vcount = igraph_vcount(graph);
long int ecount = igraph_ecount(graph);
igraph_integer_t ffrom, fto;
igraph_real_t q, pass_q;
int pass;
igraph_bool_t changed = 0;
igraph_vector_t links_community;
igraph_vector_t links_weight;
igraph_vector_t edges;
igraph_vector_t temp_membership;
igraph_i_multilevel_community_list communities;
/* Initial sanity checks on the input parameters */
if (igraph_is_directed(graph)) {
IGRAPH_ERROR("multi-level community detection works for undirected graphs only",
IGRAPH_UNIMPLEMENTED);
}
if (igraph_vector_size(weights) < igraph_ecount(graph))
IGRAPH_ERROR("multi-level community detection: weight vector too short", IGRAPH_EINVAL);
if (igraph_vector_any_smaller(weights, 0))
IGRAPH_ERROR("weights must be positive", IGRAPH_EINVAL);
/* Initialize data structures */
IGRAPH_VECTOR_INIT_FINALLY(&links_community, 0);
IGRAPH_VECTOR_INIT_FINALLY(&links_weight, 0);
IGRAPH_VECTOR_INIT_FINALLY(&edges, 0);
IGRAPH_VECTOR_INIT_FINALLY(&temp_membership, vcount);
IGRAPH_CHECK(igraph_vector_resize(membership, vcount));
/* Initialize list of communities from graph vertices */
communities.vertices_no = vcount;
communities.communities_no = vcount;
communities.weights = weights;
communities.weight_sum = 2 * igraph_vector_sum(weights);
communities.membership = membership;
communities.item = igraph_Calloc(vcount, igraph_i_multilevel_community);
if (communities.item == 0) {
IGRAPH_ERROR("multi-level community structure detection failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, communities.item);
/* Still initializing the communities data structure */
for (i=0; i < vcount; i++) {
VECTOR(*communities.membership)[i] = i;
communities.item[i].size = 1;
communities.item[i].weight_inside = 0;
communities.item[i].weight_all = 0;
}
/* Some more initialization :) */
for (i = 0; i < ecount; i++) {
igraph_real_t weight = 1;
igraph_edge(graph, (igraph_integer_t) i, &ffrom, &fto);
weight = VECTOR(*weights)[i];
communities.item[(long int) ffrom].weight_all += weight;
communities.item[(long int) fto].weight_all += weight;
if (ffrom == fto)
communities.item[(long int) ffrom].weight_inside += 2*weight;
}
q = igraph_i_multilevel_community_modularity(&communities);
pass = 1;
do { /* Pass begin */
long int temp_communities_no = communities.communities_no;
pass_q = q;
changed = 0;
/* Save the current membership, it will be restored in case of worse result */
IGRAPH_CHECK(igraph_vector_update(&temp_membership, communities.membership));
for (i = 0; i < vcount; i++) {
/* Exclude vertex from its current community */
igraph_real_t weight_all = 0;
igraph_real_t weight_inside = 0;
igraph_real_t weight_loop = 0;
igraph_real_t max_q_gain = 0;
igraph_real_t max_weight;
long int old_id, new_id, n;
igraph_i_multilevel_community_links(graph, &communities,
(igraph_integer_t) i, &edges,
&weight_all, &weight_inside,
&weight_loop, &links_community,
&links_weight);
old_id = (long int)VECTOR(*(communities.membership))[i];
new_id = old_id;
/* Update old community */
igraph_vector_set(communities.membership, i, -1);
communities.item[old_id].size--;
if (communities.item[old_id].size == 0) {communities.communities_no--;}
communities.item[old_id].weight_all -= weight_all;
communities.item[old_id].weight_inside -= 2*weight_inside + weight_loop;
/* debug("Remove %ld all: %lf Inside: %lf\n", i, -weight_all, -2*weight_inside + weight_loop); */
/* Find new community to join with the best modification gain */
max_q_gain = 0;
max_weight = weight_inside;
n = igraph_vector_size(&links_community);
igraph_vector_sort(&links_community);
for (j = 0; j < n; j++) {
long int c = (long int) VECTOR(links_community)[j];
igraph_real_t w = VECTOR(links_weight)[j];
igraph_real_t q_gain =
igraph_i_multilevel_community_modularity_gain(&communities,
(igraph_integer_t) c,
(igraph_integer_t) i,
weight_all, w);
/* debug("Link %ld -> %ld weight: %lf gain: %lf\n", i, c, (double) w, (double) q_gain); */
if (q_gain > max_q_gain) {
new_id = c;
max_q_gain = q_gain;
max_weight = w;
}
}
/* debug("Added vertex %ld to community %ld (gain %lf).\n", i, new_id, (double) max_q_gain); */
/* Add vertex to "new" community and update it */
igraph_vector_set(communities.membership, i, new_id);
if (communities.item[new_id].size == 0) {communities.communities_no++;}
communities.item[new_id].size++;
communities.item[new_id].weight_all += weight_all;
communities.item[new_id].weight_inside += 2*max_weight + weight_loop;
if (new_id != old_id) {
changed++;
}
}
q = igraph_i_multilevel_community_modularity(&communities);
if (changed && (q > pass_q)) {
/* debug("Pass %d (changed: %d) Communities: %ld Modularity from %lf to %lf\n",
pass, changed, communities.communities_no, (double) pass_q, (double) q); */
pass++;
} else {
/* No changes or the modularity became worse, restore last membership */
IGRAPH_CHECK(igraph_vector_update(communities.membership, &temp_membership));
communities.communities_no = temp_communities_no;
break;
}
IGRAPH_ALLOW_INTERRUPTION();
} while (changed && (q > pass_q)); /* Pass end */
if (modularity) {
*modularity = q;
}
/* debug("Result Communities: %ld Modularity: %lf\n",
communities.communities_no, (double) q); */
IGRAPH_CHECK(igraph_reindex_membership(membership, 0));
/* Shrink the nodes of the graph according to the present community structure
* and simplify the resulting graph */
/* TODO: check if we really need to copy temp_membership */
IGRAPH_CHECK(igraph_vector_update(&temp_membership, membership));
IGRAPH_CHECK(igraph_i_multilevel_shrink(graph, &temp_membership));
igraph_vector_destroy(&temp_membership);
IGRAPH_FINALLY_CLEAN(1);
/* Update edge weights after shrinking and simplification */
/* Here we reuse the edges vector as we don't need the previous contents anymore */
/* TODO: can we use igraph_simplify here? */
IGRAPH_CHECK(igraph_i_multilevel_simplify_multiple(graph, &edges));
/* We reuse the links_weight vector to store the old edge weights */
IGRAPH_CHECK(igraph_vector_update(&links_weight, weights));
igraph_vector_fill(weights, 0);
for (i = 0; i < ecount; i++) {
VECTOR(*weights)[(long int)VECTOR(edges)[i]] += VECTOR(links_weight)[i];
}
igraph_free(communities.item);
igraph_vector_destroy(&links_community);
igraph_vector_destroy(&links_weight);
igraph_vector_destroy(&edges);
IGRAPH_FINALLY_CLEAN(4);
return 0;
}
int igraph_biconnected_components(const igraph_t *graph,
igraph_integer_t *no,
igraph_vector_ptr_t *components,
igraph_vector_t *articulation_points) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_long_t nextptr;
igraph_vector_long_t num, low;
igraph_vector_bool_t found;
igraph_vector_t *adjedges;
igraph_stack_t path;
igraph_vector_t edgestack;
igraph_adjedgelist_t adjedgelist;
long int i, counter, rootdfs=0;
IGRAPH_CHECK(igraph_vector_long_init(&nextptr, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &nextptr);
IGRAPH_CHECK(igraph_vector_long_init(&num, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &num);
IGRAPH_CHECK(igraph_vector_long_init(&low, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &low);
IGRAPH_CHECK(igraph_vector_bool_init(&found, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &found);
IGRAPH_CHECK(igraph_stack_init(&path, 100));
IGRAPH_FINALLY(igraph_stack_destroy, &path);
IGRAPH_VECTOR_INIT_FINALLY(&edgestack, 0);
IGRAPH_CHECK(igraph_vector_reserve(&edgestack, 100));
IGRAPH_CHECK(igraph_adjedgelist_init(graph, &adjedgelist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjedgelist_destroy, &adjedgelist);
if (no) {
*no=0;
}
if (components) {
igraph_vector_ptr_clear(components);
}
if (articulation_points) {
igraph_vector_clear(articulation_points);
}
for (i=0; i<no_of_nodes; i++) {
if (VECTOR(low)[i] != 0) {
continue; /* already visited */
}
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_stack_push(&path, i));
counter=1;
rootdfs=0;
VECTOR(low)[i]=VECTOR(num)[i]=counter++;
while (!igraph_stack_empty(&path)) {
long int n;
long int act=igraph_stack_top(&path);
long int actnext=VECTOR(nextptr)[act];
adjedges=igraph_adjedgelist_get(&adjedgelist, act);
n=igraph_vector_size(adjedges);
if (actnext < n) {
/* Step down (maybe) */
long int edge=VECTOR(*adjedges)[actnext];
long int nei=IGRAPH_OTHER(graph, edge, act);
if (VECTOR(low)[nei] == 0) {
if (act==i) {
rootdfs++;
}
IGRAPH_CHECK(igraph_vector_push_back(&edgestack, edge));
IGRAPH_CHECK(igraph_stack_push(&path, nei));
VECTOR(low)[nei] = VECTOR(num)[nei]=counter++;
} else {
/* Update low value if needed */
if (VECTOR(num)[nei] < VECTOR(low)[act]) {
VECTOR(low)[act]=VECTOR(num)[nei];
}
}
VECTOR(nextptr)[act] += 1;
} else {
/* Step up */
igraph_stack_pop(&path);
if (!igraph_stack_empty(&path)) {
long int prev=igraph_stack_top(&path);
/* Update LOW value if needed */
if (VECTOR(low)[act] < VECTOR(low)[prev]) {
VECTOR(low)[prev] = VECTOR(low)[act];
}
/* Check for articulation point */
if (VECTOR(low)[act] >= VECTOR(num)[prev]) {
if (articulation_points && !VECTOR(found)[prev]
&& prev != i /* the root */) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, prev));
VECTOR(found)[prev] = 1;
}
if (no) {
*no += 1;
}
if (components) {
igraph_vector_t *v=igraph_Calloc(1, igraph_vector_t);
IGRAPH_CHECK(igraph_vector_init(v, 0));
while (!igraph_vector_empty(&edgestack)) {
long int e=igraph_vector_pop_back(&edgestack);
IGRAPH_CHECK(igraph_vector_push_back(v, e));
if (IGRAPH_FROM(graph,e)==prev || IGRAPH_TO(graph,e)==prev) {
break;
}
}
IGRAPH_CHECK(igraph_vector_ptr_push_back(components, v));
}
}
} /* !igraph_stack_empty(&path) */
}
} /* !igraph_stack_empty(&path) */
if (articulation_points && rootdfs >= 2) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, i));
}
} /* i < no_of_nodes */
igraph_adjedgelist_destroy(&adjedgelist);
igraph_vector_destroy(&edgestack);
igraph_stack_destroy(&path);
igraph_vector_bool_destroy(&found);
igraph_vector_long_destroy(&low);
igraph_vector_long_destroy(&num);
igraph_vector_long_destroy(&nextptr);
IGRAPH_FINALLY_CLEAN(7);
return 0;
}
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;
}
int igraph_revolver_p_p(const igraph_t *graph,
igraph_integer_t niter,
const igraph_vector_t *vtime,
const igraph_vector_t *etime,
const igraph_vector_t *authors,
const igraph_vector_t *eventsizes,
igraph_matrix_t *kernel,
igraph_matrix_t *sd,
igraph_matrix_t *norm,
igraph_matrix_t *cites,
igraph_matrix_t *expected,
igraph_real_t *logprob,
igraph_real_t *lognull,
const igraph_matrix_t *debug,
igraph_vector_ptr_t *debugres) {
igraph_integer_t no_of_events;
igraph_vector_t st;
long int i;
igraph_integer_t maxpapers=0;
igraph_vector_t vtimeidx, etimeidx;
igraph_lazy_inclist_t inclist;
igraph_vector_long_t papers;
if (igraph_vector_size(vtime) != igraph_vcount(graph)) {
IGRAPH_ERROR("Invalid vtime length", IGRAPH_EINVAL);
}
if (igraph_vector_size(etime) != igraph_ecount(graph)) {
IGRAPH_ERROR("Invalid etime length", IGRAPH_EINVAL);
}
no_of_events=(igraph_integer_t) igraph_vector_size(eventsizes);
IGRAPH_VECTOR_INIT_FINALLY(&st, no_of_events);
for (i=0; i<no_of_events; i++) {
VECTOR(st)[i]=1;
}
IGRAPH_CHECK(igraph_vector_long_init(&papers, igraph_vcount(graph)));
IGRAPH_FINALLY(igraph_vector_long_destroy, &papers);
for (i=0; i<igraph_vector_size(authors); i++) {
long int author=(long int) VECTOR(*authors)[i];
VECTOR(papers)[author] += 1;
if (VECTOR(papers)[author] > maxpapers) {
maxpapers=(igraph_integer_t) VECTOR(papers)[author];
}
}
igraph_vector_long_destroy(&papers);
IGRAPH_FINALLY_CLEAN(1);
IGRAPH_VECTOR_INIT_FINALLY(&vtimeidx, 0);
IGRAPH_VECTOR_INIT_FINALLY(&etimeidx, 0);
IGRAPH_CHECK(igraph_vector_order1(vtime, &vtimeidx, no_of_events));
IGRAPH_CHECK(igraph_vector_order1(etime, &etimeidx, no_of_events));
IGRAPH_CHECK(igraph_lazy_inclist_init(graph, &inclist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_lazy_inclist_destroy, &inclist);
IGRAPH_PROGRESS("Revolver p-p", 0, NULL);
for (i=0; i<niter; i++) {
IGRAPH_ALLOW_INTERRUPTION();
if (i+1 != niter) { /* not the last iteration */
/* measure */
IGRAPH_CHECK(igraph_revolver_mes_p_p(graph, &inclist,
kernel, 0 /*sd*/, 0 /*norm*/,
0/*cites*/, 0/*debug*/, 0 /*debugres*/,
&st, vtime, &vtimeidx, etime,
&etimeidx, no_of_events,
authors, eventsizes,
maxpapers));
/* normalize */
igraph_matrix_scale(kernel, 1/igraph_matrix_sum(kernel));
/* update st */
IGRAPH_CHECK(igraph_revolver_st_p_p(graph, &inclist,
&st, kernel, vtime, &vtimeidx,
etime, &etimeidx,
no_of_events, authors,
eventsizes, maxpapers));
} else {
/* measure */
IGRAPH_CHECK(igraph_revolver_mes_p_p(graph, &inclist,
kernel, sd, norm, cites,
debug, debugres, &st, vtime, &vtimeidx,
etime, &etimeidx,
no_of_events, authors,
eventsizes, maxpapers));
/* normalize */
igraph_matrix_scale(kernel, 1/igraph_matrix_sum(kernel));
/* update st */
IGRAPH_CHECK(igraph_revolver_st_p_p(graph, &inclist,
&st, kernel, vtime, &vtimeidx,
etime, &etimeidx,
no_of_events, authors, eventsizes,
maxpapers));
/* expected number of citations */
if (expected) {
IGRAPH_CHECK(igraph_revolver_exp_p_p(graph, &inclist,
expected, kernel, &st,
vtime, &vtimeidx, etime, &etimeidx,
no_of_events, authors, eventsizes,
maxpapers));
}
/* error calculation */
if (logprob || lognull) {
IGRAPH_CHECK(igraph_revolver_error_p_p(graph, &inclist,
kernel, &st,
vtime, &vtimeidx,
etime, &etimeidx, no_of_events,
authors, eventsizes,
maxpapers, logprob, lognull));
}
}
IGRAPH_PROGRESS("Revolver p-p", 100.0*(i+1)/niter, NULL);
}
igraph_lazy_inclist_destroy(&inclist);
igraph_vector_destroy(&etimeidx);
igraph_vector_destroy(&vtimeidx);
igraph_vector_destroy(&st);
IGRAPH_FINALLY_CLEAN(4);
return 0;
}
int igraph_i_find_k_cliques(const igraph_t *graph,
long int size,
const igraph_real_t *member_storage,
igraph_real_t **new_member_storage,
long int old_clique_count,
long int *clique_count,
igraph_vector_t *neis,
igraph_bool_t independent_vertices) {
long int j, k, l, m, n, new_member_storage_size;
const igraph_real_t *c1, *c2;
igraph_real_t v1, v2;
igraph_bool_t ok;
/* Allocate the storage */
*new_member_storage=igraph_Realloc(*new_member_storage,
size*old_clique_count,
igraph_real_t);
if (*new_member_storage == 0) {
IGRAPH_ERROR("cliques failed", IGRAPH_ENOMEM);
}
new_member_storage_size = size*old_clique_count;
IGRAPH_FINALLY(igraph_free, *new_member_storage);
m=n=0;
/* Now consider all pairs of i-1-cliques and see if they can be merged */
for (j=0; j<old_clique_count; j++) {
for (k=j+1; k<old_clique_count; k++) {
IGRAPH_ALLOW_INTERRUPTION();
/* Since cliques are represented by their vertex indices in increasing
* order, two cliques can be merged iff they have exactly the same
* indices excluding one AND there is an edge between the two different
* vertices */
c1 = member_storage+j*(size-1);
c2 = member_storage+k*(size-1);
/* Find the longest prefixes of c1 and c2 that are equal */
for (l=0; l<size-1 && c1[l] == c2[l]; l++)
(*new_member_storage)[m++]=c1[l];
/* Now, if l == size-1, the two vectors are totally equal.
This is a bug */
if (l == size-1) {
IGRAPH_WARNING("possible bug in igraph_cliques");
m=n;
} else {
/* Assuming that j<k, c1[l] is always less than c2[l], since cliques
* are ordered alphabetically. Now add c1[l] and store c2[l] in a
* dummy variable */
(*new_member_storage)[m++]=c1[l];
v1=c1[l];
v2=c2[l];
l++;
/* Copy the remaining part of the two vectors. Every member pair
* found in the remaining parts satisfies the following:
* 1. If they are equal, they should be added.
* 2. If they are not equal, the smaller must be equal to the
* one stored in the dummy variable. If not, the two vectors
* differ in more than one place. The larger will be stored in
* the dummy variable again.
*/
ok=1;
for (; l<size-1; l++) {
if (c1[l] == c2[l]) {
(*new_member_storage)[m++]=c1[l];
ok=0;
} else if (ok) {
if (c1[l] < c2[l]) {
if (c1[l] == v1) {
(*new_member_storage)[m++]=c1[l];
v2 = c2[l];
} else break;
} else {
if (ok && c2[l] == v1) {
(*new_member_storage)[m++]=c2[l];
v2 = c1[l];
} else break;
}
} else break;
}
/* Now, if l != size-1, the two vectors had a difference in more than
* one place, so the whole clique is invalid. */
if (l != size-1) {
/* Step back in new_member_storage */
m=n;
} else {
/* v1 and v2 are the two different vertices. Check for an edge
* if we are looking for cliques and check for the absence of an
* edge if we are looking for independent vertex sets */
IGRAPH_CHECK(igraph_neighbors(graph, neis, v1, IGRAPH_ALL));
l=igraph_vector_search(neis, 0, v2, 0);
if ((l && !independent_vertices) || (!l && independent_vertices)) {
/* Found a new clique, step forward in new_member_storage */
if (m==n || v2>(*new_member_storage)[m-1]) {
(*new_member_storage)[m++]=v2;
n=m;
} else {
m=n;
}
} else {
m=n;
}
}
/* See if new_member_storage is full. If so, reallocate */
if (m == new_member_storage_size) {
IGRAPH_FINALLY_CLEAN(1);
*new_member_storage = igraph_Realloc(*new_member_storage,
new_member_storage_size*2,
igraph_real_t);
if (*new_member_storage == 0)
IGRAPH_ERROR("cliques failed", IGRAPH_ENOMEM);
new_member_storage_size *= 2;
IGRAPH_FINALLY(igraph_free, *new_member_storage);
}
}
}
}
/* Calculate how many cliques have we found */
*clique_count = n/size;
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int igraph_biconnected_components(const igraph_t *graph,
igraph_integer_t *no,
igraph_vector_ptr_t *tree_edges,
igraph_vector_ptr_t *component_edges,
igraph_vector_ptr_t *components,
igraph_vector_t *articulation_points) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_long_t nextptr;
igraph_vector_long_t num, low;
igraph_vector_bool_t found;
igraph_vector_int_t *adjedges;
igraph_stack_t path;
igraph_vector_t edgestack;
igraph_inclist_t inclist;
long int i, counter, rootdfs=0;
igraph_vector_long_t vertex_added;
long int comps=0;
igraph_vector_ptr_t *mycomponents=components, vcomponents;
IGRAPH_CHECK(igraph_vector_long_init(&nextptr, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &nextptr);
IGRAPH_CHECK(igraph_vector_long_init(&num, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &num);
IGRAPH_CHECK(igraph_vector_long_init(&low, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &low);
IGRAPH_CHECK(igraph_vector_bool_init(&found, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &found);
IGRAPH_CHECK(igraph_stack_init(&path, 100));
IGRAPH_FINALLY(igraph_stack_destroy, &path);
IGRAPH_VECTOR_INIT_FINALLY(&edgestack, 0);
IGRAPH_CHECK(igraph_vector_reserve(&edgestack, 100));
IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_inclist_destroy, &inclist);
IGRAPH_CHECK(igraph_vector_long_init(&vertex_added, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &vertex_added);
if (no) {
*no=0;
}
if (tree_edges) {
igraph_vector_ptr_clear(tree_edges);
}
if (components) {
igraph_vector_ptr_clear(components);
}
if (component_edges) {
igraph_vector_ptr_clear(component_edges);
}
if (articulation_points) {
igraph_vector_clear(articulation_points);
}
if (component_edges && !components) {
mycomponents=&vcomponents;
IGRAPH_CHECK(igraph_vector_ptr_init(mycomponents, 0));
IGRAPH_FINALLY(igraph_i_free_vectorlist, mycomponents);
}
for (i=0; i<no_of_nodes; i++) {
if (VECTOR(low)[i] != 0) { continue; } /* already visited */
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_stack_push(&path, i));
counter=1;
rootdfs=0;
VECTOR(low)[i]=VECTOR(num)[i]=counter++;
while (!igraph_stack_empty(&path)) {
long int n;
long int act=(long int) igraph_stack_top(&path);
long int actnext=VECTOR(nextptr)[act];
adjedges=igraph_inclist_get(&inclist, act);
n=igraph_vector_int_size(adjedges);
if (actnext < n) {
/* Step down (maybe) */
long int edge=(long int) VECTOR(*adjedges)[actnext];
long int nei=IGRAPH_OTHER(graph, edge, act);
if (VECTOR(low)[nei] == 0) {
if (act==i) { rootdfs++; }
IGRAPH_CHECK(igraph_vector_push_back(&edgestack, edge));
IGRAPH_CHECK(igraph_stack_push(&path, nei));
VECTOR(low)[nei] = VECTOR(num)[nei]=counter++;
} else {
/* Update low value if needed */
if (VECTOR(num)[nei] < VECTOR(low)[act]) {
VECTOR(low)[act]=VECTOR(num)[nei];
}
}
VECTOR(nextptr)[act] += 1;
} else {
/* Step up */
igraph_stack_pop(&path);
if (!igraph_stack_empty(&path)) {
long int prev=(long int) igraph_stack_top(&path);
/* Update LOW value if needed */
if (VECTOR(low)[act] < VECTOR(low)[prev]) {
VECTOR(low)[prev] = VECTOR(low)[act];
}
/* Check for articulation point */
if (VECTOR(low)[act] >= VECTOR(num)[prev]) {
if (articulation_points && !VECTOR(found)[prev]
&& prev != i /* the root */) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, prev));
VECTOR(found)[prev] = 1;
}
if (no) { *no += 1; }
/*------------------------------------*/
/* Record the biconnected component just found */
if (tree_edges || mycomponents) {
igraph_vector_t *v = 0, *v2 = 0;
comps++;
if (tree_edges) {
v=igraph_Calloc(1, igraph_vector_t);
if (!v) { IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM); }
IGRAPH_CHECK(igraph_vector_init(v, 0));
IGRAPH_FINALLY(igraph_vector_destroy, v);
}
if (mycomponents) {
v2=igraph_Calloc(1, igraph_vector_t);
if (!v2) { IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM); }
IGRAPH_CHECK(igraph_vector_init(v2, 0));
IGRAPH_FINALLY(igraph_vector_destroy, v2);
}
while (!igraph_vector_empty(&edgestack)) {
long int e=(long int) igraph_vector_pop_back(&edgestack);
long int from=IGRAPH_FROM(graph,e);
long int to=IGRAPH_TO(graph,e);
if (tree_edges) {
IGRAPH_CHECK(igraph_vector_push_back(v, e));
}
if (mycomponents) {
if (VECTOR(vertex_added)[from] != comps) {
VECTOR(vertex_added)[from] = comps;
IGRAPH_CHECK(igraph_vector_push_back(v2, from));
}
if (VECTOR(vertex_added)[to] != comps) {
VECTOR(vertex_added)[to] = comps;
IGRAPH_CHECK(igraph_vector_push_back(v2, to));
}
}
if (from==prev || to==prev) {
break;
}
}
if (mycomponents) {
IGRAPH_CHECK(igraph_vector_ptr_push_back(mycomponents, v2));
IGRAPH_FINALLY_CLEAN(1);
}
if (tree_edges) {
IGRAPH_CHECK(igraph_vector_ptr_push_back(tree_edges, v));
IGRAPH_FINALLY_CLEAN(1);
}
if (component_edges) {
igraph_vector_t *nodes=VECTOR(*mycomponents)[comps-1];
igraph_vector_t *vv=igraph_Calloc(1, igraph_vector_t);
long int ii, no_vert=igraph_vector_size(nodes);
if (!vv) { IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM); }
IGRAPH_CHECK(igraph_vector_init(vv, 0));
IGRAPH_FINALLY(igraph_vector_destroy, vv);
for (ii=0; ii<no_vert; ii++) {
long int vert=(long int) VECTOR(*nodes)[ii];
igraph_vector_int_t *edges=igraph_inclist_get(&inclist,
vert);
long int j, nn=igraph_vector_int_size(edges);
for (j=0; j<nn; j++) {
long int e=(long int) VECTOR(*edges)[j];
long int nei=IGRAPH_OTHER(graph, e, vert);
if (VECTOR(vertex_added)[nei] == comps && nei<vert) {
IGRAPH_CHECK(igraph_vector_push_back(vv, e));
}
}
}
IGRAPH_CHECK(igraph_vector_ptr_push_back(component_edges, vv));
IGRAPH_FINALLY_CLEAN(1);
}
} /* record component if requested */
/*------------------------------------*/
}
} /* !igraph_stack_empty(&path) */
}
} /* !igraph_stack_empty(&path) */
if (articulation_points && rootdfs >= 2) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, i));
}
} /* i < no_of_nodes */
if (mycomponents != components) {
igraph_i_free_vectorlist(mycomponents);
IGRAPH_FINALLY_CLEAN(1);
}
igraph_vector_long_destroy(&vertex_added);
igraph_inclist_destroy(&inclist);
igraph_vector_destroy(&edgestack);
igraph_stack_destroy(&path);
igraph_vector_bool_destroy(&found);
igraph_vector_long_destroy(&low);
igraph_vector_long_destroy(&num);
igraph_vector_long_destroy(&nextptr);
IGRAPH_FINALLY_CLEAN(8);
return 0;
}
int igraph_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;
}
int igraph_clusters_weak(const igraph_t *graph, igraph_vector_t *membership,
igraph_vector_t *csize, igraph_integer_t *no) {
long int no_of_nodes=igraph_vcount(graph);
char *already_added;
long int first_node, act_cluster_size=0, no_of_clusters=1;
igraph_dqueue_t q=IGRAPH_DQUEUE_NULL;
long int i;
igraph_vector_t neis=IGRAPH_VECTOR_NULL;
already_added=igraph_Calloc(no_of_nodes,char);
if (already_added==0) {
IGRAPH_ERROR("Cannot calculate clusters", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, already_added);
IGRAPH_DQUEUE_INIT_FINALLY(&q, no_of_nodes > 100000 ? 10000 : no_of_nodes/10);
IGRAPH_VECTOR_INIT_FINALLY(&neis, 0);
/* Memory for result, csize is dynamically allocated */
if (membership) {
IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
}
if (csize) {
igraph_vector_clear(csize);
}
/* The algorithm */
for (first_node=0; first_node < no_of_nodes; ++first_node) {
if (already_added[first_node]==1) continue;
IGRAPH_ALLOW_INTERRUPTION();
already_added[first_node]=1;
act_cluster_size=1;
if (membership) {
VECTOR(*membership)[first_node]=no_of_clusters-1;
}
IGRAPH_CHECK(igraph_dqueue_push(&q, first_node));
while ( !igraph_dqueue_empty(&q) ) {
long int act_node=(long int) igraph_dqueue_pop(&q);
IGRAPH_CHECK(igraph_neighbors(graph, &neis,
(igraph_integer_t) act_node, 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));
already_added[neighbor]=1;
act_cluster_size++;
if (membership) {
VECTOR(*membership)[neighbor]=no_of_clusters-1;
}
}
}
no_of_clusters++;
if (csize) {
IGRAPH_CHECK(igraph_vector_push_back(csize, act_cluster_size));
}
}
/* Cleaning up */
if (no) { *no = (igraph_integer_t) no_of_clusters-1; }
igraph_Free(already_added);
igraph_dqueue_destroy(&q);
igraph_vector_destroy(&neis);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
int igraph_i_local_scan_1_directed_all(const igraph_t *graph,
igraph_vector_t *res,
const igraph_vector_t *weights) {
int no_of_nodes=igraph_vcount(graph);
igraph_inclist_t incs;
int i, node;
igraph_vector_int_t neis;
IGRAPH_CHECK(igraph_inclist_init(graph, &incs, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_inclist_destroy, &incs);
igraph_vector_int_init(&neis, no_of_nodes);
IGRAPH_FINALLY(igraph_vector_int_destroy, &neis);
igraph_vector_resize(res, no_of_nodes);
igraph_vector_null(res);
for (node=0; node < no_of_nodes; node++) {
igraph_vector_int_t *edges1=igraph_inclist_get(&incs, node);
int edgeslen1=igraph_vector_int_size(edges1);
IGRAPH_ALLOW_INTERRUPTION();
/* Mark neighbors. We also count the edges that are incident to ego.
Note that this time we do not mark ego, because we don't want to
double count its incident edges later, when we are going over the
incident edges of ego's neighbors. */
for (i=0; i<edgeslen1; i++) {
int e=VECTOR(*edges1)[i];
int nei=IGRAPH_OTHER(graph, e, node);
igraph_real_t w= weights ? VECTOR(*weights)[e] : 1;
VECTOR(neis)[nei] = node+1;
VECTOR(*res)[node] += w;
}
/* Crawl neighbors. We make sure that each neighbor of 'node' is
only crawed once. We count all qualifying edges of ego, and
then unmark ego to avoid double counting. */
for (i=0; i<edgeslen1; i++) {
int e2=VECTOR(*edges1)[i];
int nei=IGRAPH_OTHER(graph, e2, node);
igraph_vector_int_t *edges2;
int j, edgeslen2;
if (VECTOR(neis)[nei] != node+1) { continue; }
edges2=igraph_inclist_get(&incs, nei);
edgeslen2=igraph_vector_int_size(edges2);
for (j=0; j<edgeslen2; j++) {
int e2=VECTOR(*edges2)[j];
int nei2=IGRAPH_OTHER(graph, e2, nei);
igraph_real_t w2= weights ? VECTOR(*weights)[e2] : 1;
if (VECTOR(neis)[nei2] == node+1) {
VECTOR(*res)[node] += w2;
}
}
VECTOR(neis)[nei] = 0;
}
} /* node < no_of_nodes */
igraph_vector_int_destroy(&neis);
igraph_inclist_destroy(&incs);
IGRAPH_FINALLY_CLEAN(2);
return 0;
}
int igraph_revolver_mes_p_p(const igraph_t *graph,
igraph_lazy_inclist_t *inclist,
igraph_matrix_t *kernel,
igraph_matrix_t *sd,
igraph_matrix_t *norm,
igraph_matrix_t *cites,
const igraph_matrix_t *debug,
igraph_vector_ptr_t *debugres,
const igraph_vector_t *st,
const igraph_vector_t *vtime,
const igraph_vector_t *vtimeidx,
const igraph_vector_t *etime,
const igraph_vector_t *etimeidx,
igraph_integer_t pno_of_events,
const igraph_vector_t *authors,
const igraph_vector_t *eventsizes,
igraph_integer_t pmaxpapers) {
long int no_of_nodes=igraph_vcount(graph);
long int no_of_edges=igraph_ecount(graph);
long int no_of_events=pno_of_events;
long int maxpapers=pmaxpapers;
igraph_vector_long_t papers;
igraph_vector_char_t added;
igraph_matrix_t v_normfact, *normfact, v_notnull, *notnull;
igraph_matrix_t ch;
igraph_vector_long_t ntk;
igraph_matrix_t ntkk;
igraph_vector_t *adjedges;
long int timestep, i;
long int nptr=0, eptr=0, aptr=0;
long int nptr_save, eptr_save, eptr_new;
IGRAPH_CHECK(igraph_vector_long_init(&papers, no_of_nodes));
IGRAPH_FINALLY(&igraph_vector_long_destroy, &papers);
IGRAPH_CHECK(igraph_vector_char_init(&added, no_of_edges));
IGRAPH_FINALLY(igraph_vector_char_destroy, &added);
IGRAPH_CHECK(igraph_vector_long_init(&ntk, maxpapers+1));
IGRAPH_FINALLY(igraph_vector_long_destroy, &ntk);
IGRAPH_MATRIX_INIT_FINALLY(&ntkk, maxpapers+1, maxpapers+1);
IGRAPH_MATRIX_INIT_FINALLY(&ch, maxpapers+1, maxpapers+1);
if (norm) {
normfact=norm;
IGRAPH_CHECK(igraph_matrix_resize(normfact, maxpapers+1, maxpapers+1));
igraph_matrix_null(normfact);
} else {
normfact=&v_normfact;
IGRAPH_MATRIX_INIT_FINALLY(normfact, maxpapers+1, maxpapers+1);
}
if (cites) {
notnull=cites;
IGRAPH_CHECK(igraph_matrix_resize(notnull, maxpapers+1, maxpapers+1));
igraph_matrix_null(notnull);
} else {
notnull=&v_notnull;
IGRAPH_MATRIX_INIT_FINALLY(notnull, maxpapers+1, maxpapers+1);
}
IGRAPH_CHECK(igraph_matrix_resize(kernel, maxpapers+1, maxpapers+1));
igraph_matrix_null(kernel);
if (sd) {
IGRAPH_CHECK(igraph_matrix_resize(sd, maxpapers+1, maxpapers+1));
igraph_matrix_null(sd);
}
for (timestep=0; timestep<no_of_events; timestep++) {
IGRAPH_ALLOW_INTERRUPTION();
nptr_save=nptr;
while (nptr < no_of_nodes &&
VECTOR(*vtime)[(long int)VECTOR(*vtimeidx)[nptr]]==timestep) {
nptr++;
}
/* If it is a new author then she has no papers yet */
VECTOR(ntk)[0] += (nptr-nptr_save);
/* Update ch accordingly, could be done later as well */
if (VECTOR(ntk)[0] == nptr-nptr_save && nptr!=nptr_save) {
if (nptr-nptr_save >= 2) {
MATRIX(ch, 0, 0) = eptr;
}
for (i=1; i<maxpapers+1; i++) {
if (NTKK(0,i) == (nptr-nptr_save)*VECTOR(ntk)[i]) {
MATRIX(ch, 0, i) = MATRIX(ch, i, 0) = eptr;
}
}
}
/* print_ntkk(&ntkk, &ntk); */
/* Estimate Akk */
eptr_save=eptr;
while (eptr < no_of_edges &&
VECTOR(*etime)[(long int)VECTOR(*etimeidx)[eptr] ] == timestep) {
long int edge=(long int) VECTOR(*etimeidx)[eptr];
long int from=IGRAPH_FROM(graph, edge), to=IGRAPH_TO(graph, edge);
long int xidx=VECTOR(papers)[from];
long int yidx=VECTOR(papers)[to];
double xk, oldakk;
MATRIX(*notnull, xidx, yidx) += 1;
MATRIX(*notnull, yidx, xidx) = MATRIX(*notnull, xidx, yidx);
xk=VECTOR(*st)[timestep]/NTKK(xidx, yidx);
oldakk=MATRIX(*kernel, xidx, yidx);
MATRIX(*kernel, xidx, yidx) += (xk-oldakk)/MATRIX(*notnull, xidx, yidx);
MATRIX(*kernel, yidx, xidx) = MATRIX(*kernel, xidx, yidx);
if (sd) {
MATRIX(*sd, xidx, yidx) += (xk-oldakk)*(xk-MATRIX(*kernel, xidx, yidx));
MATRIX(*sd, yidx, xidx) = MATRIX(*sd, xidx, yidx);
}
/* TODO: debug */
eptr++;
}
/* update ntkk, the new papers change the type of their authors */
eptr_new=eptr;
for (i=aptr; i<aptr+VECTOR(*eventsizes)[timestep]; i++) {
long int aut=(long int) VECTOR(*authors)[i];
long int pap=VECTOR(papers)[aut];
long int j, n;
adjedges=igraph_lazy_inclist_get(inclist, (igraph_integer_t) aut);
n=igraph_vector_size(adjedges);
for (j=0; j<n; j++) {
long int edge=(long int) VECTOR(*adjedges)[j];
if (VECTOR(added)[edge]) {
long int otherv=IGRAPH_OTHER(graph, edge, aut);
long int otherpap=VECTOR(papers)[otherv];
MATRIX(ntkk, pap, otherpap) -= 1;
MATRIX(ntkk, otherpap, pap) = MATRIX(ntkk, pap, otherpap);
if (NTKK(pap, otherpap)==1) {
MATRIX(ch, pap, otherpap) = eptr_new;
MATRIX(ch, otherpap, pap) = MATRIX(ch, pap, otherpap);
}
MATRIX(ntkk, pap+1, otherpap) += 1;
MATRIX(ntkk, otherpap, pap+1) = MATRIX(ntkk, pap+1, otherpap);
if (NTKK(pap+1, otherpap)==0) {
MATRIX(*normfact, pap+1, otherpap) +=
eptr_new-MATRIX(ch, pap+1, otherpap);
MATRIX(*normfact, otherpap, pap+1) =
MATRIX(*normfact, pap+1, otherpap);
}
}
}
/* update ntk too */
for (j=0; j<maxpapers+1; j++) {
long int before, after;
before=(long int) NTKK(pap, j);
VECTOR(ntk)[pap]-=1;
after=(long int) NTKK(pap, j);
VECTOR(ntk)[pap]+=1;
if (before > 0 && after==0) {
MATRIX(*normfact, pap, j) += eptr_new-MATRIX(ch, pap, j);
MATRIX(*normfact, j, pap) = MATRIX(*normfact, pap, j);
}
}
VECTOR(ntk)[pap]-=1;
for (j=0; j<maxpapers+1; j++) {
long int before, after;
before=(long int) NTKK(pap+1, j);
VECTOR(ntk)[pap+1] += 1;
after=(long int) NTKK(pap+1, j);
VECTOR(ntk)[pap+1] -= 1;
if (before == 0 && after > 0) {
MATRIX(ch, pap+1, j) = eptr_new;
MATRIX(ch, j, pap+1) = MATRIX(ch, pap+1, j);
}
}
VECTOR(ntk)[pap+1]+=1;
VECTOR(papers)[aut] += 1;
}
aptr += VECTOR(*eventsizes)[timestep];
/* For every new edge, we lose one connection possibility, also add the edges*/
eptr=eptr_save;
while (eptr < no_of_edges &&
VECTOR(*etime)[(long int) VECTOR(*etimeidx)[eptr] ] == timestep) {
long int edge=(long int) VECTOR(*etimeidx)[eptr];
long int from=IGRAPH_FROM(graph, edge), to=IGRAPH_TO(graph, edge);
long int xidx=VECTOR(papers)[from];
long int yidx=VECTOR(papers)[to];
MATRIX(ntkk, xidx, yidx) += 1;
MATRIX(ntkk, yidx, xidx) = MATRIX(ntkk, xidx, yidx);
if (NTKK(xidx, yidx)==0) {
MATRIX(*normfact, xidx, yidx) += eptr_new-MATRIX(ch, xidx, yidx);
MATRIX(*normfact, yidx, xidx) = MATRIX(*normfact, xidx, yidx);
}
VECTOR(added)[edge]=1;
eptr++;
}
}
for (i=0; i<maxpapers+1; i++) {
igraph_real_t oldakk;
long int j;
for (j=0; j<=i; j++) {
if (NTKK(i, j) != 0) {
MATRIX(*normfact, i, j) += (eptr-MATRIX(ch, i, j));
MATRIX(*normfact, j, i) = MATRIX(*normfact, i, j);
}
if (MATRIX(*normfact, i, j)==0) {
MATRIX(*kernel, i, j)=MATRIX(*kernel, j, i)=0;
MATRIX(*normfact, i, j)=MATRIX(*normfact, j, i)=1;
}
oldakk=MATRIX(*kernel, i, j);
MATRIX(*kernel, i, j) *= MATRIX(*notnull, i, j)/MATRIX(*normfact, i, j);
MATRIX(*kernel, j, i) = MATRIX(*kernel, i, j);
if (sd) {
MATRIX(*sd, i, j) += oldakk * oldakk * MATRIX(*notnull, i, j) *
(1-MATRIX(*notnull, i, j)/MATRIX(*normfact, i, j));
MATRIX(*sd, i, j) = sqrt(MATRIX(*sd, i, j)/(MATRIX(*normfact, i, j)-1));
MATRIX(*sd, j, i) = MATRIX(*sd, i, j);
}
}
}
if (!cites) {
igraph_matrix_destroy(notnull);
IGRAPH_FINALLY_CLEAN(1);
}
if (!norm) {
igraph_matrix_destroy(normfact);
IGRAPH_FINALLY_CLEAN(1);
}
igraph_matrix_destroy(&ch);
igraph_matrix_destroy(&ntkk);
igraph_vector_long_destroy(&ntk);
igraph_vector_char_destroy(&added);
igraph_vector_long_destroy(&papers);
IGRAPH_FINALLY_CLEAN(5);
return 0;
}
int igraph_local_scan_1_ecount_them(const igraph_t *us, const igraph_t *them,
igraph_vector_t *res,
const igraph_vector_t *weights_them,
igraph_neimode_t mode) {
int no_of_nodes=igraph_vcount(us);
igraph_adjlist_t adj_us;
igraph_inclist_t incs_them;
igraph_vector_int_t neis;
int node;
if (igraph_vcount(them) != no_of_nodes) {
IGRAPH_ERROR("Number of vertices must match in scan-1", IGRAPH_EINVAL);
}
if (igraph_is_directed(us) != igraph_is_directed(them)) {
IGRAPH_ERROR("Directedness must match in scan-1", IGRAPH_EINVAL);
}
if (weights_them &&
igraph_vector_size(weights_them) != igraph_ecount(them)) {
IGRAPH_ERROR("Invalid weight vector length in scan-1 (them)",
IGRAPH_EINVAL);
}
igraph_adjlist_init(us, &adj_us, mode);
IGRAPH_FINALLY(igraph_adjlist_destroy, &adj_us);
igraph_adjlist_simplify(&adj_us);
igraph_inclist_init(them, &incs_them, mode);
IGRAPH_FINALLY(igraph_inclist_destroy, &incs_them);
igraph_vector_int_init(&neis, no_of_nodes);
IGRAPH_FINALLY(igraph_vector_int_destroy, &neis);
igraph_vector_resize(res, no_of_nodes);
igraph_vector_null(res);
for (node=0; node < no_of_nodes; node++) {
igraph_vector_int_t *neis_us=igraph_adjlist_get(&adj_us, node);
igraph_vector_int_t *edges1_them=igraph_inclist_get(&incs_them, node);
int len1_us=igraph_vector_int_size(neis_us);
int len1_them=igraph_vector_int_size(edges1_them);
int i;
IGRAPH_ALLOW_INTERRUPTION();
/* Mark neighbors and self in us */
VECTOR(neis)[node] = node+1;
for (i = 0; i < len1_us; i++) {
int nei=VECTOR(*neis_us)[i];
VECTOR(neis)[nei] = node+1;
}
/* Crawl neighbors in them, first ego */
for (i = 0; i < len1_them; i++) {
int e=VECTOR(*edges1_them)[i];
int nei=IGRAPH_OTHER(them, e, node);
if (VECTOR(neis)[nei] == node+1) {
igraph_real_t w=weights_them ? VECTOR(*weights_them)[e] : 1;
VECTOR(*res)[node] += w;
}
}
/* Then the rest */
for (i = 0; i < len1_us; i++) {
int nei=VECTOR(*neis_us)[i];
igraph_vector_int_t *edges2_them=igraph_inclist_get(&incs_them, nei);
int j, len2_them=igraph_vector_int_size(edges2_them);
for (j = 0; j < len2_them; j++) {
int e2=VECTOR(*edges2_them)[j];
int nei2=IGRAPH_OTHER(them, e2, nei);
if (VECTOR(neis)[nei2] == node+1) {
igraph_real_t w=weights_them ? VECTOR(*weights_them)[e2] : 1;
VECTOR(*res)[node] += w;
}
}
}
/* For undirected, it was double counted */
if (mode == IGRAPH_ALL || ! igraph_is_directed(us)) {
VECTOR(*res)[node] /= 2.0;
}
} /* node < no_of_nodes */
igraph_vector_int_destroy(&neis);
igraph_inclist_destroy(&incs_them);
igraph_adjlist_destroy(&adj_us);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
int igraph_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;
}
