int main() {
  
  igraph_matrix_t A;
  igraph_vector_t values;
  igraph_matrix_t vectors;
  int i, j;
  igraph_eigen_which_t which;

  igraph_rng_seed(igraph_rng_default(), 42 * 42);
  
  igraph_matrix_init(&A, DIM, DIM);
  igraph_matrix_init(&vectors, 0, 0);
  igraph_vector_init(&values, 0);

  /* All eigenvalues and eigenvectors */

  for (i=0; i<DIM; i++) {
    for (j=i; j<DIM; j++) {
      MATRIX(A, i, j) = MATRIX(A, j, i) = 
	igraph_rng_get_integer(igraph_rng_default(), 1, 10);
    }
  }

  which.pos=IGRAPH_EIGEN_LM;
  which.howmany=5;
  igraph_eigen_matrix_symmetric(&A, /*sA=*/ 0, /*fun=*/ 0, DIM, /*extra=*/ 0,
				IGRAPH_EIGEN_LAPACK, &which, /*options=*/ 0,
				/*storage=*/ 0, &values, &vectors);
  igraph_vector_print(&values);
  check_ev(&A, &values, &vectors);

  which.howmany=8;
  igraph_eigen_matrix_symmetric(&A, /*sA=*/ 0, /*fun=*/ 0, DIM, /*extra=*/ 0,
				IGRAPH_EIGEN_LAPACK, &which, /*options=*/ 0,
				/*storage=*/ 0, &values, &vectors);
  igraph_vector_print(&values);
  check_ev(&A, &values, &vectors);

  which.pos=IGRAPH_EIGEN_BE;
  which.howmany=5;
  igraph_eigen_matrix_symmetric(&A, /*sA=*/ 0, /*fun=*/ 0, DIM, /*extra=*/ 0,
				IGRAPH_EIGEN_LAPACK, &which, /*options=*/ 0,
				/*storage=*/ 0, &values, &vectors);
  igraph_vector_print(&values);
  check_ev(&A, &values, &vectors);

  which.pos=IGRAPH_EIGEN_SM;
  which.howmany=5;
  igraph_eigen_matrix_symmetric(&A, /*sA=*/ 0, /*fun=*/ 0, DIM, /*extra=*/ 0,
				IGRAPH_EIGEN_LAPACK, &which, /*options=*/ 0,
				/*storage=*/ 0, &values, &vectors);
  igraph_vector_print(&values);
  check_ev(&A, &values, &vectors);
  
  igraph_vector_destroy(&values);
  igraph_matrix_destroy(&vectors);
  igraph_matrix_destroy(&A);  

  return 0;
}
int main() {
  igraph_t small, big;
  igraph_matrix_t small_coords, big_coords, merged_coords;
  igraph_vector_ptr_t graph_ptr, coords_ptr;
  igraph_arpack_options_t arpack_opts;

  /* To make things reproducible */
  igraph_rng_seed(igraph_rng_default(), 42);
  
  igraph_small(&big, 10, IGRAPH_UNDIRECTED, 
	       0,1, 1,2, 2,3, 3,4, 4,5, 5,6, 6,7, 7,8, 8,9, 9,0,
	       -1);
  
  igraph_small(&small, 3, IGRAPH_UNDIRECTED,
	       0,1, 1,2, 2,0,
	       -1);

  igraph_arpack_options_init(&arpack_opts);

  igraph_matrix_init(&big_coords, 0, 0);
  igraph_layout_mds(&big, &big_coords, /*dist=*/ 0, /*dim=*/ 2,
		    &arpack_opts);
  
  igraph_matrix_init(&small_coords, 0, 0);
  igraph_layout_mds(&small, &small_coords, /*dist=*/ 0, /*dim=*/ 2,
		    &arpack_opts);
  
  igraph_vector_ptr_init(&graph_ptr, 2);
  igraph_vector_ptr_init(&coords_ptr, 2);
  igraph_matrix_init(&merged_coords, 0, 0);
  VECTOR(graph_ptr)[0] = &big; 
  VECTOR(graph_ptr)[1] = &small;
  VECTOR(coords_ptr)[0] = &big_coords;
  VECTOR(coords_ptr)[1] = &small_coords;
  
  igraph_layout_merge_dla(&graph_ptr, &coords_ptr, &merged_coords);
  
  igraph_matrix_print(&merged_coords);
  
  igraph_matrix_destroy(&merged_coords);
  igraph_matrix_destroy(&small_coords);
  igraph_matrix_destroy(&big_coords);
  igraph_vector_ptr_destroy(&graph_ptr);
  igraph_vector_ptr_destroy(&coords_ptr);
  igraph_destroy(&small);
  igraph_destroy(&big);
  
#ifdef __APPLE__
  return 0;
#else
  return 77;
#endif
}
int main () {
  long int i; 
  igraph_matrix_t m;
  igraph_real_t x, y, z, r;

  srand(time(0));

  /* 2D */
  igraph_matrix_init(&m, 1000, 2);
  for (i=0; i<igraph_matrix_nrow(&m); i++) {
    MATRIX(m,i,0)=rand()/(double)RAND_MAX;
    MATRIX(m,i,1)=rand()/(double)RAND_MAX;
  }
  igraph_i_layout_sphere_2d(&m, &x, &y, &r);
  
  for (i=0; i<igraph_matrix_nrow(&m); i++) {
    igraph_real_t dist=sqrt((MATRIX(m,i,0)-x)*(MATRIX(m,i,0)-x) + 
		     (MATRIX(m,i,1)-y)*(MATRIX(m,i,1)-y));
    if (dist > r) {
      printf("x: %f y: %f r: %f\n", x, y, r);
      printf("x: %f y: %f dist: %f (%li)\n", 
	     MATRIX(m,i,0), MATRIX(m,i,1), dist, i);
      return 1;
    }
  }
  igraph_matrix_destroy(&m);

  /* 3D */
  igraph_matrix_init(&m, 1000, 3);
  for (i=0; i<igraph_matrix_nrow(&m); i++) {
    MATRIX(m,i,0)=rand()/(double)RAND_MAX;
    MATRIX(m,i,1)=rand()/(double)RAND_MAX;
    MATRIX(m,i,2)=rand()/(double)RAND_MAX;
  }
  igraph_i_layout_sphere_3d(&m, &x, &y, &z, &r);
  
  for (i=0; i<igraph_matrix_nrow(&m); i++) {
    igraph_real_t dist=sqrt((MATRIX(m,i,0)-x)*(MATRIX(m,i,0)-x) + 
		     (MATRIX(m,i,1)-y)*(MATRIX(m,i,1)-y) +
		     (MATRIX(m,i,2)-z)*(MATRIX(m,i,2)-z));
    if (dist > r) {
      printf("x: %f y: %f z: %f r: %f\n", x, y, z, r);
      printf("x: %f y: %f z: %f dist: %f (%li)\n", 
	     MATRIX(m,i,0), MATRIX(m,i,1), MATRIX(m,i,2), dist, i);
      return 1;
    }
  }
  igraph_matrix_destroy(&m);

  

  return 0;
}
int main() {
  
  igraph_matrix_t A;
  igraph_matrix_t vectors_left, vectors_right;
  igraph_vector_t values_real, values_imag;
  int i, j;
  int info=1;
  int ilo, ihi;
  igraph_real_t abnrm;
  
  igraph_rng_seed(igraph_rng_default(), 42);
  
  igraph_matrix_init(&A, DIM, DIM);
  igraph_matrix_init(&vectors_left, 0, 0);
  igraph_matrix_init(&vectors_right, 0, 0);
  igraph_vector_init(&values_real, 0);
  igraph_vector_init(&values_imag, 0);

  for (i=0; i<DIM; i++) {
    for (j=0; j<DIM; j++) {
      MATRIX(A, i, j) = igraph_rng_get_integer(igraph_rng_default(), 1, 10);
    }
  }
  
  igraph_lapack_dgeevx(IGRAPH_LAPACK_DGEEVX_BALANCE_BOTH,
		       &A, &values_real, &values_imag, 
		       &vectors_left, &vectors_right, &ilo, &ihi,
		       /*scale=*/ 0, &abnrm, /*rconde=*/ 0, 
		       /*rcondv=*/ 0, &info);

  if (check_ev(&A, &values_real, &values_imag, 
	       &vectors_left, &vectors_right, /*tol=*/ 1e-8)) {
    return 1;
  }
  
  /* igraph_matrix_print(&A); */
  /* igraph_vector_print(&values_real); */
  /* igraph_vector_print(&values_imag); */
  /* igraph_matrix_print(&vectors_left); */
  /* igraph_matrix_print(&vectors_right); */
  
  igraph_vector_destroy(&values_imag);
  igraph_vector_destroy(&values_real);
  igraph_matrix_destroy(&vectors_right);
  igraph_matrix_destroy(&vectors_left);
  igraph_matrix_destroy(&A);

  return 0;
}
/* call-seq:
 *   graph.get_adjacency(type) -> Array
 *
 * Returns the adjacency matrix of a graph
 *
 */
