igraph_bool_t check_ev(const igraph_matrix_t *A,
const igraph_vector_t *values_real,
const igraph_vector_t *values_imag,
const igraph_matrix_t *vectors_left,
const igraph_matrix_t *vectors_right,
igraph_real_t tol) {
int n=igraph_matrix_nrow(A);
igraph_vector_t v_real, v_imag;
igraph_vector_t AV_real, AV_imag, lv_real, lv_imag;
igraph_vector_t null;
int i;
if (igraph_matrix_ncol(A) != n) { return 1; }
if (igraph_vector_size(values_real) != n) { return 1; }
if (igraph_vector_size(values_imag) != n) { return 1; }
if (igraph_matrix_nrow(vectors_left) != n) { return 1; }
if (igraph_matrix_ncol(vectors_left) != n) { return 1; }
if (igraph_matrix_nrow(vectors_right) != n) { return 1; }
if (igraph_matrix_ncol(vectors_right) != n) { return 1; }
igraph_vector_init(&AV_real, n);
igraph_vector_init(&AV_imag, n);
igraph_vector_init(&lv_real, n);
igraph_vector_init(&lv_imag, n);
igraph_vector_init(&null, n);
igraph_vector_null(&null);
for (i=0; i<n; i++) {
if (VECTOR(*values_imag)[i]==0.0) {
igraph_vector_view(&v_real, &MATRIX(*vectors_right, 0, i), n);
igraph_vector_view(&v_imag, VECTOR(null), n);
} else if (VECTOR(*values_imag)[i] > 0.0) {
igraph_vector_view(&v_real, &MATRIX(*vectors_right, 0, i), n);
igraph_vector_view(&v_imag, &MATRIX(*vectors_right, 0, i+1), n);
} else if (VECTOR(*values_imag)[i] < 0.0) {
igraph_vector_view(&v_real, &MATRIX(*vectors_right, 0, i-1), n);
igraph_vector_view(&v_imag, &MATRIX(*vectors_right, 0, i), n);
igraph_vector_scale(&v_imag, -1.0);
}
real_cplx_mult(A, &v_real, &v_imag, &AV_real, &AV_imag);
sc_cplx_cplx_mult(VECTOR(*values_real)[i], VECTOR(*values_imag)[i],
&v_real, &v_imag, &lv_real, &lv_imag);
if (igraph_vector_maxdifference(&AV_real, &lv_real) > tol ||
igraph_vector_maxdifference(&AV_imag, &lv_imag) > tol) {
igraph_vector_print(&AV_real); igraph_vector_print(&AV_imag);
igraph_vector_print(&lv_real); igraph_vector_print(&lv_imag);
return 1;
}
}
igraph_vector_destroy(&null);
igraph_vector_destroy(&AV_imag);
igraph_vector_destroy(&AV_real);
igraph_vector_destroy(&lv_imag);
igraph_vector_destroy(&lv_real);
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;
}
std::vector<double> Graph::betweenness() const {
igraph_vector_t results;
igraph_vs_t allnods;
std::vector<double> bet;
igraph_vector_init(&results, size);
igraph_vector_null(&results);
igraph_vs_all(&allnods);
igraph_betweenness(graph, &results, allnods, false);
bet.insert(bet.begin(), VECTOR(results), VECTOR(results) + size);
igraph_vector_destroy(&results);
igraph_vs_destroy(&allnods);
return bet;
}
std::vector<double> Graph::closeness() const {
igraph_vector_t results;
igraph_vs_t allnods;
std::vector<double> clos;
igraph_vector_init(&results, size);
igraph_vector_null(&results);
igraph_vs_all(&allnods);
igraph_closeness(graph, &results, allnods, IGRAPH_IN);
clos.insert(clos.begin(), VECTOR(results), VECTOR(results) + size);
igraph_vector_destroy(&results);
igraph_vs_destroy(&allnods);
return clos;
}
std::vector<int> Graph::degrees() {
igraph_vector_t results;
igraph_vs_t allnds;
std::vector<int> degs;
igraph_vs_all(&allnds);
igraph_vector_init(&results, size);
igraph_vector_null(&results);
igraph_degree(graph, &results, allnds, IGRAPH_ALL, IGRAPH_NO_LOOPS);
degs.insert(degs.begin(), VECTOR(results), VECTOR(results)+size);
igraph_vector_destroy(&results);
igraph_vs_destroy(&allnds);
return degs;
}
int igraph_i_create_start(igraph_vector_t *res, igraph_vector_t *el, igraph_vector_t *index,
igraph_integer_t nodes) {
# define EDGE(i) (VECTOR(*el)[ (long int) VECTOR(*index)[(i)] ])
long int no_of_nodes;
long int no_of_edges;
long int i, j, idx;
no_of_nodes=nodes;
no_of_edges=igraph_vector_size(el);
/* result */
IGRAPH_CHECK(igraph_vector_resize(res, nodes+1));
/* create the index */
if (igraph_vector_size(el)==0) {
/* empty graph */
igraph_vector_null(res);
} else {
idx=-1;
for (i=0; i<=EDGE(0); i++) {
idx++; VECTOR(*res)[idx]=0;
}
for (i=1; i<no_of_edges; i++) {
long int n=EDGE(i) - EDGE((long int)VECTOR(*res)[idx]);
for (j=0; j<n; j++) {
idx++; VECTOR(*res)[idx]=i;
}
}
j=EDGE((long int)VECTOR(*res)[idx]);
for (i=0; i<no_of_nodes-j; i++) {
idx++; VECTOR(*res)[idx]=no_of_edges;
}
}
/* clean */
# undef EDGE
return 0;
}
int igraph_i_eigen_matrix_sym_arpack_cb(igraph_real_t *to,
const igraph_real_t *from,
int n, void *extra) {
igraph_i_eigen_matrix_sym_arpack_data_t *data=
(igraph_i_eigen_matrix_sym_arpack_data_t *) extra;
if (data->A) {
igraph_blas_dgemv_array(/*transpose=*/ 0, /*alpha=*/ 1.0,
data->A, from, /*beta=*/ 0.0, to);
} else { /* data->sA */
igraph_vector_t vto, vfrom;
igraph_vector_view(&vto, to, n);
igraph_vector_view(&vfrom, to, n);
igraph_vector_null(&vto);
igraph_sparsemat_gaxpy(data->sA, &vfrom, &vto);
}
return 0;
}
int igraph_i_cliquer_histogram(const igraph_t *graph, igraph_vector_t *hist,
igraph_integer_t min_size, igraph_integer_t max_size)
{
graph_t *g;
int i;
igraph_integer_t vcount = igraph_vcount(graph);
if (vcount == 0) {
igraph_vector_clear(hist);
return IGRAPH_SUCCESS;
}
if (min_size <= 0) min_size = 1;
if (max_size <= 0) max_size = vcount; /* also used for initial hist vector size, do not set to zero */
if (max_size < min_size)
IGRAPH_ERROR("max_size must not be smaller than min_size", IGRAPH_EINVAL);
igraph_to_cliquer(graph, &g);
IGRAPH_FINALLY(graph_free, g);
igraph_vector_resize(hist, max_size);
igraph_vector_null(hist);
igraph_cliquer_opt.user_data = hist;
igraph_cliquer_opt.user_function = &count_cliques_callback;
CLIQUER_INTERRUPTABLE(clique_unweighted_find_all(g, min_size, max_size, /* maximal= */ FALSE, &igraph_cliquer_opt));
for (i=max_size; i > 0; --i)
if (VECTOR(*hist)[i-1] > 0)
break;
igraph_vector_resize(hist, i);
igraph_vector_resize_min(hist);
graph_free(g);
IGRAPH_FINALLY_CLEAN(1);
return IGRAPH_SUCCESS;
}
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;
}
/**
* \ingroup structural
* \function igraph_betweenness_estimate
* \brief Estimated betweenness centrality of some vertices.
*
* </para><para>
* The betweenness centrality of a vertex is the number of geodesics
* going through it. If there are more than one geodesic between two
* vertices, the value of these geodesics are weighted by one over the
* number of geodesics. When estimating betweenness centrality, igraph
* takes into consideration only those paths that are shorter than or
* equal to a prescribed length. Note that the estimated centrality
* will always be less than the real one.
*
* \param graph The graph object.
* \param res The result of the computation, a vector containing the
* estimated betweenness scores for the specified vertices.
* \param vids The vertices of which the betweenness centrality scores
* will be estimated.
* \param directed Logical, if true directed paths will be considered
* for directed graphs. It is ignored for undirected graphs.
* \param cutoff The maximal length of paths that will be considered.
* If zero or negative, the exact betweenness will be calculated
* (no upper limit on path lengths).
* \return Error code:
* \c IGRAPH_ENOMEM, not enough memory for
* temporary data.
* \c IGRAPH_EINVVID, invalid vertex id passed in
* \p vids.
*
* Time complexity: O(|V||E|),
* |V| and
* |E| are the number of vertices and
* edges in the graph.
* Note that the time complexity is independent of the number of
* vertices for which the score is calculated.
*
* \sa Other centrality types: \ref igraph_degree(), \ref igraph_closeness().
* See \ref igraph_edge_betweenness() for calculating the betweenness score
* of the edges in a graph.
*/
int igraph_betweenness_estimate(const igraph_t *graph, igraph_vector_t *res,
const igraph_vs_t vids, igraph_bool_t directed,
igraph_integer_t cutoff) {
long int no_of_nodes=igraph_vcount(graph);
igraph_dqueue_t q=IGRAPH_DQUEUE_NULL;
long int *distance;
long int *nrgeo;
double *tmpscore;
igraph_stack_t stack=IGRAPH_STACK_NULL;
long int source;
long int j, k;
igraph_integer_t modein, modeout;
igraph_vit_t vit;
igraph_vector_t *neis;
igraph_adjlist_t adjlist_out, adjlist_in;
igraph_adjlist_t *adjlist_out_p, *adjlist_in_p;
IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
directed=directed && igraph_is_directed(graph);
if (directed) {
modeout=IGRAPH_OUT;
modein=IGRAPH_IN;
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist_out, IGRAPH_OUT));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist_out);
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist_in, IGRAPH_IN));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist_in);
adjlist_out_p=&adjlist_out;
adjlist_in_p=&adjlist_in;
} else {
modeout=modein=IGRAPH_ALL;
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist_out, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist_out);
adjlist_out_p=adjlist_in_p=&adjlist_out;
}
distance=igraph_Calloc(no_of_nodes, long int);
if (distance==0) {
IGRAPH_ERROR("betweenness failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, distance);
nrgeo=igraph_Calloc(no_of_nodes, long int);
if (nrgeo==0) {
IGRAPH_ERROR("betweenness failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, nrgeo);
tmpscore=igraph_Calloc(no_of_nodes, double);
if (tmpscore==0) {
IGRAPH_ERROR("betweenness failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, tmpscore);
IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
igraph_stack_init(&stack, no_of_nodes);
IGRAPH_FINALLY(igraph_stack_destroy, &stack);
IGRAPH_CHECK(igraph_vector_resize(res, IGRAPH_VIT_SIZE(vit)));
igraph_vector_null(res);
/* here we go */
for (source=0; source<no_of_nodes; source++) {
IGRAPH_PROGRESS("Betweenness centrality: ", 100.0*source/no_of_nodes, 0);
IGRAPH_ALLOW_INTERRUPTION();
memset(distance, 0, no_of_nodes*sizeof(long int));
memset(nrgeo, 0, no_of_nodes*sizeof(long int));
memset(tmpscore, 0, no_of_nodes*sizeof(double));
igraph_stack_clear(&stack); /* it should be empty anyway... */
IGRAPH_CHECK(igraph_dqueue_push(&q, source));
nrgeo[source]=1;
distance[source]=0;
while (!igraph_dqueue_empty(&q)) {
long int actnode=igraph_dqueue_pop(&q);
if (cutoff > 0 && distance[actnode] >= cutoff) continue;
neis = igraph_adjlist_get(adjlist_out_p, actnode);
for (j=0; j<igraph_vector_size(neis); j++) {
long int neighbor=VECTOR(*neis)[j];
if (nrgeo[neighbor] != 0) {
/* we've already seen this node, another shortest path? */
if (distance[neighbor]==distance[actnode]+1) {
nrgeo[neighbor]+=nrgeo[actnode];
}
} else {
/* we haven't seen this node yet */
nrgeo[neighbor]+=nrgeo[actnode];
distance[neighbor]=distance[actnode]+1;
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
IGRAPH_CHECK(igraph_stack_push(&stack, neighbor));
}
}
} /* while !igraph_dqueue_empty */
/* Ok, we've the distance of each node and also the number of
shortest paths to them. Now we do an inverse search, starting
with the farthest nodes. */
while (!igraph_stack_empty(&stack)) {
long int actnode=igraph_stack_pop(&stack);
if (distance[actnode]<=1) { continue; } /* skip source node */
/* set the temporary score of the friends */
neis = igraph_adjlist_get(adjlist_in_p, actnode);
for (j=0; j<igraph_vector_size(neis); j++) {
long int neighbor=VECTOR(*neis)[j];
if (distance[neighbor]==distance[actnode]-1 && nrgeo[neighbor] != 0) {
tmpscore[neighbor] +=
(tmpscore[actnode]+1)*nrgeo[neighbor]/nrgeo[actnode];
}
}
}
/* Ok, we've the scores for this source */
for (k=0, IGRAPH_VIT_RESET(vit); !IGRAPH_VIT_END(vit);
IGRAPH_VIT_NEXT(vit), k++) {
long int node=IGRAPH_VIT_GET(vit);
VECTOR(*res)[k] += tmpscore[node];
tmpscore[node] = 0.0; /* in case a node is in vids multiple times */
}
} /* for source < no_of_nodes */
/* divide by 2 for undirected graph */
if (!directed) {
for (j=0; j<igraph_vector_size(res); j++) {
VECTOR(*res)[j] /= 2.0;
}
}
/* clean */
igraph_Free(distance);
igraph_Free(nrgeo);
igraph_Free(tmpscore);
igraph_dqueue_destroy(&q);
igraph_stack_destroy(&stack);
igraph_vit_destroy(&vit);
IGRAPH_FINALLY_CLEAN(6);
if (directed) {
igraph_adjlist_destroy(&adjlist_out);
igraph_adjlist_destroy(&adjlist_in);
IGRAPH_FINALLY_CLEAN(2);
} else {
igraph_adjlist_destroy(&adjlist_out);
IGRAPH_FINALLY_CLEAN(1);
}
return 0;
}
/*__________________________________________________________________________ MAIN CYCLE (FLTK CYCLE) ____*/
void mainidle_cb(void*){ //this routine updates the program.
//thus, it computes the EVOLUTION
double shooted;
double dens, err;
double totdens, toterr, totimerr;
char s[100];
// ---- running controls AND PRINTING
if(
(amstepping==0 && runningcontrol==1 && graphisloaded==1 && ticks<=maxtime ) ||
(amstepping==1 && runningcontrol==1 && graphisloaded==1 && ticks<=maxtime && tickstep<=step-1)
)
{
Evolution(deltat);
//PRINTS
if((int)printdatabutton->value()==1){
//if have steady state
if(usesteady==1){
igraph_matrix_t activation;
igraph_matrix_init(&activation,nodesnumber,totrun);
igraph_matrix_null(&activation);
igraph_vector_t correlation;
igraph_vector_init(&correlation,(nodesnumber*nodesnumber)); igraph_vector_null(&correlation);
fprintf(output1,"%i ", ticks);
fprintf(output2,"%i ", ticks);
fprintf(output5,"%i ", ticks);
fprintf(output6,"%i ", ticks);
totdens=0; toterr=0;
for(int i=0;i<nodesnumber;++i){
shooted=0;
dens=0;
err=0;
for(int j=0; j<totrun; ++j){
dens=dens+MATRIX(density,i,j);
err=err+((VECTOR(statstate)[i]-MATRIX(density,i,j))*(VECTOR(statstate)[i]-MATRIX(density,i,j)));
shooted=shooted+MATRIX(loss,i,j);
if(MATRIX(loss,i,j)!=0){++MATRIX(activation,i,j);}
}
dens=dens/totrun;
err=sqrt(err)/totrun;
shooted=shooted/totrun;
totdens=totdens+dens;
toterr=toterr+err;
fprintf(output1,"%f ",dens);
fprintf(output2,"%f ",err);
fprintf(output5,"%f ",shooted);
}
totdens=totdens/nodesnumber;
toterr=toterr/nodesnumber;
fprintf(output1,"%f ",totdens);
fprintf(output2,"%f ",toterr);
// printf("\n\n ACTIVATION MATRIX \n \n"); print_matrix_ur(&activation,stdout); printf("\n\n");
// ---- CORRELATION ---
igraph_vector_t meanactivation;
igraph_vector_init(&meanactivation,nodesnumber);
igraph_vector_null(&meanactivation);
//calculate mean activation
for (int j=0; j<totrun; ++j) {
for (int i=0; i<nodesnumber; ++i) {
VECTOR(meanactivation)[i]=VECTOR(meanactivation)[i]+MATRIX(activation,i,j);
}
}
igraph_vector_scale(&meanactivation,1./totrun);
//calculate actual correlation
for (int x=0; x<nodesnumber ; ++x) {
for(int y=0; y<nodesnumber; ++y){
double prod=0;
for (int j=0; j<totrun; ++j) {
prod=prod+ ( MATRIX(activation,x,j)*MATRIX(activation,y,j) );
}
prod=prod/totrun;
VECTOR(correlation)[(x*nodesnumber+y)] = prod - (VECTOR(meanactivation)[x]*VECTOR(meanactivation)[y]);
}
}
igraph_vector_destroy(&meanactivation);
for (int i=0; i<(nodesnumber*nodesnumber); ++i) {
fprintf(output6,"%f ",VECTOR(correlation)[i]);
}
//calculate error on run
igraph_matrix_t distl1; igraph_matrix_t distimel1;
igraph_matrix_init(&distl1,nodesnumber,totrun); igraph_matrix_init(&distimel1,nodesnumber,totrun);
igraph_matrix_null(&distl1); igraph_matrix_null(&distimel1);
igraph_vector_t rundistl1; igraph_vector_t rundistimel1;
igraph_vector_init(&rundistl1,totrun); igraph_vector_init(&rundistimel1,totrun);
igraph_vector_null(&rundistl1); igraph_vector_null(&rundistimel1);
toterr=0; totimerr=0;
//for every run
for(int j=0;j<totrun;++j){
//i evaluate the distance between the state and the stationary state (toterr) and the distance between old and new density (totimerr)
for(int i=0; i<nodesnumber; ++i)
{
//L1 DISTANCE WRT STATSTATE & DENSITY
MATRIX(distl1,i,j)=fabs(VECTOR(statstate)[i]-MATRIX(density,i,j));
//L1 DISTANCE WRT OLD DENSITY & DENSITY
MATRIX(distimel1,i,j)=fabs(MATRIX(densityold,i,j)-MATRIX(density,i,j));
}
}
igraph_matrix_rowsum(&distl1,&rundistl1); igraph_matrix_rowsum(&distimel1,&rundistimel1);
igraph_vector_scale(&rundistl1,(1./nodesnumber)); igraph_vector_scale(&rundistimel1,(1./nodesnumber));
toterr= (double)( igraph_vector_sum(&rundistl1) ) / (double)totrun ;
totimerr= (double)( igraph_vector_sum(&rundistimel1)) / (double)totrun;
igraph_vector_destroy(&rundistl1); igraph_vector_destroy(&rundistimel1);
igraph_matrix_destroy(&distl1); igraph_matrix_destroy(&distimel1);
fprintf(output2,"%f %f",toterr, totimerr);
fprintf(output1,"\n");
fprintf(output2,"\n");
fprintf(output5,"\n");
fprintf(output6,"\n");
//if i have BRIDGES ("clustered" graph), I print the traffic on the BRIDGES, using "output3" file
if(isclustered==1){
//for each bridge
fprintf(output3,"%i ",ticks);
for(int nbri=0; nbri<igraph_matrix_ncol(&bridgeslinks); ++nbri){
for(int i=0; i<igraph_matrix_nrow(&bridgeslinks);++i){
double tfl=0;
for(int j=0; j<totrun; ++j){
int beid;
beid=(int)MATRIX(bridgeslinks,i,nbri);
tfl=tfl+MATRIX(flux,beid,j);
}
fprintf(output3,"%f ",tfl);
}
}
fprintf(output3,"\n");
}
igraph_matrix_destroy(&activation);
igraph_vector_destroy(&correlation);
}
//if i HAVENT STEADY STATE
else {
fprintf(output1,"%i ", ticks);
fprintf(output5,"%i ", ticks);
for(int i=0;i<nodesnumber;++i){
shooted=0;
dens=0;
for(int j=0; j<totrun; ++j){
dens=dens+MATRIX(density,i,j);
shooted=shooted+MATRIX(loss,i,j);
}
dens=dens/totrun;
shooted=shooted/totrun;
fprintf(output1,"%f " ,dens);
fprintf(output5,"%f " ,shooted);
}
fprintf(output1,"\n");
fprintf(output5,"\n");
}
}
}
if((ticks==maxtime || tickstep==step) && runningcontrol==1){
run();
}
// ---- no graph loaded
if(graphisloaded==0 && rewrite==1) {
runbutton->deactivate();
sprintf(s,"No\nnetwork\nloaded");
databuff->text(s);
}
// ---- graph loaded
else {
runbutton->activate();
if(islattice==1 && rewrite==1){
if(istoro==1){
sprintf(s,"Nodes=%i\nToroidal\nLattice\n%iD Side=%i",nodesnumber, latticedim, latticeside);
}
else{
sprintf(s,"Nodes=%i\nLattice\n%iD Side=%i",nodesnumber, latticedim, latticeside);
}
databuff->text(s);
}
else if(rewrite==1){
sprintf(s,"Nodes=%i",nodesnumber);
databuff->text(s);
}
}
//have path
if(havepath==1 && rewrite==1){pathbuff->text(path); }
else if(havepath==0 && rewrite==1){pathbuff->text("No Path");}
if(error==1 && rewrite==1){
sprintf(s,errorstring);
databuff->text(s);
}
if (ticks<=maxtime){
scene->redraw();
datascene->redraw();
}
rewrite=0;
//Fl::repeat_timeout(1.0, mainidle_cb);
}
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;
}
igraph_vector_t * ggen_analyze_longest_path(igraph_t *g)
{
igraph_vector_t topology;
igraph_vector_t lengths;
igraph_vector_t preds;
igraph_vs_t vs;
igraph_vit_t vit;
igraph_vector_t *res = NULL;
int err;
unsigned long v,i,f,t;
long maxv;
if(g == NULL)
return NULL;
v = igraph_vcount(g);
err = igraph_vector_init(&topology,v);
if(err) return NULL;
err = igraph_vector_init(&lengths,v);
if(err) goto error_il;
err = igraph_vector_init(&preds,v);
if(err) goto error_ip;
res = malloc(sizeof(igraph_vector_t));
if(res == NULL) goto cleanup;
err = igraph_vector_init(res,v);
if(err) goto error_ir;
// sort topologically the vertices
err = igraph_topological_sorting(g,&topology,IGRAPH_OUT);
if(err) goto error;
// igraph is stupid, it returns 0 even if the graph isn't a dag
if(igraph_vector_size(&topology) != v)
goto error;
// find the best path incomming from every node
igraph_vector_null(&lengths);
igraph_vector_fill(&preds,-1);
maxv = -1;
for(i = 0; i < v; i++)
{
f = VECTOR(topology)[i];
err = igraph_vs_adj(&vs,f,IGRAPH_OUT);
if(err) goto error;
err = igraph_vit_create(g,vs,&vit);
if(err)
{
igraph_vs_destroy(&vs);
goto error;
}
for(vit; !IGRAPH_VIT_END(vit); IGRAPH_VIT_NEXT(vit))
{
t = IGRAPH_VIT_GET(vit);
if(VECTOR(lengths)[t] < VECTOR(lengths)[f] + 1)
{
VECTOR(lengths)[t] = VECTOR(lengths)[f] +1;
VECTOR(preds)[t] = f;
}
if(maxv == -1 || VECTOR(lengths)[t] > VECTOR(lengths)[maxv])
maxv = t;
}
igraph_vs_destroy(&vs);
igraph_vit_destroy(&vit);
}
// build the path, using preds and maxv
f = 0;
while(maxv != -1)
{
VECTOR(*res)[f++] = maxv;
maxv = VECTOR(preds)[maxv];
}
// finish the path correctly, resizing and reversing the array
err = igraph_vector_resize(res,f);
if(err) goto error;
err = igraph_vector_reverse(res);
if(err) goto error;
goto cleanup;
error:
igraph_vector_destroy(res);
error_ir:
free(res);
res = NULL;
cleanup:
igraph_vector_destroy(&preds);
error_ip:
igraph_vector_destroy(&lengths);
error_il:
igraph_vector_destroy(&topology);
return res;
}
/**
* \ingroup interface
* \function igraph_degree
* \brief The degree of some vertices in a graph.
*
* </para><para>
* This function calculates the in-, out- or total degree of the
* specified vertices.
* \param graph The graph.
* \param res Vector, this will contain the result. It should be
* initialized and will be resized to be the appropriate size.
* \param vids Vector, giving the vertex ids of which the degree will
* be calculated.
* \param mode Defines the type of the degree.
* \c IGRAPH_OUT, out-degree,
* \c IGRAPH_IN, in-degree,
* \c IGRAPH_ALL, total degree (sum of the
* in- and out-degree).
* This parameter is ignored for undirected graphs.
* \param loops Boolean, gives whether the self-loops should be
* counted.
* \return Error code:
* \c IGRAPH_EINVVID: invalid vertex id.
* \c IGRAPH_EINVMODE: invalid mode argument.
*
* Time complexity: O(v) if
* loops is
* TRUE, and
* O(v*d)
* otherwise. v is the number
* vertices for which the degree will be calculated, and
* d is their (average) degree.
*
* \sa \ref igraph_strength() for the version that takes into account
* edge weigths.
*/
int igraph_degree(const igraph_t *graph, igraph_vector_t *res,
const igraph_vs_t vids,
igraph_neimode_t mode, igraph_bool_t loops) {
long int nodes_to_calc;
long int i, j;
igraph_vit_t vit;
IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
if (mode != IGRAPH_OUT && mode != IGRAPH_IN && mode != IGRAPH_ALL) {
IGRAPH_ERROR("degree calculation failed", IGRAPH_EINVMODE);
}
nodes_to_calc=IGRAPH_VIT_SIZE(vit);
if (!igraph_is_directed(graph)) {
mode=IGRAPH_ALL;
}
IGRAPH_CHECK(igraph_vector_resize(res, nodes_to_calc));
igraph_vector_null(res);
if (loops) {
if (mode & IGRAPH_OUT) {
for (IGRAPH_VIT_RESET(vit), i=0;
!IGRAPH_VIT_END(vit);
IGRAPH_VIT_NEXT(vit), i++) {
long int vid=IGRAPH_VIT_GET(vit);
VECTOR(*res)[i] += (VECTOR(graph->os)[vid+1]-VECTOR(graph->os)[vid]);
}
}
if (mode & IGRAPH_IN) {
for (IGRAPH_VIT_RESET(vit), i=0;
!IGRAPH_VIT_END(vit);
IGRAPH_VIT_NEXT(vit), i++) {
long int vid=IGRAPH_VIT_GET(vit);
VECTOR(*res)[i] += (VECTOR(graph->is)[vid+1]-VECTOR(graph->is)[vid]);
}
}
} else { /* no loops */
if (mode & IGRAPH_OUT) {
for (IGRAPH_VIT_RESET(vit), i=0;
!IGRAPH_VIT_END(vit);
IGRAPH_VIT_NEXT(vit), i++) {
long int vid=IGRAPH_VIT_GET(vit);
VECTOR(*res)[i] += (VECTOR(graph->os)[vid+1]-VECTOR(graph->os)[vid]);
for (j=VECTOR(graph->os)[vid]; j<VECTOR(graph->os)[vid+1]; j++) {
if (VECTOR(graph->to)[ (long int)VECTOR(graph->oi)[j] ]==vid) {
VECTOR(*res)[i] -= 1;
}
}
}
}
if (mode & IGRAPH_IN) {
for (IGRAPH_VIT_RESET(vit), i=0;
!IGRAPH_VIT_END(vit);
IGRAPH_VIT_NEXT(vit), i++) {
long int vid=IGRAPH_VIT_GET(vit);
VECTOR(*res)[i] += (VECTOR(graph->is)[vid+1]-VECTOR(graph->is)[vid]);
for (j=VECTOR(graph->is)[vid]; j<VECTOR(graph->is)[vid+1]; j++) {
if (VECTOR(graph->from)[ (long int)VECTOR(graph->ii)[j] ]==vid) {
VECTOR(*res)[i] -= 1;
}
}
}
}
} /* loops */
igraph_vit_destroy(&vit);
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
/**
* \ingroup structural
* \function igraph_closeness_estimate
* \brief Closeness centrality estimations for some vertices.
*
* </para><para>
* The closeness centrality of a vertex measures how easily other
* vertices can be reached from it (or the other way: how easily it
* can be reached from the other vertices). It is defined as the
* number of the number of vertices minus one divided by the sum of the
* lengths of all geodesics from/to the given vertex. When estimating
* closeness centrality, igraph considers paths having a length less than
* or equal to a prescribed cutoff value.
*
* </para><para>
* If the graph is not connected, and there is no such path between two
* vertices, the number of vertices is used instead the length of the
* geodesic. This is always longer than the longest possible geodesic.
*
* </para><para>
* Since the estimation considers vertex pairs with a distance greater than
* the given value as disconnected, the resulting estimation will always be
* lower than the actual closeness centrality.
*
* \param graph The graph object.
* \param res The result of the computation, a vector containing the
* closeness centrality scores for the given vertices.
* \param vids Vector giving the vertices for which the closeness
* centrality scores will be computed.
* \param mode The type of shortest paths to be used for the
* calculation in directed graphs. Possible values:
* \clist
* \cli IGRAPH_OUT
* the lengths of the outgoing paths are calculated.
* \cli IGRAPH_IN
* the lengths of the incoming paths are calculated.
* \cli IGRAPH_ALL
* the directed graph is considered as an
* undirected one for the computation.
* \endclist
* \param cutoff The maximal length of paths that will be considered.
* If zero or negative, the exact closeness will be calculated
* (no upper limit on path lengths).
* \return Error code:
* \clist
* \cli IGRAPH_ENOMEM
* not enough memory for temporary data.
* \cli IGRAPH_EINVVID
* invalid vertex id passed.
* \cli IGRAPH_EINVMODE
* invalid mode argument.
* \endclist
*
* Time complexity: O(n|E|),
* n is the number
* of vertices for which the calculation is done and
* |E| is the number
* of edges in the graph.
*
* \sa Other centrality types: \ref igraph_degree(), \ref igraph_betweenness().
*/
int igraph_closeness_estimate(const igraph_t *graph, igraph_vector_t *res,
const igraph_vs_t vids, igraph_neimode_t mode,
igraph_integer_t cutoff) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_t already_counted, *neis;
long int i, j;
long int nodes_reached;
igraph_adjlist_t allneis;
igraph_dqueue_t q;
long int nodes_to_calc;
igraph_vit_t vit;
IGRAPH_CHECK(igraph_vit_create(graph, vids, &vit));
IGRAPH_FINALLY(igraph_vit_destroy, &vit);
nodes_to_calc=IGRAPH_VIT_SIZE(vit);
if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
mode != IGRAPH_ALL) {
IGRAPH_ERROR("calculating closeness", IGRAPH_EINVMODE);
}
IGRAPH_VECTOR_INIT_FINALLY(&already_counted, no_of_nodes);
IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
IGRAPH_CHECK(igraph_adjlist_init(graph, &allneis, mode));
IGRAPH_FINALLY(igraph_adjlist_destroy, &allneis);
IGRAPH_CHECK(igraph_vector_resize(res, nodes_to_calc));
igraph_vector_null(res);
for (IGRAPH_VIT_RESET(vit), i=0;
!IGRAPH_VIT_END(vit);
IGRAPH_VIT_NEXT(vit), i++) {
IGRAPH_CHECK(igraph_dqueue_push(&q, IGRAPH_VIT_GET(vit)));
IGRAPH_CHECK(igraph_dqueue_push(&q, 0));
nodes_reached=1;
VECTOR(already_counted)[(long int)IGRAPH_VIT_GET(vit)]=i+1;
IGRAPH_PROGRESS("Closeness: ", 100.0*i/no_of_nodes, NULL);
IGRAPH_ALLOW_INTERRUPTION();
while (!igraph_dqueue_empty(&q)) {
long int act=igraph_dqueue_pop(&q);
long int actdist=igraph_dqueue_pop(&q);
VECTOR(*res)[i] += actdist;
if (cutoff>0 && actdist>=cutoff) continue;
neis=igraph_adjlist_get(&allneis, act);
for (j=0; j<igraph_vector_size(neis); j++) {
long int neighbor=VECTOR(*neis)[j];
if (VECTOR(already_counted)[neighbor] == i+1) { continue; }
VECTOR(already_counted)[neighbor] = i+1;
nodes_reached++;
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
IGRAPH_CHECK(igraph_dqueue_push(&q, actdist+1));
}
}
VECTOR(*res)[i] += ((igraph_integer_t)no_of_nodes * (no_of_nodes-nodes_reached));
VECTOR(*res)[i] = (no_of_nodes-1) / VECTOR(*res)[i];
}
IGRAPH_PROGRESS("Closeness: ", 100.0, NULL);
/* Clean */
igraph_dqueue_destroy(&q);
igraph_vector_destroy(&already_counted);
igraph_vit_destroy(&vit);
igraph_adjlist_destroy(&allneis);
IGRAPH_FINALLY_CLEAN(4);
return 0;
}
int igraph_local_scan_k_ecount_them(const igraph_t *us, const igraph_t *them,
int k, igraph_vector_t *res,
const igraph_vector_t *weights_them,
igraph_neimode_t mode) {
int no_of_nodes=igraph_vcount(us);
int node;
igraph_dqueue_int_t Q;
igraph_vector_int_t marked;
igraph_stack_int_t ST;
igraph_inclist_t incs_us, incs_them;
if (igraph_vcount(them) != no_of_nodes) {
IGRAPH_ERROR("Number of vertices must match in scan-k", IGRAPH_EINVAL);
}
if (igraph_is_directed(us) != igraph_is_directed(them)) {
IGRAPH_ERROR("Directedness must match in scan-k", IGRAPH_EINVAL);
}
if (k < 0) {
IGRAPH_ERROR("k must be non-negative in k-scan", IGRAPH_EINVAL);
}
if (weights_them &&
igraph_vector_size(weights_them) != igraph_ecount(them)) {
IGRAPH_ERROR("Invalid weight vector length in k-scan (them)",
IGRAPH_EINVAL);
}
if (k==0) {
return igraph_local_scan_0_them(us, them, res, weights_them, mode);
}
if (k==1) {
return igraph_local_scan_1_ecount_them(us, them, res, weights_them, mode);
}
/* We mark the nodes in US in a BFS. Then we check the outgoing edges
of all marked nodes in THEM. */
IGRAPH_CHECK(igraph_dqueue_int_init(&Q, 100));
IGRAPH_FINALLY(igraph_dqueue_int_destroy, &Q);
IGRAPH_CHECK(igraph_vector_int_init(&marked, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_int_destroy, &marked);
IGRAPH_CHECK(igraph_inclist_init(us, &incs_us, mode));
IGRAPH_FINALLY(igraph_inclist_destroy, &incs_us);
IGRAPH_CHECK(igraph_inclist_init(them, &incs_them, mode));
IGRAPH_FINALLY(igraph_inclist_destroy, &incs_them);
IGRAPH_CHECK(igraph_stack_int_init(&ST, 100));
IGRAPH_FINALLY(igraph_stack_int_destroy, &ST);
IGRAPH_CHECK(igraph_vector_resize(res, no_of_nodes));
igraph_vector_null(res);
for (node=0; node < no_of_nodes; node++) {
/* BFS to mark the nodes in US */
IGRAPH_CHECK(igraph_dqueue_int_push(&Q, node));
IGRAPH_CHECK(igraph_dqueue_int_push(&Q, 0));
IGRAPH_CHECK(igraph_stack_int_push(&ST, node));
VECTOR(marked)[node] = node+1;
while (!igraph_dqueue_int_empty(&Q)) {
int act=igraph_dqueue_int_pop(&Q);
int dist=igraph_dqueue_int_pop(&Q) + 1;
igraph_vector_int_t *edges=igraph_inclist_get(&incs_us, act);
int i, edgeslen=igraph_vector_int_size(edges);
for (i=0; i<edgeslen; i++) {
int edge=VECTOR(*edges)[i];
int nei=IGRAPH_OTHER(us, edge, act);
if (dist <= k && VECTOR(marked)[nei] != node+1) {
igraph_dqueue_int_push(&Q, nei);
igraph_dqueue_int_push(&Q, dist);
VECTOR(marked)[nei] = node+1;
igraph_stack_int_push(&ST, nei);
}
}
}
/* Now check the edges of all nodes in THEM */
while (!igraph_stack_int_empty(&ST)) {
int act=igraph_stack_int_pop(&ST);
igraph_vector_int_t *edges=igraph_inclist_get(&incs_them, act);
int i, edgeslen=igraph_vector_int_size(edges);
for (i=0; i<edgeslen; i++) {
int edge=VECTOR(*edges)[i];
int nei=IGRAPH_OTHER(them, edge, act);
if (VECTOR(marked)[nei] == node+1) {
igraph_real_t w=weights_them ? VECTOR(*weights_them)[edge] : 1;
VECTOR(*res)[node] += w;
}
}
}
if (mode == IGRAPH_ALL || ! igraph_is_directed(us)) {
VECTOR(*res)[node] /= 2;
}
} /* node < no_of_nodes */
igraph_stack_int_destroy(&ST);
igraph_inclist_destroy(&incs_them);
igraph_inclist_destroy(&incs_us);
igraph_vector_int_destroy(&marked);
igraph_dqueue_int_destroy(&Q);
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_vector_order(const igraph_vector_t* v,
const igraph_vector_t *v2,
igraph_vector_t* res, igraph_real_t nodes) {
long int edges=igraph_vector_size(v);
igraph_vector_t ptr;
igraph_vector_t rad;
long int i, j;
assert(v!=NULL);
assert(v->stor_begin != NULL);
IGRAPH_VECTOR_INIT_FINALLY(&ptr, nodes+1);
IGRAPH_VECTOR_INIT_FINALLY(&rad, edges);
IGRAPH_CHECK(igraph_vector_resize(res, edges));
for (i=0; i<edges; i++) {
long int radix=v2->stor_begin[i];
if (VECTOR(ptr)[radix]!=0) {
VECTOR(rad)[i]=VECTOR(ptr)[radix];
}
VECTOR(ptr)[radix]=i+1;
}
j=0;
for (i=0; i<nodes+1; i++) {
if (VECTOR(ptr)[i] != 0) {
long int next=VECTOR(ptr)[i]-1;
res->stor_begin[j++]=next;
while (VECTOR(rad)[next] != 0) {
next=VECTOR(rad)[next]-1;
res->stor_begin[j++]=next;
}
}
}
igraph_vector_null(&ptr);
igraph_vector_null(&rad);
for (i=0; i<edges; i++) {
long int edge=VECTOR(*res)[edges-i-1];
long int radix=VECTOR(*v)[edge];
if (VECTOR(ptr)[radix]!= 0) {
VECTOR(rad)[edge]=VECTOR(ptr)[radix];
}
VECTOR(ptr)[radix]=edge+1;
}
j=0;
for (i=0; i<nodes+1; i++) {
if (VECTOR(ptr)[i] != 0) {
long int next=VECTOR(ptr)[i]-1;
res->stor_begin[j++]=next;
while (VECTOR(rad)[next] != 0) {
next=VECTOR(rad)[next]-1;
res->stor_begin[j++]=next;
}
}
}
igraph_vector_destroy(&ptr);
igraph_vector_destroy(&rad);
IGRAPH_FINALLY_CLEAN(2);
return 0;
}
int igraph_clusters_strong(const igraph_t *graph, igraph_vector_t *membership,
igraph_vector_t *csize, igraph_integer_t *no) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_t next_nei=IGRAPH_VECTOR_NULL;
long int i, n, num_seen;
igraph_dqueue_t q=IGRAPH_DQUEUE_NULL;
long int no_of_clusters=1;
long int act_cluster_size;
igraph_vector_t out=IGRAPH_VECTOR_NULL;
const igraph_vector_int_t* tmp;
igraph_adjlist_t adjlist;
/* The result */
IGRAPH_VECTOR_INIT_FINALLY(&next_nei, no_of_nodes);
IGRAPH_VECTOR_INIT_FINALLY(&out, 0);
IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
if (membership) {
IGRAPH_CHECK(igraph_vector_resize(membership, no_of_nodes));
}
IGRAPH_CHECK(igraph_vector_reserve(&out, no_of_nodes));
igraph_vector_null(&out);
if (csize) {
igraph_vector_clear(csize);
}
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_OUT));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
num_seen = 0;
for (i=0; i<no_of_nodes; i++) {
IGRAPH_ALLOW_INTERRUPTION();
tmp = igraph_adjlist_get(&adjlist, i);
if (VECTOR(next_nei)[i] > igraph_vector_int_size(tmp)) {
continue;
}
IGRAPH_CHECK(igraph_dqueue_push(&q, i));
while (!igraph_dqueue_empty(&q)) {
long int act_node=(long int) igraph_dqueue_back(&q);
tmp = igraph_adjlist_get(&adjlist, act_node);
if (VECTOR(next_nei)[act_node]==0) {
/* this is the first time we've met this vertex */
VECTOR(next_nei)[act_node]++;
} else if (VECTOR(next_nei)[act_node] <= igraph_vector_int_size(tmp)) {
/* we've already met this vertex but it has more children */
long int neighbor=(long int) VECTOR(*tmp)[(long int)
VECTOR(next_nei)[act_node]-1];
if (VECTOR(next_nei)[neighbor] == 0) {
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
}
VECTOR(next_nei)[act_node]++;
} else {
/* we've met this vertex and it has no more children */
IGRAPH_CHECK(igraph_vector_push_back(&out, act_node));
igraph_dqueue_pop_back(&q);
num_seen++;
if (num_seen % 10000 == 0) {
/* time to report progress and allow the user to interrupt */
IGRAPH_PROGRESS("Strongly connected components: ",
num_seen * 50.0 / no_of_nodes, NULL);
IGRAPH_ALLOW_INTERRUPTION();
}
}
} /* while q */
} /* for */
IGRAPH_PROGRESS("Strongly connected components: ", 50.0, NULL);
igraph_adjlist_destroy(&adjlist);
IGRAPH_FINALLY_CLEAN(1);
IGRAPH_CHECK(igraph_adjlist_init(graph, &adjlist, IGRAPH_IN));
IGRAPH_FINALLY(igraph_adjlist_destroy, &adjlist);
/* OK, we've the 'out' values for the nodes, let's use them in
decreasing order with the help of a heap */
igraph_vector_null(&next_nei); /* mark already added vertices */
num_seen = 0;
while (!igraph_vector_empty(&out)) {
long int grandfather=(long int) igraph_vector_pop_back(&out);
if (VECTOR(next_nei)[grandfather] != 0) { continue; }
VECTOR(next_nei)[grandfather]=1;
act_cluster_size=1;
if (membership) {
VECTOR(*membership)[grandfather]=no_of_clusters-1;
}
IGRAPH_CHECK(igraph_dqueue_push(&q, grandfather));
num_seen++;
if (num_seen % 10000 == 0) {
/* time to report progress and allow the user to interrupt */
IGRAPH_PROGRESS("Strongly connected components: ",
50.0 + num_seen * 50.0 / no_of_nodes, NULL);
IGRAPH_ALLOW_INTERRUPTION();
}
while (!igraph_dqueue_empty(&q)) {
long int act_node=(long int) igraph_dqueue_pop_back(&q);
tmp = igraph_adjlist_get(&adjlist, act_node);
n = igraph_vector_int_size(tmp);
for (i=0; i<n; i++) {
long int neighbor=(long int) VECTOR(*tmp)[i];
if (VECTOR(next_nei)[neighbor] != 0) { continue; }
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
VECTOR(next_nei)[neighbor]=1;
act_cluster_size++;
if (membership) {
VECTOR(*membership)[neighbor]=no_of_clusters-1;
}
num_seen++;
if (num_seen % 10000 == 0) {
/* time to report progress and allow the user to interrupt */
IGRAPH_PROGRESS("Strongly connected components: ",
50.0 + num_seen * 50.0 / no_of_nodes, NULL);
IGRAPH_ALLOW_INTERRUPTION();
}
}
}
no_of_clusters++;
if (csize) {
IGRAPH_CHECK(igraph_vector_push_back(csize, act_cluster_size));
}
}
IGRAPH_PROGRESS("Strongly connected components: ", 100.0, NULL);
if (no) { *no=(igraph_integer_t) no_of_clusters-1; }
/* Clean up, return */
igraph_adjlist_destroy(&adjlist);
igraph_vector_destroy(&out);
igraph_dqueue_destroy(&q);
igraph_vector_destroy(&next_nei);
IGRAPH_FINALLY_CLEAN(4);
return 0;
}
int igraph_local_scan_k_ecount(const igraph_t *graph, int k,
igraph_vector_t *res,
const igraph_vector_t *weights,
igraph_neimode_t mode) {
int no_of_nodes=igraph_vcount(graph);
int node;
igraph_dqueue_int_t Q;
igraph_vector_int_t marked;
igraph_inclist_t incs;
if (k < 0) {
IGRAPH_ERROR("k must be non-negative in k-scan", IGRAPH_EINVAL);
}
if (weights && igraph_vector_size(weights) != igraph_ecount(graph)) {
IGRAPH_ERROR("Invalid weight vector length in k-scan", IGRAPH_EINVAL);
}
if (k==0) { return igraph_local_scan_0(graph, res, weights, mode); }
if (k==1) { return igraph_local_scan_1_ecount(graph, res, weights, mode); }
/* We do a BFS form each node, and simply count the number
of edges on the way */
IGRAPH_CHECK(igraph_dqueue_int_init(&Q, 100));
IGRAPH_FINALLY(igraph_dqueue_int_destroy, &Q);
IGRAPH_CHECK(igraph_vector_int_init(&marked, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_int_destroy, &marked);
IGRAPH_CHECK(igraph_inclist_init(graph, &incs, mode));
IGRAPH_FINALLY(igraph_inclist_destroy, &incs);
IGRAPH_CHECK(igraph_vector_resize(res, no_of_nodes));
igraph_vector_null(res);
for (node=0 ; node < no_of_nodes ; node++) {
igraph_dqueue_int_push(&Q, node);
igraph_dqueue_int_push(&Q, 0);
VECTOR(marked)[node] = node+1;
while (!igraph_dqueue_int_empty(&Q)) {
int act=igraph_dqueue_int_pop(&Q);
int dist=igraph_dqueue_int_pop(&Q) + 1;
igraph_vector_int_t *edges=igraph_inclist_get(&incs, act);
int i, edgeslen=igraph_vector_int_size(edges);
for (i=0; i<edgeslen; i++) {
int edge=VECTOR(*edges)[i];
int nei=IGRAPH_OTHER(graph, edge, act);
if (dist <= k || VECTOR(marked)[nei] == node+1) {
igraph_real_t w=weights ? VECTOR(*weights)[edge] : 1;
VECTOR(*res)[node] += w;
}
if (dist <= k && VECTOR(marked)[nei] != node+1) {
igraph_dqueue_int_push(&Q, nei);
igraph_dqueue_int_push(&Q, dist);
VECTOR(marked)[nei] = node+1;
}
}
}
if (mode == IGRAPH_ALL || ! igraph_is_directed(graph)) {
VECTOR(*res)[node] /= 2.0;
}
} /* node < no_of_nodes */
igraph_inclist_destroy(&incs);
igraph_vector_int_destroy(&marked);
igraph_dqueue_int_destroy(&Q);
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
int main() {
igraph_t g;
igraph_matrix_t merges;
igraph_vector_t membership;
long int i, j;
igraph_bool_t split;
igraph_vector_t x;
igraph_real_t val;
igraph_arpack_options_t options;
/* Zachary Karate club */
igraph_small(&g, 0, IGRAPH_UNDIRECTED,
0, 1, 0, 2, 0, 3, 0, 4, 0, 5,
0, 6, 0, 7, 0, 8, 0, 10, 0, 11,
0, 12, 0, 13, 0, 17, 0, 19, 0, 21,
0, 31, 1, 2, 1, 3, 1, 7, 1, 13,
1, 17, 1, 19, 1, 21, 1, 30, 2, 3,
2, 7, 2, 8, 2, 9, 2, 13, 2, 27,
2, 28, 2, 32, 3, 7, 3, 12, 3, 13,
4, 6, 4, 10, 5, 6, 5, 10, 5, 16,
6, 16, 8, 30, 8, 32, 8, 33, 9, 33,
13, 33, 14, 32, 14, 33, 15, 32, 15, 33,
18, 32, 18, 33, 19, 33, 20, 32, 20, 33,
22, 32, 22, 33, 23, 25, 23, 27, 23, 29,
23, 32, 23, 33, 24, 25, 24, 27, 24, 31,
25, 31, 26, 29, 26, 33, 27, 33, 28, 31,
28, 33, 29, 32, 29, 33, 30, 32, 30, 33,
31, 32, 31, 33, 32, 33,
-1);
/* Make one step with all methods */
igraph_matrix_init(&merges, 0, 0);
igraph_vector_init(&membership, 0);
igraph_vector_init(&x, 0);
igraph_arpack_options_init(&options);
igraph_community_leading_eigenvector_naive(&g, &merges, &membership, 1, &options);
print_matrix(&merges);
print_vector(&membership);
igraph_community_leading_eigenvector(&g, &merges, &membership, 1, &options);
print_matrix(&merges);
print_vector(&membership);
igraph_vector_null(&membership);
igraph_community_leading_eigenvector_step(&g, &membership, 0, &split,
&x, &val, &options, 0);
print_vector(&membership);
print_vector(&x);
printf("\n");
/* Make all the steps */
igraph_community_leading_eigenvector(&g, &merges, &membership, igraph_vcount(&g),
&options);
print_matrix(&merges);
print_vector(&membership);
/* Try to make one more step from here, should fail */
for (i=0; i<igraph_matrix_nrow(&merges)+1; i++) {
igraph_community_leading_eigenvector_step(&g, &membership,
i, &split, &x, &val, &options, 0);
if (split) {
printf("Impossible, community %li splitted.\n", i);
return 1;
}
}
igraph_vector_destroy(&x);
igraph_vector_destroy(&membership);
igraph_matrix_destroy(&merges);
igraph_destroy(&g);
return 0;
}
int igraph_local_scan_neighborhood_ecount(const igraph_t *graph,
igraph_vector_t *res,
const igraph_vector_t *weights,
const igraph_vector_ptr_t *neighborhoods) {
int node, no_of_nodes=igraph_vcount(graph);
igraph_inclist_t incs;
igraph_vector_int_t marked;
igraph_bool_t directed=igraph_is_directed(graph);
if (weights && igraph_vector_size(weights) != igraph_ecount(graph)) {
IGRAPH_ERROR("Invalid weight vector length in local scan", IGRAPH_EINVAL);
}
if (igraph_vector_ptr_size(neighborhoods) != no_of_nodes) {
IGRAPH_ERROR("Invalid neighborhood list length in local scan",
IGRAPH_EINVAL);
}
IGRAPH_CHECK(igraph_vector_int_init(&marked, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_int_destroy, &marked);
IGRAPH_CHECK(igraph_inclist_init(graph, &incs, IGRAPH_OUT));
IGRAPH_FINALLY(igraph_inclist_destroy, &incs);
IGRAPH_CHECK(igraph_vector_resize(res, no_of_nodes));
igraph_vector_null(res);
for (node=0; node < no_of_nodes; node++) {
igraph_vector_int_t *nei=VECTOR(*neighborhoods)[node];
int i, neilen=igraph_vector_int_size(nei);
VECTOR(marked)[node] = node + 1;
for (i=0; i<neilen; i++) {
int vertex=VECTOR(*nei)[i];
if (vertex < 0 || vertex >= no_of_nodes) {
IGRAPH_ERROR("Invalid vertex id in neighborhood list in local scan",
IGRAPH_EINVAL);
}
VECTOR(marked)[vertex] = node + 1;
}
for (i=0; i<neilen; i++) {
int vertex=VECTOR(*nei)[i];
igraph_vector_int_t *edges=igraph_inclist_get(&incs, vertex);
int j, edgeslen=igraph_vector_int_size(edges);
for (j=0; j<edgeslen; j++) {
int edge=VECTOR(*edges)[j];
int nei2=IGRAPH_OTHER(graph, edge, vertex);
if (VECTOR(marked)[nei2] == node+1) {
igraph_real_t w = weights ? VECTOR(*weights)[edge] : 1;
VECTOR(*res)[node] += w;
}
}
}
if (!directed) { VECTOR(*res)[node] /= 2.0; }
}
igraph_inclist_destroy(&incs);
igraph_vector_int_destroy(&marked);
IGRAPH_FINALLY_CLEAN(2);
return 0;
}
/**
* \ingroup structural
* \function igraph_edge_betweenness_estimate
* \brief Estimated betweenness centrality of the edges.
*
* </para><para>
* The betweenness centrality of an edge is the number of geodesics
* going through it. If there are more than one geodesics between two
* vertices, the value of these geodesics are weighted by one over the
* number of geodesics. When estimating betweenness centrality, igraph
* takes into consideration only those paths that are shorter than or
* equal to a prescribed length. Note that the estimated centrality
* will always be less than the real one.
* \param graph The graph object.
* \param result The result of the computation, vector containing the
* betweenness scores for the edges.
* \param directed Logical, if true directed paths will be considered
* for directed graphs. It is ignored for undirected graphs.
* \param cutoff The maximal length of paths that will be considered.
* If zero or negative, the exact betweenness will be calculated
* (no upper limit on path lengths).
* \return Error code:
* \c IGRAPH_ENOMEM, not enough memory for
* temporary data.
*
* Time complexity: O(|V||E|),
* |V| and
* |E| are the number of vertices and
* edges in the graph.
*
* \sa Other centrality types: \ref igraph_degree(), \ref igraph_closeness().
* See \ref igraph_betweenness() for calculating the betweenness score
* of the vertices in a graph.
*/
int igraph_edge_betweenness_estimate(const igraph_t *graph, igraph_vector_t *result,
igraph_bool_t directed, igraph_integer_t cutoff) {
long int no_of_nodes=igraph_vcount(graph);
long int no_of_edges=igraph_ecount(graph);
igraph_dqueue_t q=IGRAPH_DQUEUE_NULL;
long int *distance;
long int *nrgeo;
double *tmpscore;
igraph_stack_t stack=IGRAPH_STACK_NULL;
long int source;
long int j;
igraph_adjedgelist_t elist_out, elist_in;
igraph_adjedgelist_t *elist_out_p, *elist_in_p;
igraph_vector_t *neip;
long int neino;
long int i;
igraph_integer_t modein, modeout;
directed=directed && igraph_is_directed(graph);
if (directed) {
modeout=IGRAPH_OUT;
modein=IGRAPH_IN;
IGRAPH_CHECK(igraph_adjedgelist_init(graph, &elist_out, IGRAPH_OUT));
IGRAPH_FINALLY(igraph_adjedgelist_destroy, &elist_out);
IGRAPH_CHECK(igraph_adjedgelist_init(graph, &elist_in, IGRAPH_IN));
IGRAPH_FINALLY(igraph_adjedgelist_destroy, &elist_in);
elist_out_p=&elist_out;
elist_in_p=&elist_in;
} else {
modeout=modein=IGRAPH_ALL;
IGRAPH_CHECK(igraph_adjedgelist_init(graph,&elist_out, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjedgelist_destroy, &elist_out);
elist_out_p=elist_in_p=&elist_out;
}
distance=igraph_Calloc(no_of_nodes, long int);
if (distance==0) {
IGRAPH_ERROR("edge betweenness failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, distance);
nrgeo=igraph_Calloc(no_of_nodes, long int);
if (nrgeo==0) {
IGRAPH_ERROR("edge betweenness failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, nrgeo);
tmpscore=igraph_Calloc(no_of_nodes, double);
if (tmpscore==0) {
IGRAPH_ERROR("edge betweenness failed", IGRAPH_ENOMEM);
}
IGRAPH_FINALLY(igraph_free, tmpscore);
IGRAPH_DQUEUE_INIT_FINALLY(&q, 100);
IGRAPH_CHECK(igraph_stack_init(&stack, no_of_nodes));
IGRAPH_FINALLY(igraph_stack_destroy, &stack);
IGRAPH_CHECK(igraph_vector_resize(result, no_of_edges));
igraph_vector_null(result);
/* here we go */
for (source=0; source<no_of_nodes; source++) {
IGRAPH_PROGRESS("Edge betweenness centrality: ", 100.0*source/no_of_nodes, 0);
IGRAPH_ALLOW_INTERRUPTION();
memset(distance, 0, no_of_nodes*sizeof(long int));
memset(nrgeo, 0, no_of_nodes*sizeof(long int));
memset(tmpscore, 0, no_of_nodes*sizeof(double));
igraph_stack_clear(&stack); /* it should be empty anyway... */
IGRAPH_CHECK(igraph_dqueue_push(&q, source));
nrgeo[source]=1;
distance[source]=0;
while (!igraph_dqueue_empty(&q)) {
long int actnode=igraph_dqueue_pop(&q);
if (cutoff > 0 && distance[actnode] >= cutoff ) continue;
neip=igraph_adjedgelist_get(elist_out_p, actnode);
neino=igraph_vector_size(neip);
for (i=0; i<neino; i++) {
igraph_integer_t edge=VECTOR(*neip)[i], from, to;
long int neighbor;
igraph_edge(graph, edge, &from, &to);
neighbor = actnode!=from ? from : to;
if (nrgeo[neighbor] != 0) {
/* we've already seen this node, another shortest path? */
if (distance[neighbor]==distance[actnode]+1) {
nrgeo[neighbor]+=nrgeo[actnode];
}
} else {
/* we haven't seen this node yet */
nrgeo[neighbor]+=nrgeo[actnode];
distance[neighbor]=distance[actnode]+1;
IGRAPH_CHECK(igraph_dqueue_push(&q, neighbor));
IGRAPH_CHECK(igraph_stack_push(&stack, neighbor));
}
}
} /* while !igraph_dqueue_empty */
/* Ok, we've the distance of each node and also the number of
shortest paths to them. Now we do an inverse search, starting
with the farthest nodes. */
while (!igraph_stack_empty(&stack)) {
long int actnode=igraph_stack_pop(&stack);
if (distance[actnode]<1) { continue; } /* skip source node */
/* set the temporary score of the friends */
neip=igraph_adjedgelist_get(elist_in_p, actnode);
neino=igraph_vector_size(neip);
for (i=0; i<neino; i++) {
igraph_integer_t from, to;
long int neighbor;
long int edgeno=VECTOR(*neip)[i];
igraph_edge(graph, edgeno, &from, &to);
neighbor= actnode != from ? from : to;
if (distance[neighbor]==distance[actnode]-1 &&
nrgeo[neighbor] != 0) {
tmpscore[neighbor] +=
(tmpscore[actnode]+1)*nrgeo[neighbor]/nrgeo[actnode];
VECTOR(*result)[edgeno] +=
(tmpscore[actnode]+1)*nrgeo[neighbor]/nrgeo[actnode];
}
}
}
/* Ok, we've the scores for this source */
} /* for source <= no_of_nodes */
IGRAPH_PROGRESS("Edge betweenness centrality: ", 100.0, 0);
/* clean and return */
igraph_Free(distance);
igraph_Free(nrgeo);
igraph_Free(tmpscore);
igraph_dqueue_destroy(&q);
igraph_stack_destroy(&stack);
IGRAPH_FINALLY_CLEAN(5);
if (directed) {
igraph_adjedgelist_destroy(&elist_out);
igraph_adjedgelist_destroy(&elist_in);
IGRAPH_FINALLY_CLEAN(2);
} else {
igraph_adjedgelist_destroy(&elist_out);
IGRAPH_FINALLY_CLEAN(1);
}
/* divide by 2 for undirected graph */
if (!directed || !igraph_is_directed(graph)) {
for (j=0; j<igraph_vector_size(result); j++) {
VECTOR(*result)[j] /= 2.0;
}
}
return 0;
}
