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 sc_cplx_cplx_mult(igraph_real_t lambda_real,
igraph_real_t lambda_imag,
const igraph_vector_t *v_real,
const igraph_vector_t *v_imag,
igraph_vector_t *res_real,
igraph_vector_t *res_imag) {
int r;
int n=igraph_vector_size(v_real);
if (igraph_vector_size(v_imag) != n) {
printf("Wrong vector sizes");
return 1;
}
igraph_vector_resize(res_real, n);
igraph_vector_resize(res_imag, n);
for (r=0; r<n; r++) {
VECTOR(*res_real)[r] = (lambda_real * VECTOR(*v_real)[r] -
lambda_imag * VECTOR(*v_imag)[r]);
VECTOR(*res_imag)[r] = (lambda_imag * VECTOR(*v_real)[r] +
lambda_real * VECTOR(*v_imag)[r]);
}
return 0;
}
int igraph_i_maximal_cliques_store_max_size(const igraph_vector_t* clique, void* data,
igraph_bool_t* cont) {
igraph_integer_t* result = (igraph_integer_t*)data;
if (*result < igraph_vector_size(clique))
*result = igraph_vector_size(clique);
return IGRAPH_SUCCESS;
}
int igraph_i_kleinberg2(igraph_real_t *to, const igraph_real_t *from,
long int n, void *extra) {
igraph_adjlist_t *in = ((igraph_i_kleinberg_data_t*)extra)->in;
igraph_adjlist_t *out = ((igraph_i_kleinberg_data_t*)extra)->out;
igraph_vector_t *tmp = ((igraph_i_kleinberg_data_t*)extra)->tmp;
igraph_vector_t *neis;
long int i, j, nlen;
for (i=0; i<n; i++) {
neis=igraph_adjlist_get(in, i);
nlen=igraph_vector_size(neis);
VECTOR(*tmp)[i]=0.0;
for (j=0; j<nlen; j++) {
long int nei=VECTOR(*neis)[j];
VECTOR(*tmp)[i] += from[nei];
}
}
for (i=0; i<n; i++) {
neis=igraph_adjlist_get(out, i);
nlen=igraph_vector_size(neis);
to[i]=0.0;
for (j=0; j<nlen; j++) {
long int nei=VECTOR(*neis)[j];
to[i] += VECTOR(*tmp)[nei];
}
}
return 0;
}
int igraph_i_largest_cliques_store(const igraph_vector_t* clique, void* data, igraph_bool_t* cont) {
igraph_vector_ptr_t* result = (igraph_vector_ptr_t*)data;
igraph_vector_t* vec;
long int i, n;
/* Is the current clique at least as large as the others that we have found? */
if (!igraph_vector_ptr_empty(result)) {
n = igraph_vector_size(clique);
if (n < igraph_vector_size(VECTOR(*result)[0]))
return IGRAPH_SUCCESS;
if (n > igraph_vector_size(VECTOR(*result)[0])) {
for (i = 0; i < igraph_vector_ptr_size(result); i++)
igraph_vector_destroy(VECTOR(*result)[i]);
igraph_vector_ptr_free_all(result);
igraph_vector_ptr_resize(result, 0);
}
}
vec = igraph_Calloc(1, igraph_vector_t);
if (vec == 0)
IGRAPH_ERROR("cannot allocate memory for storing next clique", IGRAPH_ENOMEM);
IGRAPH_CHECK(igraph_vector_copy(vec, clique));
IGRAPH_CHECK(igraph_vector_ptr_push_back(result, vec));
return IGRAPH_SUCCESS;
}
int igraph_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;
}
uint8_t cliques_overlap_cliques(cliques* c, int i, int j){
igraph_vector_t *i_clique, *j_clique;
uint8_t overlap_size = 0;
int node_it;
int clique_size;
i_clique = (igraph_vector_t*)VECTOR(c->plain_cliques_v_ptr)[i];
j_clique = (igraph_vector_t*)VECTOR(c->plain_cliques_v_ptr)[j];
if (i == j)
return igraph_vector_size(i_clique);
if( (igraph_vector_tail(i_clique) >= VECTOR(*j_clique)[0]) && (VECTOR(*i_clique)[0] <= igraph_vector_tail(j_clique))){
clique_size = igraph_vector_size(j_clique);
for (node_it = 0; node_it < clique_size; node_it++) {
if (VECTOR(*j_clique)[node_it] < VECTOR(*i_clique)[0])
// if the current node is lower than i_clique minimum node, then continue
continue;
if (VECTOR(*j_clique)[node_it] > igraph_vector_tail(i_clique))
// if the current node is greater than i_clique maximum node, than exit
break;
// search element node_it^th of j_clique within i_clique vector
if (igraph_vector_binsearch2(i_clique, VECTOR(*j_clique)[node_it]))
overlap_size++;
}
}
return overlap_size;
}
int real_cplx_mult(const igraph_matrix_t *A,
const igraph_vector_t *v_real,
const igraph_vector_t *v_imag,
igraph_vector_t *res_real,
igraph_vector_t *res_imag) {
int n=igraph_vector_size(v_real);
int r, c;
if (igraph_matrix_nrow(A) != n ||
igraph_matrix_ncol(A) != n ||
igraph_vector_size(v_imag) != n) {
printf("Wrong matrix or vector size");
return 1;
}
igraph_vector_resize(res_real, n);
igraph_vector_resize(res_imag, n);
for (r=0; r<n; r++) {
igraph_real_t s_real=0.0;
igraph_real_t s_imag=0.0;
for (c=0; c<n; c++) {
s_real += MATRIX(*A, r, c) * VECTOR(*v_real)[c];
s_imag += MATRIX(*A, r, c) * VECTOR(*v_imag)[c];
}
VECTOR(*res_real)[r]=s_real;
VECTOR(*res_imag)[r]=s_imag;
}
return 0;
}
void print_vector(igraph_vector_t *v, FILE *f) {
long int i;
for (i=0; i<igraph_vector_size(v)-1; i+=2) {
fprintf(f, "[\"%li\" , \"%li\" , \"\"] , ", (long int) VECTOR(*v)[i],(long int) VECTOR(*v)[i+1]);
}
fprintf(f, "[\"%li\" , \"%li\" , \"\"] ", (long int) VECTOR(*v)[igraph_vector_size(v)-2],(long int) VECTOR(*v)[igraph_vector_size(v)-1]);
fprintf(f, "\n");
}
int main() {
igraph_t g;
igraph_vector_t v, weights;
long int i;
igraph_real_t value;
igraph_arpack_options_t options;
igraph_star(&g, 100, IGRAPH_STAR_UNDIRECTED, 0);
igraph_arpack_options_init(&options);
igraph_vector_init(&v, 0);
igraph_eigenvector_centrality(&g, &v, &value, /*directed=*/ 0,
/*scale=*/0, /*weights=*/0,
&options);
if (options.info != 0) {
return 1;
}
for (i=0; i<igraph_vector_size(&v); i++) {
printf(" %.3f", fabs(VECTOR(v)[i]));
}
printf("\n");
igraph_destroy(&g);
/* Special cases: check for empty graph */
igraph_empty(&g, 10, 0);
igraph_eigenvector_centrality(&g, &v, &value, 0, 0, 0, &options);
if (value != 0.0) {
return 1;
}
for (i=0; i<igraph_vector_size(&v); i++) {
printf(" %.2f", fabs(VECTOR(v)[i]));
}
printf("\n");
igraph_destroy(&g);
/* Special cases: check for full graph, zero weights */
igraph_full(&g, 10, 0, 0);
igraph_vector_init(&weights, 45);
igraph_vector_fill(&weights, 0);
igraph_eigenvector_centrality(&g, &v, &value, 0, 0, &weights, &options);
igraph_vector_destroy(&weights);
if (value != 0.0) {
return 2;
}
for (i=0; i<igraph_vector_size(&v); i++) {
printf(" %.2f", fabs(VECTOR(v)[i]));
}
printf("\n");
igraph_destroy(&g);
igraph_vector_destroy(&v);
return 0;
}
int sort_cmp(const void *a, const void *b) {
const igraph_vector_t **da = (const igraph_vector_t **) a;
const igraph_vector_t **db = (const igraph_vector_t **) b;
int i, alen=igraph_vector_size(*da), blen=igraph_vector_size(*db);
if (alen != blen) { return (alen < blen) - (alen > blen); }
for (i=0; i<alen; i++) {
int ea=VECTOR(**da)[i], eb=VECTOR(**db)[i];
if (ea != eb) { return (ea > eb) - (ea < eb); }
}
return 0;
}
VALUE cIGraph_community_edge_betweenness(VALUE self, VALUE directed){
igraph_t *graph;
igraph_vector_t result_vec;
igraph_vector_t edge_betw_vec;
igraph_vector_t bridges_vec;
igraph_matrix_t *merges = malloc(sizeof(igraph_matrix_t));
igraph_bool_t directed_b = 0;
int i;
VALUE result_a, edge_betw_a, bridges_a, res;
if(directed)
directed_b = 1;
Data_Get_Struct(self, igraph_t, graph);
igraph_matrix_init(merges,0,0);
igraph_vector_init(&result_vec,0);
igraph_vector_init(&edge_betw_vec,0);
igraph_vector_init(&bridges_vec,0);
igraph_community_edge_betweenness(graph,
&result_vec,&edge_betw_vec,
merges,&bridges_vec,directed_b);
result_a = rb_ary_new();
for(i=0;i<igraph_vector_size(&result_vec);i++){
rb_ary_push(result_a,INT2NUM(VECTOR(result_vec)[i]));
}
edge_betw_a = rb_ary_new();
for(i=0;i<igraph_vector_size(&edge_betw_vec);i++){
rb_ary_push(edge_betw_a,INT2NUM(VECTOR(edge_betw_vec)[i]));
}
bridges_a = rb_ary_new();
for(i=0;i<igraph_vector_size(&bridges_vec);i++){
rb_ary_push(bridges_a,INT2NUM(VECTOR(bridges_vec)[i]));
}
res = rb_ary_new3(4,
Data_Wrap_Struct(cIGraphMatrix, 0,
cIGraph_matrix_free, merges),
result_a, edge_betw_a, bridges_a);
igraph_vector_destroy(&result_vec);
igraph_vector_destroy(&edge_betw_vec);
igraph_vector_destroy(&bridges_vec);
return res;
}
VALUE cIGraph_community_leading_eigenvector_naive(VALUE self, VALUE steps){
igraph_t *graph;
igraph_vector_t membership;
igraph_matrix_t *merges = malloc(sizeof(igraph_matrix_t));
igraph_arpack_options_t arpack_opt;
igraph_arpack_options_init(&arpack_opt);
int i,groupid,max_groupid;
VALUE groups, group, res;
Data_Get_Struct(self, igraph_t, graph);
igraph_matrix_init(merges,0,0);
igraph_vector_init(&membership,0);
igraph_community_leading_eigenvector_naive(graph,merges,&membership,
NUM2INT(steps), &arpack_opt);
max_groupid = 0;
for(i=0;i<igraph_vector_size(&membership);i++){
if(VECTOR(membership)[i] > max_groupid)
max_groupid = VECTOR(membership)[i];
}
groups = rb_ary_new();
for(i=0;i<max_groupid+1;i++){
rb_ary_push(groups,rb_ary_new());
}
for(i=0;i<igraph_vector_size(&membership);i++){
groupid = VECTOR(membership)[i];
if(groupid == -1)
groupid = 0;
group = RARRAY_PTR(groups)[groupid];
rb_ary_push(group,cIGraph_get_vertex_object(self, i));
}
res = rb_ary_new3(2,groups,
Data_Wrap_Struct(cIGraphMatrix, 0,
cIGraph_matrix_free, merges));
igraph_vector_destroy(&membership);
return res;
}
int main() {
igraph_t graph;
igraph_vector_t walk, weights;
igraph_integer_t ec, i;
igraph_rng_seed(igraph_rng_default(), 137);
igraph_vector_init(&walk, 0);
igraph_vector_init(&weights, 0);
/* This directed graph has loop edges.
It also has multi-edges when considered as undirected. */
igraph_de_bruijn(&graph, 3, 2);
ec = igraph_ecount(&graph);
/* unweighted, directed */
igraph_random_edge_walk(&graph, NULL, &walk, 0, IGRAPH_OUT, 1000, IGRAPH_RANDOM_WALK_STUCK_RETURN);
assert(igraph_vector_size(&walk) == 1000);
/* unweighted, undirected */
igraph_random_edge_walk(&graph, NULL, &walk, 0, IGRAPH_ALL, 1000, IGRAPH_RANDOM_WALK_STUCK_RETURN);
assert(igraph_vector_size(&walk) == 1000);
igraph_vector_resize(&weights, ec);
for (i=0; i < ec; ++i)
VECTOR(weights)[i] = igraph_rng_get_unif01(igraph_rng_default());
/* weighted, directed */
igraph_random_edge_walk(&graph, &weights, &walk, 0, IGRAPH_OUT, 1000, IGRAPH_RANDOM_WALK_STUCK_RETURN);
assert(igraph_vector_size(&walk) == 1000);
/* weighted, undirecetd */
igraph_random_edge_walk(&graph, &weights, &walk, 0, IGRAPH_ALL, 1000, IGRAPH_RANDOM_WALK_STUCK_RETURN);
assert(igraph_vector_size(&walk) == 1000);
igraph_destroy(&graph);
/* 1-vertex graph, should get stuck */
igraph_empty(&graph, 1, /* directed = */ 0);
igraph_random_edge_walk(&graph, NULL, &walk, 0, IGRAPH_OUT, 1000, IGRAPH_RANDOM_WALK_STUCK_RETURN);
assert(igraph_vector_size(&walk) == 0);
igraph_destroy(&graph);
igraph_vector_destroy(&weights);
igraph_vector_destroy(&walk);
return 0;
}
void vector_print(igraph_vector_t *v) {
long int i;
for (i=0; i<igraph_vector_size(v); i++) {
printf(" %li", (long int) VECTOR(*v)[i]);
}
printf("\n");
}
int igraph_2dgrid_init(igraph_2dgrid_t *grid, igraph_matrix_t *coords,
igraph_real_t minx, igraph_real_t maxx, igraph_real_t deltax,
igraph_real_t miny, igraph_real_t maxy, igraph_real_t deltay) {
long int i;
grid->coords=coords;
grid->minx=minx;
grid->maxx=maxx;
grid->deltax=deltax;
grid->miny=miny;
grid->maxy=maxy;
grid->deltay=deltay;
grid->stepsx=(long int) ceil((maxx-minx)/deltax);
grid->stepsy=(long int) ceil((maxy-miny)/deltay);
IGRAPH_CHECK(igraph_matrix_init(&grid->startidx,
grid->stepsx, grid->stepsy));
IGRAPH_FINALLY(igraph_matrix_destroy, &grid->startidx);
IGRAPH_VECTOR_INIT_FINALLY(&grid->next, igraph_matrix_nrow(coords));
IGRAPH_VECTOR_INIT_FINALLY(&grid->prev, igraph_matrix_nrow(coords));
for (i=0; i<igraph_vector_size(&grid->next); i++) {
VECTOR(grid->next)[i]=-1;
}
grid->massx=0;
grid->massy=0;
grid->vertices=0;
IGRAPH_FINALLY_CLEAN(3);
return 0;
}
static gboolean _tgengraph_hasSelfLoop(TGenGraph* g, igraph_integer_t vertexIndex) {
TGEN_ASSERT(g);
gboolean isLoop = FALSE;
igraph_vector_t* resultNeighborVertices = g_new0(igraph_vector_t, 1);
gint result = igraph_vector_init(resultNeighborVertices, 0);
if(result == IGRAPH_SUCCESS) {
result = igraph_neighbors(g->graph, resultNeighborVertices, vertexIndex, IGRAPH_OUT);
if(result == IGRAPH_SUCCESS) {
glong nVertices = igraph_vector_size(resultNeighborVertices);
for (gint i = 0; i < nVertices; i++) {
igraph_integer_t dstVertexIndex = igraph_vector_e(resultNeighborVertices, i);
if(vertexIndex == dstVertexIndex) {
isLoop = TRUE;
break;
}
}
}
}
igraph_vector_destroy(resultNeighborVertices);
g_free(resultNeighborVertices);
return isLoop;
}
/* call-seq:
* igraph.motifs_randesu(size,cut)
*
*/
VALUE cIGraph_motifs_randesu(VALUE self, VALUE size, VALUE cuts){
igraph_t *graph;
igraph_vector_t cutsv;
igraph_vector_t res;
int i;
VALUE hist = rb_ary_new();
Data_Get_Struct(self, igraph_t, graph);
igraph_vector_init(&res,0);
//Convert an array of vertices to a vector of vertex ids
igraph_vector_init(&cutsv,0);
for(i=0;i<RARRAY_LEN(cuts);i++){
igraph_vector_push_back(&cutsv,NUM2DBL(RARRAY_PTR(cuts)[i]));
}
igraph_motifs_randesu(graph,&res,NUM2INT(size),&cutsv);
for(i=0; i<igraph_vector_size(&res); i++){
rb_ary_push(hist,INT2NUM(VECTOR(res)[i]));
}
igraph_vector_destroy(&cutsv);
igraph_vector_destroy(&res);
return hist;
}
void print_vector(igraph_vector_t *v) {
long int i, n=igraph_vector_size(v);
for (i=0; i<n; i++) {
printf(" %g", VECTOR(*v)[i]);
}
printf("\n");
}
int check_ev(const igraph_matrix_t *A, const igraph_vector_t *values,
const igraph_matrix_t *vectors) {
int i, n=igraph_matrix_nrow(A);
int ne=igraph_matrix_ncol(vectors);
igraph_vector_t v, lhs, rhs;
if (ne != igraph_vector_size(values)) {
printf("'values' and 'vectors' sizes do not match\n");
exit(1);
}
igraph_vector_init(&lhs, n);
igraph_vector_init(&rhs, n);
for (i=0; i<ne; i++) {
igraph_vector_view(&v, &MATRIX(*vectors, 0, i), n);
igraph_blas_dgemv(/*transpose=*/ 0, /*alpha=*/ 1, A, &v,
/*beta=*/ 0, &lhs);
igraph_vector_update(&rhs, &v);
igraph_vector_scale(&rhs, VECTOR(*values)[i]);
if (igraph_vector_maxdifference(&lhs, &rhs) > 1e-10) {
printf("LHS: "); igraph_vector_print(&lhs);
printf("RHS: "); igraph_vector_print(&rhs);
exit(2);
}
}
igraph_vector_destroy(&rhs);
igraph_vector_destroy(&lhs);
return 0;
}
int main(void) {
igraph_real_t avg_path;
igraph_t graph;
igraph_vector_t dimvector;
igraph_vector_t edges;
int i;
igraph_vector_init(&dimvector, 2);
VECTOR(dimvector)[0]=30;
VECTOR(dimvector)[1]=30;
igraph_lattice(&graph, &dimvector, 0, IGRAPH_UNDIRECTED, 0, 1);
igraph_rng_seed(igraph_rng_default(), 42);
igraph_vector_init(&edges, 20);
for (i=0; i<igraph_vector_size(&edges); i++) {
VECTOR(edges)[i] = rand() % (int)igraph_vcount(&graph);
}
igraph_average_path_length(&graph, &avg_path, IGRAPH_UNDIRECTED, 1);
printf("Average path length (lattice): %f\n", (double) avg_path);
igraph_add_edges(&graph, &edges, 0);
igraph_average_path_length(&graph, &avg_path, IGRAPH_UNDIRECTED, 1);
printf("Average path length (randomized lattice): %f\n", (double) avg_path);
igraph_vector_destroy(&dimvector);
igraph_vector_destroy(&edges);
igraph_destroy(&graph);
return 0;
}
/* call-seq:
* graph.neighbours(vertex,mode) -> Array
*
* Returns an Array of the neighbouring vertices to vertex. mode defines
* the way adjacent vertices are searched for directed graphs. It can have
* the following values: IGraph::OUT, vertices reachable by an edge from the
* specified vertex are searched, IGraph::IN, vertices from which the
* specified vertex is reachable are searched. IGraph::ALL, both kind of
* vertices are searched. This parameter is ignored for undirected graphs.
*
* Example:
*
* g = IGraph.new([1,2,3,4],true)
* g.neighbours(1,IGraph::ALL) # returns [2]
*
*/
VALUE cIGraph_neighbors(VALUE self, VALUE v, VALUE mode){
igraph_t *graph;
igraph_integer_t pnode;
igraph_neimode_t pmode = NUM2INT(mode);
igraph_vector_t neis;
int i;
VALUE neighbors = rb_ary_new();
igraph_vector_init_int(&neis,0);
Data_Get_Struct(self, igraph_t, graph);
pnode = cIGraph_get_vertex_id(self,v);
igraph_neighbors(graph,&neis,pnode,pmode);
for(i=0;i<igraph_vector_size(&neis);i++){
rb_ary_push(neighbors,cIGraph_get_vertex_object(self,VECTOR(neis)[i]));
}
igraph_vector_destroy(&neis);
return neighbors;
}
/* call-seq:
* graph.adjacent(vertex,mode) -> Array
*
* Returns an Array of the adjacent edge ids to vertex. mode defines
* the way adjacent edges are searched for directed graphs. It can have
* the following values: IGraph::OUT means only outgoing edges, IGraph::IN
* only incoming edges, IGraph::ALL both. This parameter is ignored for
* undirected graphs.
*
* Example:
*
* g = IGraph.new([1,2,3,4],true)
* g.adjacent(1,IGraph::ALL) # returns [1]
*
*/
VALUE cIGraph_adjacent(VALUE self, VALUE v, VALUE mode){
igraph_t *graph;
igraph_integer_t pnode;
igraph_neimode_t pmode = NUM2INT(mode);
igraph_vector_t eids;
int i;
VALUE eids_r = rb_ary_new();
igraph_vector_init_int(&eids,0);
Data_Get_Struct(self, igraph_t, graph);
pnode = cIGraph_get_vertex_id(self,v);
igraph_adjacent(graph,&eids,pnode,pmode);
for(i=0;i<igraph_vector_size(&eids);i++){
rb_ary_push(eids_r,INT2NUM(VECTOR(eids)[i]));
}
igraph_vector_destroy(&eids);
return eids_r;
}
/* call-seq:
* graph.degree(vs,mode,loops) -> Array
*
* Returns an Array of Integers specifying the degree of each of the
* vertices specified in the vs Array. mode defines the type of the degree.
* IGraph::OUT, out-degree, IGraph::IN, in-degree, IGraph::ALL, total degree
* (sum of the in- and out-degree). This parameter is ignored for undirected
* graphs.
*
* Example:
*
* g = IGraph.new([1,2,3,4],true)
* g.is_directed? #returns true
*
*/
VALUE cIGraph_degree(VALUE self, VALUE v, VALUE mode, VALUE loops){
igraph_t *graph;
igraph_vs_t vids;
igraph_vector_t vidv;
igraph_neimode_t pmode = NUM2INT(mode);
igraph_bool_t loop_mode = loops ? 1 : 0;
igraph_vector_t res;
int i;
VALUE degree_r = rb_ary_new();
//vector to hold the results of the degree calculations
igraph_vector_init_int(&res,0);
Data_Get_Struct(self, igraph_t, graph);
//Convert an array of vertices to a vector of vertex ids
igraph_vector_init_int(&vidv,0);
cIGraph_vertex_arr_to_id_vec(self,v,&vidv);
//create vertex selector from the vecotr of ids
igraph_vs_vector(&vids,&vidv);
igraph_degree(graph,&res,vids,pmode,loop_mode);
for(i=0;i<igraph_vector_size(&res);i++){
rb_ary_push(degree_r,INT2NUM(VECTOR(res)[i]));
}
igraph_vector_destroy(&vidv);
igraph_vector_destroy(&res);
igraph_vs_destroy(&vids);
return degree_r;
}
VALUE cIGraph_community_fastgreedy(VALUE self){
igraph_t *graph;
igraph_vector_t modularity;
igraph_matrix_t *merges = malloc(sizeof(igraph_matrix_t));
int i;
VALUE modularity_a, res;
Data_Get_Struct(self, igraph_t, graph);
igraph_matrix_init(merges,0,0);
igraph_vector_init(&modularity,0);
igraph_community_fastgreedy(graph,NULL,
merges,&modularity);
modularity_a = rb_ary_new();
for(i=0;i<igraph_vector_size(&modularity);i++){
rb_ary_push(modularity_a,rb_float_new(VECTOR(modularity)[i]));
}
res = rb_ary_new3(2,
Data_Wrap_Struct(cIGraphMatrix, 0,
cIGraph_matrix_free, merges),
modularity_a);
igraph_vector_destroy(&modularity);
return res;
}
/* call-seq:
* graph.transitivity() -> Float
*
* Calculates the transitivity (clustering coefficient) of a graph.
*
* The transitivity measures the probability that two neighbors of a vertex
* are connected. More precisely this is the ratio of the triangles and
* connected triples in the graph, the result is a single real number or
* NaN (0/0) if there are no connected triples in the graph. Directed graphs
* are considered as undirected ones.
*/
VALUE cIGraph_transitivity_local(VALUE self, VALUE vs){
igraph_t *graph;
igraph_vs_t vids;
igraph_vector_t vidv;
igraph_vector_t res;
VALUE trans = rb_ary_new();
int i;
//vector to hold the results of the calculations
igraph_vector_init_int(&res,0);
//Convert an array of vertices to a vector of vertex ids
igraph_vector_init_int(&vidv,0);
cIGraph_vertex_arr_to_id_vec(self,vs,&vidv);
//create vertex selector from the vecotr of ids
igraph_vs_vector(&vids,&vidv);
Data_Get_Struct(self, igraph_t, graph);
igraph_transitivity_local_undirected(graph,&res,vids);
for(i=0;i<igraph_vector_size(&res);i++){
rb_ary_push(trans,rb_float_new(VECTOR(res)[i]));
}
igraph_vector_destroy(&vidv);
igraph_vector_destroy(&res);
igraph_vs_destroy(&vids);
return trans;
}
void print_vector(igraph_vector_t *v, FILE *f) {
long int i;
for (i=0; i<igraph_vector_size(v); i++) {
fprintf(f, " %4.2f", VECTOR(*v)[i]);
}
fprintf(f, "\n");
}
int igraph_adjlist_simplify(igraph_adjlist_t *al) {
long int i;
long int n=al->length;
igraph_vector_t mark;
IGRAPH_VECTOR_INIT_FINALLY(&mark, n);
for (i=0; i<n; i++) {
igraph_vector_t *v=&al->adjs[i];
long int j, l=igraph_vector_size(v);
VECTOR(mark)[i] = i+1;
for (j=0; j<l; /* nothing */) {
long int e=VECTOR(*v)[j];
if (VECTOR(mark)[e] != i+1) {
VECTOR(mark)[e]=i+1;
j++;
} else {
VECTOR(*v)[j] = igraph_vector_tail(v);
igraph_vector_pop_back(v);
l--;
}
}
}
igraph_vector_destroy(&mark);
IGRAPH_FINALLY_CLEAN(1);
return 0;
}
int print_vector(igraph_vector_t *v) {
long int i, l=igraph_vector_size(v);
for (i=0; i<l; i++) {
printf(" %li", (long int) VECTOR(*v)[i]);
}
printf("\n");
}
igraph_vector_t *igraph_lazy_adjlist_get_real(igraph_lazy_adjlist_t *al,
igraph_integer_t pno) {
long int no=pno;
int ret;
if (al->adjs[no] == 0) {
al->adjs[no] = igraph_Calloc(1, igraph_vector_t);
if (al->adjs[no] == 0) {
igraph_error("Lazy adjlist failed", __FILE__, __LINE__,
IGRAPH_ENOMEM);
}
ret=igraph_vector_init(al->adjs[no], 0);
if (ret != 0) {
igraph_error("", __FILE__, __LINE__, ret);
}
ret=igraph_neighbors(al->graph, al->adjs[no], no, al->mode);
if (ret != 0) {
igraph_error("", __FILE__, __LINE__, ret);
}
if (al->simplify == IGRAPH_SIMPLIFY) {
igraph_vector_t *v=al->adjs[no];
long int i, p=0, n=igraph_vector_size(v);
for (i=0; i<n; i++) {
if (VECTOR(*v)[i] != no &&
(i==n-1 || VECTOR(*v)[i+1] != VECTOR(*v)[i])) {
VECTOR(*v)[p]=VECTOR(*v)[i];
p++;
}
}
igraph_vector_resize(v, p);
}
}
return al->adjs[no];
}