VALUE cIGraph_get_adjacency(VALUE self, VALUE mode){

  igraph_t *graph;
  igraph_get_adjacency_t pmode = NUM2INT(mode);
  igraph_matrix_t res;
  int i;
  int j;
  VALUE row;
  VALUE path_length;
  VALUE matrix = rb_ary_new();
  int n;

  Data_Get_Struct(self, igraph_t, graph);

  n = igraph_vcount(graph);

  //matrix to hold the results of the calculations
  igraph_matrix_init(&res,n,n);

  igraph_get_adjacency(graph,&res,pmode);

  for(i=0; i<igraph_matrix_nrow(&res); i++){
    row = rb_ary_new();
    rb_ary_push(matrix,row);
    for(j=0; j<igraph_matrix_ncol(&res); j++){
      path_length = INT2NUM(MATRIX(res,i,j));
      rb_ary_push(row,path_length);
    }
  }

  igraph_matrix_destroy(&res);

  return matrix;

}
int main() {
  
  const int nodes=10, skip=3;
  igraph_matrix_t mat2;
  igraph_vector_complex_t values, values2;
  igraph_matrix_complex_t vectors, vectors2;
  igraph_eigen_which_t which;
  int i;

  igraph_rng_seed(igraph_rng_default(), 42);
  igraph_matrix_init(&mat2, nodes, nodes);
  for (i=0; i<nodes; i++) {
    int j;
    for (j=0; j<nodes; j++) {
      MATRIX(mat2, i, j) = igraph_rng_get_integer(igraph_rng_default(), 1, 10);
    }
  }

  igraph_vector_complex_init(&values, 0);
  igraph_matrix_complex_init(&vectors, 0, 0);
  which.pos=IGRAPH_EIGEN_LI;
  which.howmany=nodes;
  igraph_eigen_matrix(&mat2, /*sparsemat=*/ 0, /*fun=*/ 0, nodes, 
		      /*extra=*/ 0, IGRAPH_EIGEN_LAPACK, &which,
		      /*options=*/ 0, /*storage=*/ 0, &values, &vectors);
  
  igraph_vector_complex_init(&values2, 0);
  igraph_matrix_complex_init(&vectors2, 0, 0);
  which.pos=IGRAPH_EIGEN_SI;
  which.howmany=nodes;
  igraph_eigen_matrix(&mat2, /*sparsemat=*/ 0, /*fun=*/ 0, nodes, 
		      /*extra=*/ 0, IGRAPH_EIGEN_LAPACK, &which, 
		      /*options=*/ 0, /*storage=*/ 0, &values2, &vectors2);

  igraph_vector_complex_print(&values);
  igraph_vector_complex_print(&values2);

  for (i=0; i<nodes; i++) { 
    int j;
    igraph_real_t d=
      igraph_complex_abs(igraph_complex_sub(VECTOR(values)[i],
					    VECTOR(values2)[nodes-i-1]));
    if (d > 1e-15) { DUMP(); return 2; }
    for (j=0; j<nodes; j++) { 
      igraph_real_t d=
	igraph_complex_abs(igraph_complex_sub(MATRIX(vectors, j, i), 
					      MATRIX(vectors2, j,
						     nodes-i-1)));
      if (d > 1e-15) { DUMP(); return 3; }
    }
  }

  igraph_vector_complex_destroy(&values);
  igraph_matrix_complex_destroy(&vectors);
  igraph_vector_complex_destroy(&values2);
  igraph_matrix_complex_destroy(&vectors2);
  igraph_matrix_destroy(&mat2);
  
  return 0;
}
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;

}
int initIgraph(int *m){

	igraph_t g;
	igraph_matrix_t mat;
	long int i, j;

	igraph_matrix_init(&mat, numNodos, numNodos);
	for (i=0; i<numNodos; i++) for (j=0; j<numNodos; j++) MATRIX(mat, i, j) = m[i+numNodos*j];
	igraph_i_set_attribute_table(&igraph_cattribute_table);


	igraph_weighted_adjacency(&g, &mat, IGRAPH_ADJ_UPPER, 0, /*loops=*/ 1);
	//print(&g);

	FILE *stp;
	stp = fopen("/home/john/git/primAlgorithm/grafo2.gml", "w");
	if (stp==0) {
		printf("Problema abriendo archivo de grafo\n");
		return EXIT_FAILURE;
	}

	igraph_write_graph_gml(&g, stp, 0, "gml Test");
	fclose(stp);

	igraph_destroy(&g);
	return EXIT_SUCCESS;
}
Exemple #9
0
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;
}
Exemple #10
0
int main() {
  
  igraph_t g;
  igraph_vector_t weights;
  igraph_real_t weights_data[] = { 0,2,1, 0,5,2, 1,1,0, 2,2,8, 1,1,3, 1,1,4, 2,1 };
  igraph_matrix_t res;
  
  igraph_small(&g, 10, IGRAPH_DIRECTED, 
	       0,1, 0,2, 0,3,    1,2, 1,4, 1,5,
	       2,3, 2,6,         3,2, 3,6,
	       4,5, 4,7,         5,6, 5,8, 5,9,
	       7,5, 7,8,         8,9,
	       5,2,
	       2,1,
	       -1);
  
  igraph_vector_view(&weights, weights_data, 
		     sizeof(weights_data)/sizeof(igraph_real_t));
  
  igraph_matrix_init(&res, 0, 0);
  igraph_shortest_paths_dijkstra(&g, &res, igraph_vss_all(), igraph_vss_all(),
				 &weights, IGRAPH_OUT);
  print_matrix(&res);
  
  igraph_matrix_destroy(&res);
  igraph_destroy(&g);

  return 0;
}
int test_unnormalized_laplacian(igraph_bool_t dir) {
  igraph_t g;
  igraph_matrix_t m;
  igraph_vector_t vec;
  igraph_matrix_init(&m, 1, 1);

  /* No loop or multiple edges */
  igraph_ring(&g, 5, dir, 0, 1);
  igraph_laplacian(&g, &m, 0);
  print_matrix(&m);
  printf("===\n");

  /* Add some loop edges */
  igraph_vector_init_real(&vec, 4, 1.0, 1.0, 2.0, 2.0);
  igraph_add_edges(&g, &vec, 0);
  igraph_vector_destroy(&vec);

  igraph_laplacian(&g, &m, 0);
  print_matrix(&m);
  printf("===\n");

  /* Duplicate some edges */
  igraph_vector_init_real(&vec, 4, 1.0, 2.0, 3.0, 4.0);
  igraph_add_edges(&g, &vec, 0);
  igraph_vector_destroy(&vec);

  igraph_laplacian(&g, &m, 0);
  print_matrix(&m);

  igraph_destroy(&g);

  igraph_matrix_destroy(&m);

  return 0;
}
Exemple #12
0
/* Erdos-Renyi : G(n,M)
*/
igraph_t *ggen_generate_erdos_gnm(gsl_rng *r, unsigned long n, unsigned long m)
{
    igraph_matrix_t adj;
    igraph_t *g = NULL;
    int err;
    unsigned long i,j;
    unsigned long added_edges = 0;

    ggen_error_start_stack();
    if(r == NULL)
        GGEN_SET_ERRNO(GGEN_EINVAL);

    if(m > (n*(n-1)/2))
        GGEN_SET_ERRNO(GGEN_EINVAL);

    g = malloc(sizeof(igraph_t));
    GGEN_CHECK_ALLOC(g);
    GGEN_FINALLY3(free,g,1);

    if(m == 0 || n <= 1)
    {
        GGEN_CHECK_IGRAPH(igraph_empty(g,n,1));
        goto end;
    }
    if(m == (n*(n-1))/2)
    {
        GGEN_CHECK_IGRAPH(igraph_full_citation(g,n,1));
        goto end;
    }

    GGEN_CHECK_IGRAPH(igraph_matrix_init(&adj,n,n));
    GGEN_FINALLY(igraph_matrix_destroy,&adj);

    igraph_matrix_null(&adj);

    while(added_edges < m) {
        GGEN_CHECK_GSL_DO(i = gsl_rng_uniform_int(r,n));
        GGEN_CHECK_GSL_DO(j = gsl_rng_uniform_int(r,n));

        if(i < j && igraph_matrix_e(&adj,i,j) == 0)
        {
            igraph_matrix_set(&adj,i,j,1);
            added_edges++;
        }

    }

    GGEN_CHECK_IGRAPH(igraph_adjacency(g,&adj,IGRAPH_ADJ_DIRECTED));
end:
    ggen_error_clean(1);
    return g;
ggen_error_label:
    return NULL;
}
Exemple #13
0
/* call-seq:
 *   graph.dijkstra_shortest_paths(varray,weights,mode) -> Array
 *
 * Calculates the length of the shortest paths from each of the vertices in
 * the varray Array to all of the other vertices in the graph given a set of 
 * edge weights given in the weights Array. The result
 * is returned as an Array of Array. Each top-level Array contains the results
 * for a vertex in the varray Array. Each entry in the Array is the path length
 * to another vertex in the graph in vertex order (the order the vertices were
 * added to the graph. (This should probalby be changed to give a Hash of Hash
 * to allow easier look up.)
 */
VALUE cIGraph_dijkstra_shortest_paths(VALUE self, VALUE from, VALUE weights, VALUE mode){

  igraph_t *graph;
  igraph_vs_t vids;
  igraph_vector_t vidv;
  igraph_vector_t wghts;
  igraph_neimode_t pmode = NUM2INT(mode);
  igraph_matrix_t res;
  int i;
  int j;
  VALUE row;
  VALUE path_length;
  VALUE matrix = rb_ary_new();
  int n_row;
  int n_col;

  Data_Get_Struct(self, igraph_t, graph);

  n_row = NUM2INT(rb_funcall(from,rb_intern("length"),0));
  n_col = igraph_vcount(graph);

  //matrix to hold the results of the calculations
  igraph_matrix_init(&res,n_row,n_col);

  igraph_vector_init(&wghts,RARRAY_LEN(weights));

  for(i=0;i<RARRAY_LEN(weights);i++){
    VECTOR(wghts)[i] = NUM2DBL(RARRAY_PTR(weights)[i]);
  }

  //Convert an array of vertices to a vector of vertex ids
  igraph_vector_init_int(&vidv,0);
  cIGraph_vertex_arr_to_id_vec(self,from,&vidv);
  //create vertex selector from the vecotr of ids
  igraph_vs_vector(&vids,&vidv);

  igraph_dijkstra_shortest_paths(graph,&res,vids,&wghts,pmode);

  for(i=0; i<igraph_matrix_nrow(&res); i++){
    row = rb_ary_new();
    rb_ary_push(matrix,row);
    for(j=0; j<igraph_matrix_ncol(&res); j++){
      path_length = MATRIX(res,i,j) == n_col ? Qnil : rb_float_new(MATRIX(res,i,j));
      rb_ary_push(row,path_length);
    }
  }

  igraph_vector_destroy(&vidv);
  igraph_matrix_destroy(&res);
  igraph_vs_destroy(&vids);
  igraph_vector_destroy(&wghts);
  return matrix;

}
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;

}
Exemple #16
0
VALUE cIGraph_matrix_alloc(VALUE klass){

  igraph_matrix_t *m = malloc(sizeof(igraph_matrix_t));
  VALUE obj;

  igraph_matrix_init(m, 0, 0);

  obj = Data_Wrap_Struct(klass, 0, cIGraph_matrix_free, m);

  return obj;
  
}
/* call-seq:
 *   graph.layout_random -> IGraphMatrix
 *
 * Returns a random layout in 3D.
 */
VALUE cIGraph_layout_random_3d(VALUE self) {

    igraph_t *graph;
    igraph_matrix_t *res = malloc(sizeof(igraph_matrix_t));

    Data_Get_Struct(self, igraph_t, graph);

    igraph_matrix_init(res,0,0);
    igraph_layout_random_3d(graph,res);

    return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);

}
Exemple #18
0
symmetric_matrix<double, lower> Graph::adjacency() const {
  double x;
  int i,j;
  igraph_matrix_t m; 
  symmetric_matrix<double, lower> adjmatrix(size, size);
  igraph_matrix_init(&m, size, size);
  igraph_get_adjacency(graph, &m,IGRAPH_GET_ADJACENCY_LOWER);  /* IGRAPH_GET_ADJACENCY_BOTH);*/
  for(i = 0; i < size; i++){
    for(j = 0; j <=i; j++) {
      x = MATRIX(m,i,j) ? 1 : 0;
      adjmatrix(i,j) = x;
    }
  }
  igraph_matrix_destroy(&m);
  return adjmatrix;
}
Exemple #19
0
/* Erdos-Renyi : G(n,p)
*/
igraph_t *ggen_generate_erdos_gnp(gsl_rng *r, unsigned long n, double p)
{
    igraph_matrix_t m;
    igraph_t *g = NULL;
    int err;
    unsigned long i,j;

    ggen_error_start_stack();
    if(r == NULL)
        GGEN_SET_ERRNO(GGEN_EINVAL);

    if(p < 0.0 || p > 1.0)
        GGEN_SET_ERRNO(GGEN_EINVAL);

    g = malloc(sizeof(igraph_t));
    GGEN_CHECK_ALLOC(g);
    GGEN_FINALLY3(free,g,1);

    if(p == 0.0)
    {
        GGEN_CHECK_IGRAPH(igraph_empty(g,n,1));
        goto end;
    }
    if(p == 1.0)
    {
        GGEN_CHECK_IGRAPH(igraph_full_citation(g,n,1));
        goto end;
    }

    GGEN_CHECK_IGRAPH(igraph_matrix_init(&m,n,n));
    GGEN_FINALLY(igraph_matrix_destroy,&m);

    for(i = 0; i < n; i++)
        for(j = 0; j < n; j++)
            if(i < j)
                // coin flipping to determine if we add an edge or not
                igraph_matrix_set(&m,i,j,gsl_ran_bernoulli(r,p));
            else
                igraph_matrix_set(&m,i,j,0);

    GGEN_CHECK_IGRAPH(igraph_adjacency(g,&m,IGRAPH_ADJ_DIRECTED));
end:
    ggen_error_clean(1);
    return g;
ggen_error_label:
    return NULL;
}
/* call-seq:
 *   graph.cocitation(varray) -> Array
 *
 * Cocitation coupling.
 *
 * Two vertices are cocited if there is another vertex citing both of them. 
 * igraph_cocitation() simply counts how many types two vertices are cocited. 
 * The cocitation score for each given vertex and all other vertices in the 
 * graph will be calculated. 
 *
 */
VALUE cIGraph_cocitation(VALUE self, VALUE vs){

  igraph_t *graph;
  igraph_vs_t vids;
  igraph_vector_t vidv;
  igraph_matrix_t res;
  int i;
  int j;
  VALUE row;
  VALUE path_length;
  VALUE matrix = rb_ary_new();
  int n_row;
  int n_col;

  Data_Get_Struct(self, igraph_t, graph);

  n_row = NUM2INT(rb_funcall(vs,rb_intern("length"),0));
  n_col = igraph_vcount(graph);

  //matrix to hold the results of the calculations
  igraph_matrix_init(&res,n_row,n_col);

  //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);

  igraph_cocitation(graph,&res,vids);

  for(i=0; i<igraph_matrix_nrow(&res); i++){
    row = rb_ary_new();
    rb_ary_push(matrix,row);
    for(j=0; j<igraph_matrix_ncol(&res); j++){
      path_length = INT2NUM(MATRIX(res,i,j));
      rb_ary_push(row,path_length);
    }
  }

  igraph_vector_destroy(&vidv);
  igraph_matrix_destroy(&res);
  igraph_vs_destroy(&vids);

  return matrix;

}
Exemple #21
0
int main() {
  igraph_matrix_t m;
  
  igraph_matrix_init(&m, 10, 10);
  if (igraph_matrix_capacity(&m) != 100) {
    return 1;
  }

  igraph_matrix_add_cols(&m, 5);
  igraph_matrix_resize(&m, 5, 5);
  igraph_matrix_resize_min(&m);
  if (igraph_matrix_capacity(&m) != igraph_matrix_size(&m)) {
    return 2;
  }

  igraph_matrix_destroy(&m);
  return 0;
}
int main() {
  igraph_t graph;
  igraph_matrix_t coords;
  int i;

  igraph_matrix_init(&coords, 0, 0);

  for (i=0; i<10; i++) {
    igraph_erdos_renyi_game(&graph, IGRAPH_ERDOS_RENYI_GNP, /*n=*/ 100, 
			    /*p=*/ 2.0/100, IGRAPH_UNDIRECTED, /*loops=*/ 0);
    igraph_layout_mds(&graph, &coords, /*dist=*/ 0, /*dim=*/ 2,
		      /*options=*/ 0);
    igraph_destroy(&graph);
  }
  
  igraph_matrix_destroy(&coords);
	 
  return 0;
}
int main() {
  igraph_matrix_t mat;
  igraph_sparsemat_t spmat, spmat2;
  int i;
  igraph_real_t m1, m2;
  
  igraph_rng_seed(igraph_rng_default(), 42);

  igraph_sparsemat_init(&spmat, DIM1, DIM2, 20);
  igraph_sparsemat_entry(&spmat, 1, 2, -1.0);
  igraph_sparsemat_entry(&spmat, 3, 2, 10.0);
  for (i=0; i<10; i++) {
    igraph_sparsemat_entry(&spmat, INT(DIM1-1), INT(DIM2-1), 1.0);
  } 
  igraph_sparsemat_entry(&spmat, 1, 2, -1.0);
  igraph_sparsemat_entry(&spmat, 3, 2, 10.0);
  
  igraph_sparsemat_compress(&spmat, &spmat2);
  igraph_matrix_init(&mat, 0, 0);
  igraph_sparsemat_as_matrix(&mat, &spmat2);
  m1=igraph_sparsemat_min(&spmat2);
  m2=igraph_matrix_min(&mat);
  if (m1 != m2) {
    printf("%f %f\n", m1, m2);
    return 1; 
  }
  m1=igraph_sparsemat_max(&spmat2);
  m2=igraph_matrix_max(&mat);
  if (m1 != m2) {
    printf("%f %f\n", m1, m2);
    return 2;
  }

  igraph_sparsemat_minmax(&spmat2, &m1, &m2);
  if (m1 != igraph_matrix_min(&mat)) { return 3; }
  if (m2 != igraph_matrix_max(&mat)) { return 4; }

  igraph_matrix_destroy(&mat);
  igraph_sparsemat_destroy(&spmat);
  igraph_sparsemat_destroy(&spmat2);
  
  return 0;
}
VALUE cIGraph_community_walktrap(VALUE self, VALUE weights, VALUE steps){

  igraph_t *graph;

  igraph_vector_t weights_vec;
  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(&weights_vec,0);
  igraph_vector_init(&modularity,0);

  for(i=0;i<RARRAY_LEN(weights);i++){
    VECTOR(weights_vec)[i] = NUM2DBL(RARRAY_PTR(weights)[i]);
  }

  igraph_community_walktrap(graph,
			    igraph_vector_size(&weights_vec) > 0 ? &weights_vec : NULL,
			    NUM2INT(steps),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(&weights_vec);
  igraph_vector_destroy(&modularity);

  return res;

}
int main() {
  
  igraph_t g;
  igraph_matrix_t m;
  
  igraph_small(&g, 0, IGRAPH_DIRECTED, 
	       0,1, 2,1, 2,0, 3,0, 
	       -1);
  
  igraph_matrix_init(&m, 0, 0);
  igraph_bibcoupling(&g, &m, igraph_vss_all());
  print_matrix(&m, stdout);
  
  igraph_cocitation(&g, &m, igraph_vss_all());
  print_matrix(&m, stdout);
  
  igraph_matrix_destroy(&m);
  igraph_destroy(&g);
  
  return 0;
}
VALUE cIGraph_community_eb_get_merges(VALUE self, VALUE edges){

  igraph_t *graph;
  igraph_matrix_t *res = malloc(sizeof(igraph_matrix_t));

  igraph_vector_t edges_vec;
  igraph_vector_t bridges_vec;

  VALUE result,bridges_a;

  int i;

  Data_Get_Struct(self, igraph_t, graph);

  igraph_matrix_init(res,0,0);
  igraph_vector_init(&edges_vec,0);
  igraph_vector_init(&bridges_vec,0);

  for(i=0;i<RARRAY_LEN(edges);i++){
    igraph_vector_push_back(&edges_vec,NUM2INT(RARRAY_PTR(edges)[i]));
  }

  igraph_community_eb_get_merges(graph,&edges_vec,res,&bridges_vec);

  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]));
  }

  igraph_vector_destroy(&bridges_vec);
  igraph_vector_destroy(&edges_vec);

  result = rb_ary_new3(2,
		       Data_Wrap_Struct(cIGraphMatrix, 0, 
					cIGraph_matrix_free, res),
		       bridges_a);

  return result;

}
Exemple #27
0
int* readGrafo(){

	int *grafo;
	igraph_matrix_t gMatrix;
	igraph_t g;
	igraph_i_set_attribute_table(&igraph_cattribute_table);
	FILE *ifile;
	ifile=fopen("/home/john/git/primAlgorithm/celegansneural.gml"/*"/home/john/git/primAlgorithm/grafo.gml"*/, "r");
	if (ifile==0) {
		printf("Problema abriendo archivo de grafo\n");
		return NULL;
	}
	igraph_read_graph_gml(&g, ifile);

	fclose(ifile);
	numNodos = igraph_vcount(&g);
	grafo = malloc(numNodos*numNodos*sizeof(int));
	igraph_matrix_init(&gMatrix,numNodos,numNodos);
	igraph_get_adjacency(&g,&gMatrix,IGRAPH_GET_ADJACENCY_BOTH,1);

	igraph_vector_t el;
	int ii, jj, n;
	igraph_vector_init(&el, 0);
	igraph_get_edgelist(&g, &el, 0);
	n = igraph_ecount(&g);

	memset(grafo,INT_MAX2,numNodos*numNodos*sizeof(int));

	  for (ii=0, jj=0; ii<n; ii++, jj+=2) {
	    grafo[((long)VECTOR(el)[jj])+numNodos*((long)VECTOR(el)[jj+1])] = (int)EAN(&g, "weight", ii);
	    grafo[((long)VECTOR(el)[jj+1])+numNodos*((long)VECTOR(el)[jj])] =  (int)EAN(&g, "weight", ii);
	  }

	printf("\nNumero de nodos %d",numNodos);

	igraph_vector_destroy(&el);
	igraph_destroy(&g);
	return grafo;

}
/* call-seq:
 *   graph.layout_kamada_kawai_3d -> IGraphMatrix
 *
 * Places the vertices on a plane according the Kamada-Kawai algorithm.
 *
 * This is a force directed layout, see Kamada, T. and Kawai, S.: An
 * Algorithm for Drawing General Undirected Graphs. Information Processing
 * Letters, 31/1, 7--15, 1989.
 */
VALUE cIGraph_layout_kamada_kawai_3d(VALUE self,
                                     VALUE niter,
                                     VALUE sigma,
                                     VALUE initemp,
                                     VALUE coolexp,
                                     VALUE kkconst) {

    igraph_t *graph;
    igraph_matrix_t *res = malloc(sizeof(igraph_matrix_t));

    Data_Get_Struct(self, igraph_t, graph);

    igraph_matrix_init(res,0,0);
    igraph_layout_kamada_kawai_3d(graph,res,
                                  NUM2INT(niter),
                                  NUM2DBL(sigma),
                                  NUM2DBL(initemp),
                                  NUM2DBL(coolexp),
                                  NUM2DBL(kkconst),0);

    return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);

}
int test_normalized_laplacian(igraph_bool_t dir) {
  igraph_t g;
  igraph_matrix_t m;
  igraph_vector_t vec;
  igraph_matrix_init(&m, 1, 1);
  igraph_bool_t ok = 1;

  /* Undirected graph, no loop or multiple edges */
  igraph_ring(&g, 5, dir, 0, 1);
  igraph_laplacian(&g, &m, 1);
  ok = ok && check_laplacian(&g, &m);

  /* Add some loop edges */
  igraph_vector_init_real(&vec, 4, 1.0, 1.0, 2.0, 2.0);
  igraph_add_edges(&g, &vec, 0);
  igraph_vector_destroy(&vec);

  igraph_laplacian(&g, &m, 1);
  ok = ok && check_laplacian(&g, &m);

  /* Duplicate some edges */
  igraph_vector_init_real(&vec, 4, 1.0, 2.0, 3.0, 4.0);
  igraph_add_edges(&g, &vec, 0);
  igraph_vector_destroy(&vec);

  igraph_laplacian(&g, &m, 1);
  ok = ok && check_laplacian(&g, &m);

  igraph_destroy(&g);

  igraph_matrix_destroy(&m);

  if (ok)
    printf("OK\n");

  return !ok;
}
Exemple #30
0
int igraph_i_eigen_arpackfun_to_mat(igraph_arpack_function_t *fun,
				    int n, void *extra, 
				    igraph_matrix_t *res) {
  
  int i;
  igraph_vector_t v;

  IGRAPH_CHECK(igraph_matrix_init(res, n, n));
  IGRAPH_FINALLY(igraph_matrix_destroy, res);
  IGRAPH_VECTOR_INIT_FINALLY(&v, n);
  VECTOR(v)[0]=1;
  IGRAPH_CHECK(fun(/*to=*/ &MATRIX(*res, 0, 0), /*from=*/ VECTOR(v), n, 
		   extra));
  for (i=1; i<n; i++) {
    VECTOR(v)[i-1]=0;
    VECTOR(v)[i  ]=1;
    IGRAPH_CHECK(fun(/*to=*/ &MATRIX(*res, 0, i), /*from=*/ VECTOR(v), n, 
		     extra));
  }
  igraph_vector_destroy(&v);
  IGRAPH_FINALLY_CLEAN(2);
  
  return 0;
}