int main() { igraph_t g; int ret; igraph_atlas(&g, 45); igraph_write_graph_edgelist(&g, stdout); printf("\n"); igraph_destroy(&g); igraph_atlas(&g, 0); igraph_write_graph_edgelist(&g, stdout); printf("\n"); igraph_destroy(&g); igraph_atlas(&g, 1252); igraph_write_graph_edgelist(&g, stdout); printf("\n"); igraph_destroy(&g); igraph_set_error_handler(igraph_error_handler_ignore); ret=igraph_atlas(&g, -1); if (ret != IGRAPH_EINVAL) { return 1; } ret=igraph_atlas(&g, 1253); if (ret != IGRAPH_EINVAL) { return 2; } return 0; }
char * ggen_vname(char *s, igraph_t *g, unsigned long id) { /* WARNING: this should be changed if igraph-0.6 gets * stable. * We need to ignore some igraph_cattribute errors * because we try to retrieve special attributes (ggen specifics). * igraph version 0.6 include a cattribute_has_attr that should be * used instead of ignoring errors. */ char * r = NULL; igraph_error_handler_t *error_handler; error_handler = igraph_set_error_handler(igraph_error_handler_ignore); r = vid2vname_unsafe(s,g,id); igraph_set_error_handler(error_handler); return r; }
int main() { igraph_t g; igraph_vector_t v; int ret; igraph_es_t es; igraph_vector_init(&v, 8); VECTOR(v)[0]=0; VECTOR(v)[1]=1; VECTOR(v)[2]=1; VECTOR(v)[3]=2; VECTOR(v)[4]=2; VECTOR(v)[5]=3; VECTOR(v)[6]=2; VECTOR(v)[7]=2; igraph_create(&g, &v, 0, 0); igraph_es_pairs_small(&es, IGRAPH_DIRECTED, 3,2, -1); igraph_delete_edges(&g, es); if (igraph_ecount(&g) != 3) { return 1; } /* error test, no such edge to delete */ igraph_set_error_handler(igraph_error_handler_ignore); ret=igraph_delete_edges(&g, es); if (ret != IGRAPH_EINVAL) { printf("Error code: %i\n", ret); return 2; } if (igraph_ecount(&g) != 3) { return 3; } /* error test, invalid vertex id */ igraph_es_destroy(&es); igraph_es_pairs_small(&es, IGRAPH_DIRECTED, 10,2, -1); ret=igraph_delete_edges(&g, es); if (ret != IGRAPH_EINVVID) { return 4; } if (igraph_ecount(&g) != 3) { return 5; } /* error test, invalid (odd) length */ igraph_es_destroy(&es); igraph_es_pairs_small(&es, IGRAPH_DIRECTED, 0,1,2, -1); ret=igraph_delete_edges(&g, es); if (ret != IGRAPH_EINVAL) { return 6; } if (igraph_ecount(&g) != 3) { return 7; } igraph_es_destroy(&es); igraph_vector_destroy(&v); igraph_destroy(&g); return 0; }
int main() { igraph_t g; igraph_vector_t v1, v2; int ret; /* simple use */ igraph_vector_init(&v1, 8); VECTOR(v1)[0]=0; VECTOR(v1)[1]=1; VECTOR(v1)[2]=1; VECTOR(v1)[3]=2; VECTOR(v1)[4]=2; VECTOR(v1)[5]=3; VECTOR(v1)[6]=2; VECTOR(v1)[7]=2; igraph_create(&g, &v1, 0, 0); if (igraph_vcount(&g) != 4) { return 1; } igraph_vector_init(&v2, 0); igraph_get_edgelist(&g, &v2, 0); igraph_vector_sort(&v1); igraph_vector_sort(&v2); if (!igraph_vector_all_e(&v1, &v2)) { return 2; } igraph_destroy(&g); /* higher number of vertices */ igraph_create(&g, &v1, 10, 0); if (igraph_vcount(&g) != 10) { return 1; } igraph_get_edgelist(&g, &v2, 0); igraph_vector_sort(&v1); igraph_vector_sort(&v2); if (!igraph_vector_all_e(&v1, &v2)) { return 3; } igraph_destroy(&g); /* error: IGRAPH_EINVEVECTOR */ igraph_set_error_handler(igraph_error_handler_ignore); igraph_vector_resize(&v1, 9); VECTOR(v1)[8]=0; ret=igraph_create(&g, &v1, 0, 0); if (ret != IGRAPH_EINVEVECTOR) { return 4; } /* error: IGRAPH_EINVVID */ igraph_vector_resize(&v1, 8); VECTOR(v1)[7]=-1; ret=igraph_create(&g, &v1, 10, 1); if (ret != IGRAPH_EINVVID) { return 5; } igraph_vector_destroy(&v1); igraph_vector_destroy(&v2); return 0; }
int main() { igraph_t g; int ret; /* empty directed graph, zero vertices */ igraph_empty(&g, 0, 1); if (igraph_vcount(&g) != 0) { return 1; } if (igraph_ecount(&g) != 0) { return 2; } igraph_destroy(&g); /* empty undirected graph, zero vertices */ igraph_empty(&g, 0, 0); if (igraph_vcount(&g) != 0) { return 3; } if (igraph_ecount(&g) != 0) { return 4; } igraph_destroy(&g); /* empty directed graph, 20 vertices */ igraph_empty(&g, 20, 1); if (igraph_vcount(&g) != 20) { return 5; } if (igraph_ecount(&g) != 0) { return 6; } igraph_destroy(&g); /* empty undirected graph, 30 vertices */ igraph_empty(&g, 30, 0); if (igraph_vcount(&g) != 30) { return 7; } if (igraph_ecount(&g) != 0) { return 8; } igraph_destroy(&g); /* error: negative number of vertices */ igraph_set_error_handler(igraph_error_handler_ignore); ret=igraph_empty(&g, -1, 0); if (ret != IGRAPH_EINVAL) { return 9; } return 0; }
int main() { igraph_t g; igraph_vector_t v; int ret; /* without edges */ igraph_empty(&g, 5, IGRAPH_DIRECTED); igraph_add_vertices(&g, 2, 0); igraph_add_vertices(&g, 3, 0); igraph_add_vertices(&g, 1, 0); igraph_add_vertices(&g, 4, 0); if (igraph_vcount(&g) != 15) { return 1; } igraph_delete_vertices(&g, igraph_vss_1(2)); if (igraph_vcount(&g) != 14) { return 2; } igraph_destroy(&g); igraph_vector_init(&v, 8); VECTOR(v)[0]=0; VECTOR(v)[1]=1; VECTOR(v)[2]=1; VECTOR(v)[3]=2; VECTOR(v)[4]=2; VECTOR(v)[5]=3; VECTOR(v)[6]=2; VECTOR(v)[7]=2; igraph_create(&g, &v, 0, 0); igraph_vector_destroy(&v); /* resize vector */ igraph_delete_vertices(&g, igraph_vss_1(2)); if (igraph_vcount(&g) != 3) { return 3; } if (igraph_ecount(&g) != 1) { return 4; } /* error test */ igraph_set_error_handler(igraph_error_handler_ignore); ret=igraph_delete_vertices(&g, igraph_vss_1(3)); if (ret != IGRAPH_EINVVID) { return 5; } igraph_destroy(&g); return 0; }
int main() { igraph_t g; igraph_vector_t v, res, reset, weights; igraph_arpack_options_t arpack_options; igraph_real_t value; int ret; igraph_pagerank_power_options_t power_options; /* Test graphs taken from http://www.iprcom.com/papers/pagerank/ */ igraph_vector_init(&v, 10); VECTOR(v)[0]=0; VECTOR(v)[1]=1; VECTOR(v)[2]=1; VECTOR(v)[3]=2; VECTOR(v)[4]=2; VECTOR(v)[5]=0; VECTOR(v)[6]=3; VECTOR(v)[7]=2; VECTOR(v)[8]=0; VECTOR(v)[9]=2; igraph_create(&g, &v, 0, 1); igraph_vector_init(&res, 0); oldwarn=igraph_set_warning_handler(warning_handler_stdout); igraph_pagerank_old(&g, &res, igraph_vss_all(), 1, 1000, 0.001, 0.85, 0); print_vector(&res, stdout); igraph_vector_destroy(&res); igraph_vector_destroy(&v); igraph_destroy(&g); igraph_vector_init(&v, 28); VECTOR(v)[ 0]=0; VECTOR(v)[ 1]=1; VECTOR(v)[ 2]=0; VECTOR(v)[ 3]=2; VECTOR(v)[ 4]=0; VECTOR(v)[ 5]=3; VECTOR(v)[ 6]=1; VECTOR(v)[ 7]=0; VECTOR(v)[ 8]=2; VECTOR(v)[ 9]=0; VECTOR(v)[10]=3; VECTOR(v)[11]=0; VECTOR(v)[12]=3; VECTOR(v)[13]=4; VECTOR(v)[14]=3; VECTOR(v)[15]=5; VECTOR(v)[16]=3; VECTOR(v)[17]=6; VECTOR(v)[18]=3; VECTOR(v)[19]=7; VECTOR(v)[20]=4; VECTOR(v)[21]=0; VECTOR(v)[22]=5; VECTOR(v)[23]=0; VECTOR(v)[24]=6; VECTOR(v)[25]=0; VECTOR(v)[26]=7; VECTOR(v)[27]=0; igraph_create(&g, &v, 0, 1); igraph_vector_init(&res, 0); igraph_pagerank_old(&g, &res, igraph_vss_all(), 1, 10000, 0.0001, 0.85, 0); print_vector(&res, stdout); igraph_vector_destroy(&res); igraph_vector_destroy(&v); igraph_destroy(&g); igraph_set_warning_handler(oldwarn); /* New PageRank */ igraph_star(&g, 11, IGRAPH_STAR_UNDIRECTED, 0); igraph_vector_init(&res, 0); igraph_arpack_options_init(&arpack_options); igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, 0, igraph_vss_all(), 0, 0.85, 0, &arpack_options); print_vector(&res, stdout); igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, 0, igraph_vss_all(), 0, 0.85, 0, 0); print_vector(&res, stdout); /* Check twice more for consistency */ igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, 0, igraph_vss_all(), 0, 0.85, 0, &arpack_options); print_vector(&res, stdout); igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, 0, igraph_vss_all(), 0, 0.85, 0, 0); print_vector(&res, stdout); igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, 0, igraph_vss_all(), 0, 0.85, 0, &arpack_options); print_vector(&res, stdout); igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, 0, igraph_vss_all(), 0, 0.85, 0, 0); print_vector(&res, stdout); /* Check personalized PageRank */ igraph_personalized_pagerank_vs(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, 0, igraph_vss_all(), 0, 0.5, igraph_vss_1(1), 0, &arpack_options); print_vector(&res, stdout); igraph_personalized_pagerank_vs(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, 0, igraph_vss_all(), 0, 0.5, igraph_vss_1(1), 0, 0); print_vector(&res, stdout); /* Errors */ power_options.niter = -1; power_options.eps=0.0001; igraph_set_error_handler(igraph_error_handler_ignore); igraph_set_warning_handler(igraph_warning_handler_ignore); ret=igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_POWER, &res, /*value=*/ 0, igraph_vss_all(), 1, 0.85, /*weights=*/ 0, &power_options); if (ret != IGRAPH_EINVAL) { return 1; } power_options.niter=10000; power_options.eps=-1; ret=igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_POWER, &res, /*value=*/ 0, igraph_vss_all(), 1, 0.85, /*weights=*/ 0, &power_options); if (ret != IGRAPH_EINVAL) { return 2; } power_options.niter=10000; power_options.eps=0.0001; ret=igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_POWER, &res, /*value=*/ 0, igraph_vss_all(), 1, 1.2, /*weights=*/ 0, &power_options); if (ret != IGRAPH_EINVAL) { return 3; } igraph_vector_init(&reset, 2); ret=igraph_personalized_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, 0, igraph_vss_all(), 0, 0.85, &reset, 0, &arpack_options); if (ret != IGRAPH_EINVAL) { return 4; } ret=igraph_personalized_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, 0, igraph_vss_all(), 0, 0.85, &reset, 0, 0); if (ret != IGRAPH_EINVAL) { return 4; } igraph_vector_resize(&reset, 10); igraph_vector_fill(&reset, 0); ret=igraph_personalized_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, 0, igraph_vss_all(), 0, 0.85, &reset, 0, &arpack_options); if (ret != IGRAPH_EINVAL) { return 5; } ret=igraph_personalized_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, 0, igraph_vss_all(), 0, 0.85, &reset, 0, 0); if (ret != IGRAPH_EINVAL) { return 5; } igraph_vector_destroy(&reset); igraph_destroy(&g); igraph_set_error_handler(igraph_error_handler_abort); /* Special cases: check for empty graph */ igraph_empty(&g, 10, 0); igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, &value, igraph_vss_all(), 1, 0.85, 0, &arpack_options); if (value != 1.0) { return 6; } igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, &value, igraph_vss_all(), 1, 0.85, 0, 0); if (value != 1.0) { return 6; } print_vector(&res, stdout); igraph_destroy(&g); /* Special cases: check for full graph, zero weights */ igraph_full(&g, 10, 0, 0); igraph_vector_init(&v, 45); igraph_vector_fill(&v, 0); igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, &value, igraph_vss_all(), 1, 0.85, &v, &arpack_options); if (value != 1.0) { return 7; } igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, &value, igraph_vss_all(), 1, 0.85, &v, 0); if (value != 1.0) { return 7; } igraph_vector_destroy(&v); print_vector(&res, stdout); igraph_destroy(&g); /* Another test case for PageRank (bug #792352) */ igraph_small(&g, 9, 1, 0, 5, 1, 5, 2, 0, 3, 1, 5, 4, 5, 7, 6, 0, 8, 0, 8, 1, -1); igraph_vector_init(&weights, 9); VECTOR(weights)[0] = 4; VECTOR(weights)[1] = 5; VECTOR(weights)[2] = 5; VECTOR(weights)[3] = 4; VECTOR(weights)[4] = 4; VECTOR(weights)[5] = 4; VECTOR(weights)[6] = 3; VECTOR(weights)[7] = 4; VECTOR(weights)[8] = 4; igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_ARPACK, &res, 0, igraph_vss_all(), 1, 0.85, &weights, &arpack_options); print_vector(&res, stdout); igraph_pagerank(&g, IGRAPH_PAGERANK_ALGO_PRPACK, &res, 0, igraph_vss_all(), 1, 0.85, &weights, 0); print_vector(&res, stdout); igraph_vector_destroy(&weights); igraph_destroy(&g); igraph_vector_destroy(&res); return 0; }
int ggen_write_graph(igraph_t *g, FILE *output) { Agraph_t *cg; Agnode_t *f,*t; Agedge_t *edge; igraph_vector_ptr_t vertices; igraph_eit_t eit; int err; unsigned long i,j; unsigned long vcount = igraph_vcount(g); igraph_integer_t from,to; char name[GGEN_DEFAULT_NAME_SIZE]; char *str = NULL; igraph_strvector_t gnames,vnames,enames; igraph_vector_t gtypes,vtypes,etypes; Agsym_t *attr; /* see warning below */ igraph_error_handler_t *error_handler; err = igraph_vector_ptr_init(&vertices,vcount); if(err) return 1; /* WARNING: this should be changed if igraph-0.6 gets * stable. * We need to ignore some igraph_cattribute errors * because we try to retrieve special attributes (ggen specifics). * igraph version 0.6 include a cattribute_has_attr that should be * used instead of ignoring errors. */ error_handler = igraph_set_error_handler(igraph_error_handler_ignore); /* open graph * its name is saved in __ggen_graph_name if it exists */ str =(char *) GAS(g,GGEN_GRAPH_NAME_ATTR); if(!str) cg = agopen(GGEN_DEFAULT_GRAPH_NAME,Agdirected,NULL); else cg = agopen(str,Agdirected,NULL); if(!cg) { err = 1; goto d_v; } /* save a pointer to each vertex */ for(i = 0; i < vcount; i++) { /* find a vertex name */ str = vid2vname_unsafe(name,g,i); if(!str) f = agnode(cg,name,1); else f = agnode(cg,str,1); VECTOR(vertices)[i] = (void *)f; } /* We have finished with dangerous attributes accesses */ igraph_set_error_handler(error_handler); /* now loop through edges in the igraph */ err = igraph_eit_create(g,igraph_ess_all(IGRAPH_EDGEORDER_ID),&eit); if(err) goto c_ag; for(IGRAPH_EIT_RESET(eit); !IGRAPH_EIT_END(eit); IGRAPH_EIT_NEXT(eit)) { err = igraph_edge(g,IGRAPH_EIT_GET(eit),&from,&to); if(err) goto d_eit; f = (Agnode_t *) VECTOR(vertices)[(unsigned long)from]; t = (Agnode_t *) VECTOR(vertices)[(unsigned long)to]; agedge(cg,f,t,NULL,1); } /* find all properties */ igraph_strvector_init(&gnames,1); igraph_strvector_init(&vnames,vcount); igraph_strvector_init(&enames,igraph_ecount(g)); igraph_vector_init(>ypes,1); igraph_vector_init(&vtypes,vcount); igraph_vector_init(&etypes,igraph_ecount(g)); err = igraph_cattribute_list(g,&gnames,>ypes,&vnames,&vtypes,&enames,&etypes); if(err) goto d_eit; /* add graph properties */ for(i = 0; i < igraph_strvector_size(&gnames); i++) { if(strcmp(GGEN_GRAPH_NAME_ATTR,STR(gnames,i))) { if(VECTOR(gtypes)[i]==IGRAPH_ATTRIBUTE_NUMERIC) { snprintf(name,GGEN_DEFAULT_NAME_SIZE,"%f", (double)GAN(g,STR(gnames,i))); agattr(cg,AGRAPH,(char *)STR(gnames,i),name); } else agattr(cg,AGRAPH,(char *)STR(gnames,i), (char *)GAS(g,STR(gnames,i))); } } /* add vertex properties */ for(i = 0; i < igraph_strvector_size(&vnames); i++) { if(strcmp(GGEN_VERTEX_NAME_ATTR,STR(vnames,i))) { /* creates the attribute but we still need to set it for each vertex */ attr = agattr(cg,AGNODE,(char *)STR(vnames,i),GGEN_CGRAPH_DEFAULT_VALUE); for(j = 0; j < vcount; j++) { f = (Agnode_t *) VECTOR(vertices)[j]; if(VECTOR(vtypes)[i]==IGRAPH_ATTRIBUTE_NUMERIC) { snprintf(name,GGEN_DEFAULT_NAME_SIZE,"%f", (double)VAN(g,STR(vnames,i),j)); agxset(f,attr,name); } else agxset(f,attr,(char *)VAS(g,STR(vnames,i),j)); } } } /* add edges properties */ for(i = 0; i < igraph_strvector_size(&enames); i++) { /* creates the attribute but we still need to set it for each edge */ attr = agattr(cg,AGEDGE,(char *)STR(enames,i),GGEN_CGRAPH_DEFAULT_VALUE); for(j = 0; j < igraph_ecount(g); j++) { igraph_edge(g,j,&from,&to); f = (Agnode_t *) VECTOR(vertices)[(unsigned long)from]; t = (Agnode_t *) VECTOR(vertices)[(unsigned long)to]; edge = agedge(cg,f,t,NULL,0); if(VECTOR(etypes)[i]==IGRAPH_ATTRIBUTE_NUMERIC) { snprintf(name,GGEN_DEFAULT_NAME_SIZE,"%f", (double)EAN(g,STR(enames,i),j)); agxset(edge,attr,name); } else agxset(edge,attr,(char *)EAS(g,STR(enames,i),j)); } } /* write the graph */ err = agwrite(cg,(void *)output); d_eit: igraph_eit_destroy(&eit); c_ag: agclose(cg); d_v: igraph_vector_ptr_destroy(&vertices); return err; }
/** * \ingroup interface * \function igraph_add_edges * \brief Adds edges to a graph object. * * </para><para> * The edges are given in a vector, the * first two elements define the first edge (the order is * <code>from</code>, <code>to</code> for directed * graphs). The vector * should contain even number of integer numbers between zero and the * number of vertices in the graph minus one (inclusive). If you also * want to add new vertices, call igraph_add_vertices() first. * \param graph The graph to which the edges will be added. * \param edges The edges themselves. * \param attr The attributes of the new edges, only used by high level * interfaces currently, you can supply 0 here. * \return Error code: * \c IGRAPH_EINVEVECTOR: invalid (odd) * edges vector length, \c IGRAPH_EINVVID: * invalid vertex id in edges vector. * * This function invalidates all iterators. * * </para><para> * Time complexity: O(|V|+|E|) where * |V| is the number of vertices and * |E| is the number of * edges in the \em new, extended graph. */ int igraph_add_edges(igraph_t *graph, const igraph_vector_t *edges, void *attr) { long int no_of_edges=igraph_vector_size(&graph->from); long int edges_to_add=igraph_vector_size(edges)/2; long int i=0; igraph_error_handler_t *oldhandler; int ret1, ret2; igraph_vector_t newoi, newii; igraph_bool_t directed=igraph_is_directed(graph); if (igraph_vector_size(edges) % 2 != 0) { IGRAPH_ERROR("invalid (odd) length of edges vector", IGRAPH_EINVEVECTOR); } if (!igraph_vector_isininterval(edges, 0, igraph_vcount(graph)-1)) { IGRAPH_ERROR("cannot add edges", IGRAPH_EINVVID); } /* from & to */ IGRAPH_CHECK(igraph_vector_reserve(&graph->from, no_of_edges+edges_to_add)); IGRAPH_CHECK(igraph_vector_reserve(&graph->to , no_of_edges+edges_to_add)); while (i<edges_to_add*2) { if (directed || VECTOR(*edges)[i] > VECTOR(*edges)[i+1]) { igraph_vector_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */ igraph_vector_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */ } else { igraph_vector_push_back(&graph->to, VECTOR(*edges)[i++]); /* reserved */ igraph_vector_push_back(&graph->from, VECTOR(*edges)[i++]); /* reserved */ } } /* disable the error handler temporarily */ oldhandler=igraph_set_error_handler(igraph_error_handler_ignore); /* oi & ii */ ret1=igraph_vector_init(&newoi, no_of_edges); ret2=igraph_vector_init(&newii, no_of_edges); if (ret1 != 0 || ret2 != 0) { igraph_vector_resize(&graph->from, no_of_edges); /* gets smaller */ igraph_vector_resize(&graph->to, no_of_edges); /* gets smaller */ igraph_set_error_handler(oldhandler); IGRAPH_ERROR("cannot add edges", IGRAPH_ERROR_SELECT_2(ret1, ret2)); } ret1=igraph_vector_order(&graph->from, &graph->to, &newoi, graph->n); ret2=igraph_vector_order(&graph->to , &graph->from, &newii, graph->n); if (ret1 != 0 || ret2 != 0) { igraph_vector_resize(&graph->from, no_of_edges); igraph_vector_resize(&graph->to, no_of_edges); igraph_vector_destroy(&newoi); igraph_vector_destroy(&newii); igraph_set_error_handler(oldhandler); IGRAPH_ERROR("cannot add edges", IGRAPH_ERROR_SELECT_2(ret1, ret2)); } /* Attributes */ if (graph->attr) { ret1=igraph_i_attribute_add_edges(graph, edges, attr); if (ret1 != 0) { igraph_vector_resize(&graph->from, no_of_edges); igraph_vector_resize(&graph->to, no_of_edges); igraph_vector_destroy(&newoi); igraph_vector_destroy(&newii); igraph_set_error_handler(oldhandler); IGRAPH_ERROR("cannot add edges", ret1); } } /* os & is, its length does not change, error safe */ igraph_i_create_start(&graph->os, &graph->from, &newoi, graph->n); igraph_i_create_start(&graph->is, &graph->to , &newii, graph->n); /* everything went fine */ igraph_vector_destroy(&graph->oi); igraph_vector_destroy(&graph->ii); graph->oi=newoi; graph->ii=newii; igraph_set_error_handler(oldhandler); return 0; }
int main() { igraph_t g; igraph_vector_t weights, result; igraph_bool_t dag; int retval; igraph_vector_init(&result, 0); igraph_set_error_handler(&igraph_error_handler_printignore); /***********************************************************************/ /* Exact solution with integer programming */ /***********************************************************************/ /* Simple unweighted graph */ igraph_small(&g, 0, IGRAPH_DIRECTED, 0,1, 1,2, 2,0, 2,3, 2,4, 0,4, 4,3, 5,0, 6,5, -1); retval = igraph_feedback_arc_set(&g, &result, 0, IGRAPH_FAS_EXACT_IP); if (retval == IGRAPH_UNIMPLEMENTED) return 77; igraph_vector_print(&result); igraph_delete_edges(&g, igraph_ess_vector(&result)); igraph_is_dag(&g, &dag); if (!dag) return 1; igraph_destroy(&g); /* Simple weighted graph */ igraph_small(&g, 0, IGRAPH_DIRECTED, 0,1, 1,2, 2,0, 2,3, 2,4, 0,4, 4,3, 5,0, 6,5, -1); igraph_vector_init_int_end(&weights, -1, 1, 1, 3, 1, 1, 1, 1, 1, 1, -1); igraph_feedback_arc_set(&g, &result, &weights, IGRAPH_FAS_EXACT_IP); igraph_vector_print(&result); igraph_delete_edges(&g, igraph_ess_vector(&result)); igraph_is_dag(&g, &dag); if (!dag) return 2; igraph_vector_destroy(&weights); igraph_destroy(&g); /* Simple unweighted graph with loops */ igraph_small(&g, 0, IGRAPH_DIRECTED, 0,1, 1,2, 2,0, 2,3, 2,4, 0,4, 4,3, 5,0, 6,5, 1,1, 4,4, -1); igraph_feedback_arc_set(&g, &result, 0, IGRAPH_FAS_EXACT_IP); igraph_vector_print(&result); igraph_delete_edges(&g, igraph_ess_vector(&result)); igraph_is_dag(&g, &dag); if (!dag) return 3; igraph_destroy(&g); /* Disjoint union of two almost identical graphs */ igraph_small(&g, 0, IGRAPH_DIRECTED, 0,1, 1,2, 2,0, 2,3, 2,4, 0,4, 4,3, 5,0, 6,5, 1,1, 4,4, 7,8, 8,9, 9,7, 9,10, 9,11, 7,11, 11,10, 12,7, 13,12, -1); igraph_feedback_arc_set(&g, &result, 0, IGRAPH_FAS_EXACT_IP); igraph_vector_print(&result); igraph_delete_edges(&g, igraph_ess_vector(&result)); igraph_is_dag(&g, &dag); if (!dag) return 4; igraph_destroy(&g); /* Graph with lots of isolated vertices */ igraph_small(&g, 10000, IGRAPH_DIRECTED, 0,1, -1); igraph_feedback_arc_set(&g, &result, 0, IGRAPH_FAS_EXACT_IP); igraph_vector_print(&result); igraph_delete_edges(&g, igraph_ess_vector(&result)); igraph_is_dag(&g, &dag); if (!dag) return 5; igraph_destroy(&g); igraph_vector_destroy(&result); return 0; }
int main() { igraph_t g; igraph_vector_t weights; igraph_real_t weights_data_0[] = { 0,2,1, 0,5,2, 1,1,0, 2,2,8, 1,1,3, 1,1,4, 2,1 }; igraph_real_t weights_data_1[] = { 6,7,8,-4,-2,-3,9,2,7 }; igraph_real_t weights_data_2[] = { 6,7,2,-4,-2,-3,9,2,7 }; igraph_matrix_t res; /* Graph with only positive weights */ 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_0, sizeof(weights_data_0)/sizeof(igraph_real_t)); igraph_matrix_init(&res, 0, 0); igraph_shortest_paths_bellman_ford(&g, &res, igraph_vss_all(), igraph_vss_all(), &weights, IGRAPH_OUT); print_matrix(&res); igraph_matrix_destroy(&res); igraph_destroy(&g); printf("\n"); /***************************************/ /* Graph with negative weights */ igraph_small(&g, 5, IGRAPH_DIRECTED, 0,1, 0,3, 1,3, 1,4, 2,1, 3,2, 3,4, 4,0, 4,2, -1); igraph_vector_view(&weights, weights_data_1, sizeof(weights_data_1)/sizeof(igraph_real_t)); igraph_matrix_init(&res, 0, 0); igraph_shortest_paths_bellman_ford(&g, &res, igraph_vss_all(), igraph_vss_all(), &weights, IGRAPH_OUT); print_matrix(&res); /***************************************/ /* Same graph with negative loop */ igraph_set_error_handler(igraph_error_handler_ignore); igraph_vector_view(&weights, weights_data_2, sizeof(weights_data_2)/sizeof(igraph_real_t)); if (igraph_shortest_paths_bellman_ford(&g, &res, igraph_vss_all(), igraph_vss_all(), &weights, IGRAPH_OUT) != IGRAPH_ENEGLOOP) return 1; igraph_matrix_destroy(&res); igraph_destroy(&g); if (!IGRAPH_FINALLY_STACK_EMPTY) return 1; return 0; }
int main(int argc, char **argv) { igraph_t g; igraph_error_handler_t* oldhandler; igraph_warning_handler_t* oldwarnhandler; int result; FILE *ifile, *ofile; igraph_i_set_attribute_table(&igraph_cattribute_table); /* GraphML */ ifile=fopen("test.gxl", "r"); if (ifile==0) { return 10; } oldhandler=igraph_set_error_handler(igraph_error_handler_ignore); oldwarnhandler=igraph_set_warning_handler(custom_warning_handler); if ((result=igraph_read_graph_graphml(&g, ifile, 0))) { /* maybe it is simply disabled at compile-time */ if (result == IGRAPH_UNIMPLEMENTED) return 77; return 1; } igraph_set_error_handler(oldhandler); fclose(ifile); /* Write it back */ ofile=fopen("test2.gxl", "w"); /* If we can't create the test file, just skip the test */ if (ofile) { if ((result=igraph_write_graph_graphml(&g, ofile, /*prefixattr=*/ 1))) { return 1; } fclose(ofile); unlink("test2.gxl"); } dump_graph("The directed graph:\n", &g); igraph_destroy(&g); /* The same with undirected graph */ ifile=fopen("test.gxl", "r"); if ((result=igraph_read_graph_graphml(&g, ifile, 0))) { return 1; } fclose(ifile); dump_graph("The undirected graph:\n", &g); igraph_destroy(&g); /* Test a GraphML file with default attributes */ ifile=fopen("graphml-default-attrs.xml", "r"); if ((result=igraph_read_graph_graphml(&g, ifile, 0))) { return 1; } fclose(ifile); dump_graph("The directed graph:\n", &g); dump_vertex_attribute_bool("type", &g); dump_vertex_attribute_string("gender", &g); dump_vertex_attribute_numeric("age", &g); dump_vertex_attribute_bool("retired", &g); igraph_destroy(&g); /* Test a GraphML file with namespaces */ ifile=fopen("graphml-namespace.xml", "r"); if ((result=igraph_read_graph_graphml(&g, ifile, 0))) { return 1; } fclose(ifile); dump_graph("The undirected graph:\n", &g); igraph_destroy(&g); /* Restore the old warning handler */ igraph_set_warning_handler(oldwarnhandler); /* There were sometimes problems with this file */ /* Only if called from R though, and only on random occasions, once in every ten reads. Do testing here doesn't make much sense, but if we have the file then let's do it anyway. */ ifile=fopen("graphml-hsa05010.xml", "r"); igraph_read_graph_graphml(&g, ifile, 0); fclose(ifile); igraph_destroy(&g); return 0; }
int main() { igraph_t g; igraph_vector_t deg; igraph_bool_t is_simple; igraph_set_error_handler(&igraph_error_handler_ignore); igraph_vector_init(°, 0); /* k-regular undirected graph, even degrees, no multiple edges */ igraph_k_regular_game(&g, 10, 4, 0, 0); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_ALL, 1); igraph_vector_print(°); igraph_is_simple(&g, &is_simple); if (!is_simple) return 1; if (igraph_is_directed(&g)) return 1; igraph_destroy(&g); /* k-regular undirected graph, odd degrees, even number of vertices, no multiple edges */ igraph_k_regular_game(&g, 10, 3, 0, 0); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_ALL, 1); igraph_vector_print(°); igraph_is_simple(&g, &is_simple); if (!is_simple) return 2; if (igraph_is_directed(&g)) return 2; igraph_destroy(&g); /* k-regular undirected graph, odd degrees, odd number of vertices, no multiple edges */ if (!igraph_k_regular_game(&g, 9, 3, 0, 0)) return 3; /* k-regular undirected graph, even degrees, multiple edges */ igraph_k_regular_game(&g, 10, 4, 0, 1); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_ALL, 1); igraph_vector_print(°); if (igraph_is_directed(&g)) return 14; igraph_destroy(&g); /* k-regular undirected graph, odd degrees, even number of vertices, multiple edges */ igraph_k_regular_game(&g, 10, 3, 0, 1); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_ALL, 1); igraph_vector_print(°); if (igraph_is_directed(&g)) return 15; igraph_destroy(&g); /* k-regular undirected graph, odd degrees, odd number of vertices, multiple edges */ if (!igraph_k_regular_game(&g, 9, 3, 0, 1)) return 4; /* k-regular directed graph, even degrees, no multiple edges */ igraph_k_regular_game(&g, 10, 4, 1, 0); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_IN, 1); igraph_vector_print(°); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_OUT, 1); igraph_vector_print(°); igraph_is_simple(&g, &is_simple); if (!is_simple) return 5; if (!igraph_is_directed(&g)) return 5; igraph_destroy(&g); /* k-regular directed graph, odd degrees, even number of vertices, no multiple edges */ igraph_k_regular_game(&g, 10, 3, 1, 0); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_IN, 1); igraph_vector_print(°); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_OUT, 1); igraph_vector_print(°); igraph_is_simple(&g, &is_simple); if (!is_simple) return 6; if (!igraph_is_directed(&g)) return 6; igraph_destroy(&g); /* k-regular directed graph, odd degrees, odd number of vertices, no multiple edges */ igraph_k_regular_game(&g, 9, 3, 1, 0); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_IN, 1); igraph_vector_print(°); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_OUT, 1); igraph_vector_print(°); igraph_is_simple(&g, &is_simple); if (!is_simple) return 7; if (!igraph_is_directed(&g)) return 7; igraph_destroy(&g); /* k-regular directed graph, even degrees, multiple edges */ igraph_k_regular_game(&g, 10, 4, 1, 1); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_IN, 1); igraph_vector_print(°); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_OUT, 1); igraph_vector_print(°); if (!igraph_is_directed(&g)) return 16; igraph_destroy(&g); /* k-regular directed graph, odd degrees, even number of vertices, multiple edges */ igraph_k_regular_game(&g, 10, 3, 1, 1); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_IN, 1); igraph_vector_print(°); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_OUT, 1); igraph_vector_print(°); if (!igraph_is_directed(&g)) return 17; igraph_destroy(&g); /* k-regular directed graph, odd degrees, odd number of vertices, multiple edges */ igraph_k_regular_game(&g, 9, 3, 1, 1); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_IN, 1); igraph_vector_print(°); igraph_degree(&g, °, igraph_vss_all(), IGRAPH_OUT, 1); igraph_vector_print(°); if (!igraph_is_directed(&g)) return 18; igraph_destroy(&g); /* k-regular undirected graph, too large degree, no multiple edges */ if (!igraph_k_regular_game(&g, 10, 10, 0, 0)) return 8; /* k-regular directed graph, too large degree, no multiple edges */ if (!igraph_k_regular_game(&g, 10, 10, 1, 0)) return 9; /* empty graph */ if (igraph_k_regular_game(&g, 0, 0, 0, 0)) return 10; if (igraph_vcount(&g) != 0 || igraph_ecount(&g) != 0 || igraph_is_directed(&g)) return 11; igraph_destroy(&g); if (igraph_k_regular_game(&g, 0, 0, 1, 0)) return 12; if (igraph_vcount(&g) != 0 || igraph_ecount(&g) != 0 || !igraph_is_directed(&g)) return 13; igraph_destroy(&g); igraph_vector_destroy(°); return 0; }
void Init_igraph(){ //Modules VALUE cIGraph_generate; VALUE cIGraph_genrandom; VALUE cIGraph_connectivity; VALUE cIGraph_mincuts; VALUE cIGraph_layout; VALUE cIGraph_clique; VALUE cIGraph_indyver; VALUE cIGraph_isomor; VALUE cIGraph_motifs; VALUE cIGraph_sorting; VALUE cIGraph_filewrite; VALUE cIGraph_fileread; VALUE cIGraph_community; VALUE cIGraph_shortestpaths; VALUE cIGraph_neighborhoodm; VALUE cIGraph_components; VALUE cIGraph_closenessm; VALUE cIGraph_spanning; VALUE cIGraph_transitivitym; VALUE cIGraph_spectral; VALUE cIGraph_kcore; VALUE cIGraph_otherop; VALUE cIGraph_randomise; igraph_i_set_attribute_table(&cIGraph_attribute_table); igraph_set_error_handler(cIGraph_error_handler); igraph_set_warning_handler(cIGraph_warning_handler); cIGraph = rb_define_class("IGraph", rb_cObject); cIGraphError = rb_define_class("IGraphError", rb_eRuntimeError); rb_define_alloc_func(cIGraph, cIGraph_alloc); rb_define_method(cIGraph, "initialize", cIGraph_initialize, -1); rb_define_method(cIGraph, "initialize_copy", cIGraph_init_copy, 1); rb_include_module(cIGraph, rb_mEnumerable); /* Functions for deterministically generating graphs. */ cIGraph_generate = rb_define_module_under(cIGraph, "Generate"); rb_include_module(cIGraph, cIGraph_generate); rb_define_singleton_method(cIGraph_generate, "adjacency", cIGraph_adjacency, 2); /* in cIGraph_generators_deterministic.c */ rb_define_singleton_method(cIGraph_generate, "star", cIGraph_star, 3); /* in cIGraph_generators_deterministic.c */ rb_define_singleton_method(cIGraph_generate, "lattice", cIGraph_lattice, 4); /* in cIGraph_generators_deterministic.c */ rb_define_singleton_method(cIGraph_generate, "ring", cIGraph_ring, 4); /* in cIGraph_generators_deterministic.c */ rb_define_singleton_method(cIGraph_generate, "tree", cIGraph_tree, 3); /* in cIGraph_generators_deterministic.c */ rb_define_singleton_method(cIGraph_generate, "full", cIGraph_full, 3); /* in cIGraph_generators_deterministic.c */ rb_define_singleton_method(cIGraph_generate, "atlas", cIGraph_atlas, 1); /* in cIGraph_generators_deterministic.c */ rb_define_singleton_method(cIGraph_generate, "extended_chordal_ring", cIGraph_extended_chordal_ring, 2); /* in cIGraph_generators_deterministic.c */ /* Functions for randomly generating graphs. */ cIGraph_genrandom = rb_define_module_under(cIGraph, "GenerateRandom"); rb_include_module(cIGraph, cIGraph_genrandom); rb_define_singleton_method(cIGraph_genrandom, "grg_game", cIGraph_grg_game, 3); /* in cIGraph_generators_random.c */ rb_define_singleton_method(cIGraph_genrandom, "barabasi_game", cIGraph_barabasi_game, 4); /* in cIGraph_generators_random.c */ rb_define_singleton_method(cIGraph_genrandom, "nonlinear_barabasi_game", cIGraph_nonlinear_barabasi_game, 6); /* in cIGraph_generators_random.c */ rb_define_singleton_method(cIGraph_genrandom, "erdos_renyi_game", cIGraph_erdos_renyi_game, 5); /* in cIGraph_generators_random.c */ rb_define_singleton_method(cIGraph_genrandom, "watts_strogatz_game", cIGraph_watts_strogatz_game, 4); /* in cIGraph_generators_random.c */ rb_define_singleton_method(cIGraph_genrandom, "degree_sequence_game", cIGraph_degree_sequence_game, 2); /* in cIGraph_generators_random.c */ rb_define_singleton_method(cIGraph_genrandom, "growing_random_game", cIGraph_growing_random_game, 4); /* in cIGraph_generators_random.c */ rb_define_singleton_method(cIGraph_genrandom, "callaway_traits_game", cIGraph_callaway_traits_game, 6); /* in cIGraph_generators_random.c */ rb_define_singleton_method(cIGraph_genrandom, "establishment_game", cIGraph_establishment_game, 6); /* in cIGraph_generators_random.c */ rb_define_singleton_method(cIGraph_genrandom, "preference_game", cIGraph_preference_game, 6); /* in cIGraph_generators_random.c */ rb_define_singleton_method(cIGraph_genrandom, "asymmetric_preference_game", cIGraph_asymmetric_preference_game, 5); /* in cIGraph_generators_random.c */ rb_define_singleton_method(cIGraph_genrandom, "recent_degree_game", cIGraph_recent_degree_game, 7); /* in cIGraph_generators_random.c */ rb_define_singleton_method(cIGraph_genrandom, "barabasi_aging_game", cIGraph_barabasi_aging_game, 11); /* in cIGraph_generators_random.c */ rb_define_singleton_method(cIGraph_genrandom, "recent_degree_aging_game", cIGraph_recent_degree_aging_game, 9); /* in cIGraph_generators_random.c */ rb_define_singleton_method(cIGraph_genrandom, "cited_type_game", cIGraph_cited_type_game, 5); /* in cIGraph_generators_random.c */ rb_define_singleton_method(cIGraph_genrandom, "citing_cited_type_game", cIGraph_citing_cited_type_game, 5); /* in cIGraph_generators_random.c */ rb_define_method(cIGraph, "[]", cIGraph_get_edge_attr, 2); /* in cIGraph_attribute_handler.c */ rb_define_method(cIGraph, "[]=", cIGraph_set_edge_attr, 3); /* in cIGraph_attribute_handler.c */ rb_define_alias (cIGraph, "get_edge_attr", "[]"); rb_define_alias (cIGraph, "set_edge_attr", "[]="); rb_define_method(cIGraph, "attributes", cIGraph_graph_attributes, 0); /* in cIGraph_attribute_handler.c */ rb_define_method(cIGraph, "each_vertex", cIGraph_each_vertex, 0); /* in cIGraph_iterators.c */ rb_define_method(cIGraph, "each_edge", cIGraph_each_edge, 1); /* in cIGraph_iterators.c */ rb_define_method(cIGraph, "each_edge_eid", cIGraph_each_edge_eid,1); /* in cIGraph_iterators.c */ rb_define_alias (cIGraph, "each", "each_vertex"); rb_define_method(cIGraph, "vertices", cIGraph_all_v, 0); /* in cIGraph_selectors.c */ rb_define_method(cIGraph, "adjacent_vertices", cIGraph_adj_v, 2); /* in cIGraph_selectors.c */ rb_define_method(cIGraph, "nonadjacent_vertices", cIGraph_nonadj_v, 2); /* in cIGraph_selectors.c */ rb_define_alias (cIGraph, "all_vertices", "vertices"); rb_define_method(cIGraph, "edges", cIGraph_all_e, 1); /* in cIGraph_selectors.c */ rb_define_method(cIGraph, "adjacent_edges", cIGraph_adj_e, 2); /* in cIGraph_selectors.c */ rb_define_alias (cIGraph, "all_edges", "edges"); rb_define_method(cIGraph, "vcount", cIGraph_vcount, 0); /* in cIGraph_basic_query.c */ rb_define_method(cIGraph, "ecount", cIGraph_ecount, 0); /* in cIGraph_basic_query.c */ rb_define_method(cIGraph, "edge", cIGraph_edge, 1); /* in cIGraph_basic_query.c */ rb_define_method(cIGraph, "get_eid", cIGraph_get_eid, 2); /* in cIGraph_basic_query.c */ rb_define_method(cIGraph, "neighbours", cIGraph_neighbors, 2); /* in cIGraph_basic_query.c */ rb_define_method(cIGraph, "adjacent", cIGraph_adjacent, 2); /* in cIGraph_basic_query.c */ rb_define_method(cIGraph, "degree", cIGraph_degree, 3); /* in cIGraph_basic_query.c */ rb_define_method(cIGraph, "is_directed?", cIGraph_is_directed, 0); /* in cIGraph_basic_query.c */ rb_define_alias (cIGraph, "is_directed", "is_directed?"); rb_define_alias (cIGraph, "neighbors", "neighbours"); rb_define_method(cIGraph, "add_edges", cIGraph_add_edges, -1); /* in cIGraph_add_delete.c */ rb_define_method(cIGraph, "add_vertices", cIGraph_add_vertices, 1); /* in cIGraph_add_delete.c */ rb_define_method(cIGraph, "add_edge", cIGraph_add_edge, -1); /* in cIGraph_add_delete.c */ rb_define_method(cIGraph, "add_vertex", cIGraph_add_vertex, 1); /* in cIGraph_add_delete.c */ rb_define_method(cIGraph, "delete_edge", cIGraph_delete_edge, 2); /* in cIGraph_add_delete.c */ rb_define_method(cIGraph, "delete_vertex", cIGraph_delete_vertex, 1); /* in cIGraph_add_delete.c */ rb_define_method(cIGraph, "are_connected", cIGraph_are_connected,2); /* in cIGraph_basic_properties.c */ rb_define_alias (cIGraph, "are_connected?", "are_connected"); rb_define_method(cIGraph, "to_directed", cIGraph_to_directed, 1); /* in cIGraph_direction.c */ rb_define_method(cIGraph, "to_undirected", cIGraph_to_undirected, 1); /* in cIGraph_direction.c */ /* These methods randomise a graph by rewiring the edges. */ cIGraph_randomise = rb_define_module_under(cIGraph, "Randomise"); rb_include_module(cIGraph, cIGraph_randomise); rb_define_method(cIGraph_randomise, "rewire_edges", cIGraph_rewire_edges, 1); /* in cIGraph_randomisation.c */ rb_define_method(cIGraph_randomise, "rewire", cIGraph_rewire, 1); /* in cIGraph_randomisation.c */ /* Functions for calculating the shortest path through a graph */ cIGraph_shortestpaths = rb_define_module_under(cIGraph, "ShortestPaths"); rb_include_module(cIGraph, cIGraph_shortestpaths); rb_define_method(cIGraph_shortestpaths, "shortest_paths", cIGraph_shortest_paths, 2); /* in cIGraph_shortest_paths.c */ rb_define_method(cIGraph_shortestpaths, "get_shortest_paths", cIGraph_get_shortest_paths, 3); /* in cIGraph_shortest_paths.c */ rb_define_method(cIGraph_shortestpaths, "get_all_shortest_paths", cIGraph_get_all_shortest_paths, 3); /* in cIGraph_shortest_paths.c */ rb_define_method(cIGraph_shortestpaths, "average_path_length", cIGraph_average_path_length, 2); /* in cIGraph_shortest_paths.c */ rb_define_method(cIGraph_shortestpaths, "diameter", cIGraph_diameter, 2); /* in cIGraph_shortest_paths.c */ rb_define_method(cIGraph_shortestpaths, "girth", cIGraph_girth, 0); /* in cIGraph_shortest_paths.c */ rb_define_method(cIGraph_shortestpaths, "dijkstra_shortest_paths", cIGraph_dijkstra_shortest_paths, 3); /* in cIGraph_dijkstra.c */ /* Functions for querying the neighborhood of vertices */ cIGraph_neighborhoodm = rb_define_module_under(cIGraph, "Neighborhood"); rb_include_module(cIGraph, cIGraph_neighborhoodm); rb_define_method(cIGraph_neighborhoodm, "neighbourhood_size", cIGraph_neighborhood_size, 3); /* in cIGraph_vertex_neighbourhood.c */ rb_define_method(cIGraph_neighborhoodm, "neighbourhood", cIGraph_neighborhood, 3); /* in cIGraph_vertex_neighbourhood.c */ rb_define_method(cIGraph_neighborhoodm, "neighbourhood_graphs", cIGraph_neighborhood_graphs, 3); /* in cIGraph_vertex_neighbourhood.c */ rb_define_alias (cIGraph_neighborhoodm, "neighborhood_size", "neighbourhood_size"); rb_define_alias (cIGraph_neighborhoodm, "neighborhood", "neighbourhood"); rb_define_alias (cIGraph_neighborhoodm, "neighborhood_graphs", "neighbourhood_graphs"); rb_define_method(cIGraph_neighborhoodm, "connect_neighborhood", cIGraph_connect_neighborhood, 2); /* in cIGraph_generators_deterministic.c */ /* Functions for splitting the graph into components */ cIGraph_components = rb_define_module_under(cIGraph, "Components"); rb_include_module(cIGraph, cIGraph_components); rb_define_method(cIGraph_components, "subcomponent", cIGraph_subcomponent, 2); /* in cIGraph_components.c */ rb_define_method(cIGraph_components, "subgraph", cIGraph_subgraph, 1); /* in cIGraph_components.c */ rb_define_method(cIGraph_components, "clusters", cIGraph_clusters, 1); /* in cIGraph_components.c */ rb_define_method(cIGraph_components, "decompose", cIGraph_decompose, -1); /* in cIGraph_components.c */ /* Graph centrality functions */ cIGraph_closenessm = rb_define_module_under(cIGraph, "Closeness"); rb_include_module(cIGraph, cIGraph_closenessm); rb_define_method(cIGraph_closenessm, "closeness", cIGraph_closeness, 2); /* in cIGraph_centrality.c */ rb_define_method(cIGraph_closenessm, "betweenness", cIGraph_betweenness, 2); /* in cIGraph_centrality.c */ rb_define_method(cIGraph_closenessm, "edge_betweenness", cIGraph_edge_betweenness, 1); /* in cIGraph_centrality.c */ rb_define_method(cIGraph_closenessm, "pagerank", cIGraph_pagerank, 5); /* in cIGraph_centrality.c */ rb_define_method(cIGraph_closenessm, "constraint", cIGraph_constraint, -1); /* in cIGraph_centrality.c */ rb_define_method(cIGraph_closenessm, "maxdegree", cIGraph_maxdegree, 3); /* in cIGraph_centrality.c */ /* Minimum spanning tree functions */ cIGraph_spanning = rb_define_module_under(cIGraph, "Spanning"); rb_include_module(cIGraph, cIGraph_spanning); rb_define_method(cIGraph_spanning, "minimum_spanning_tree_unweighted", cIGraph_minimum_spanning_tree_unweighted, 0); /* in cIGraph_spanning.c */ rb_define_method(cIGraph_spanning, "minimum_spanning_tree_prim", cIGraph_minimum_spanning_tree_prim, 1); /* in cIGraph_spanning.c */ /* Graph transitivity functions */ cIGraph_transitivitym = rb_define_module_under(cIGraph, "Transitivity"); rb_include_module(cIGraph, cIGraph_transitivitym); rb_define_method(cIGraph_transitivitym, "transitivity", cIGraph_transitivity, 0); /* in cIGraph_transitivity.c */ rb_define_method(cIGraph_transitivitym, "transitivity_local", cIGraph_transitivity_local, 1); /* in cIGraph_transitivity.c */ rb_define_method(cIGraph_transitivitym, "transitivity_avglocal", cIGraph_transitivity_avglocal, 0); /* in cIGraph_transitivity.c */ /* Functions for the Laplacian matrix. */ cIGraph_spectral = rb_define_module_under(cIGraph, "Spectral"); rb_include_module(cIGraph, cIGraph_spectral); rb_define_method(cIGraph_spectral, "laplacian", cIGraph_laplacian, 1); /* in cIGraph_spectral.c */ /* Functions for finding the coreness of a graph */ cIGraph_kcore = rb_define_module_under(cIGraph, "KCores"); rb_include_module(cIGraph, cIGraph_kcore); rb_define_method(cIGraph_kcore, "coreness", cIGraph_coreness, 1); /* in cIGraph_kcores.c */ /* Other general graph operations */ cIGraph_otherop = rb_define_module_under(cIGraph, "OtherOperations"); rb_include_module(cIGraph, cIGraph_otherop); rb_define_method(cIGraph_otherop, "density", cIGraph_density, 1); /* in cIGraph_other_ops.c */ rb_define_method(cIGraph_otherop, "simplify", cIGraph_simplify, 2); /* in cIGraph_other_ops.c */ rb_define_method(cIGraph_otherop, "reciprocity", cIGraph_reciprocity, 1); /* in cIGraph_other_ops.c */ rb_define_method(cIGraph_otherop, "bibcoupling", cIGraph_bibcoupling, 1); /* in cIGraph_other_ops.c */ rb_define_method(cIGraph_otherop, "cocitation", cIGraph_cocitation, 1); /* in cIGraph_other_ops.c */ rb_define_method(cIGraph_otherop, "get_adjacency", cIGraph_get_adjacency, 1); /* in cIGraph_other_ops.c */ /* Clique finding functions */ cIGraph_clique = rb_define_module_under(cIGraph, "Cliques"); rb_include_module(cIGraph, cIGraph_clique); rb_define_method(cIGraph_clique, "cliques", cIGraph_cliques, 2); /* in cIGraph_cliques.c */ rb_define_method(cIGraph_clique, "largest_cliques", cIGraph_largest_cliques, 0); /* in cIGraph_cliques.c */ rb_define_method(cIGraph_clique, "maximal_cliques", cIGraph_maximal_cliques, 0); /* in cIGraph_cliques.c */ rb_define_method(cIGraph_clique, "clique_number", cIGraph_clique_number, 0); /* in cIGraph_cliques.c */ /* Independent vertex set finding functions */ cIGraph_indyver = rb_define_module_under(cIGraph, "IndependentVertexSets"); rb_include_module(cIGraph, cIGraph_indyver); rb_define_method(cIGraph_indyver, "independent_vertex_sets", cIGraph_independent_vertex_sets, 2); /* in cIGraph_independent_vertex_sets.c */ rb_define_method(cIGraph_indyver, "largest_independent_vertex_sets", cIGraph_largest_independent_vertex_sets, 0); /* in cIGraph_independent_vertex_sets.c */ rb_define_method(cIGraph_indyver, "maximal_independent_vertex_sets", cIGraph_maximal_independent_vertex_sets, 0); /* in cIGraph_independent_vertex_sets.c */ rb_define_method(cIGraph_indyver, "independence_number", cIGraph_independence_number, 0); /* in cIGraph_independent_vertex_sets.c */ /* Functions for isomorphism and isoclasses */ cIGraph_isomor = rb_define_module_under(cIGraph, "Isomorphism"); rb_include_module(cIGraph, cIGraph_isomor); rb_define_method(cIGraph_isomor, "isomorphic", cIGraph_isomorphic, 1); /* in cIGraph_isomorphism.c */ rb_define_method(cIGraph_isomor, "isomorphic_vf2", cIGraph_isomorphic_vf2, 1); /* in cIGraph_isomorphism.c */ rb_define_method(cIGraph_isomor, "isoclass", cIGraph_isoclass, 0); /* in cIGraph_isomorphism.c */ rb_define_method(cIGraph_isomor, "isoclass_subgraph", cIGraph_isoclass_subgraph, 1); /* in cIGraph_isomorphism.c */ rb_define_singleton_method(cIGraph_generate, "isoclass_create", cIGraph_isoclass_create, 3); /* in cIGraph_isomorphism.c */ /* Motif finding functions */ cIGraph_motifs = rb_define_module_under(cIGraph, "Motifs"); rb_include_module(cIGraph, cIGraph_motifs); rb_define_method(cIGraph_motifs, "motifs_randesu", cIGraph_motifs_randesu, 2); /* in cIGraph_motif.c */ rb_define_method(cIGraph_motifs, "motifs_randesu_no", cIGraph_motifs_randesu_no, 2); /* in cIGraph_motif.c */ rb_define_method(cIGraph_motifs, "motifs_randesu_estimate", cIGraph_motifs_randesu_estimate, 4); /* in cIGraph_motif.c */ /* Graph sorting functions. */ cIGraph_sorting = rb_define_module_under(cIGraph, "Sorting"); rb_include_module(cIGraph, cIGraph_sorting); rb_define_method(cIGraph_sorting, "topological_sorting", cIGraph_topological_sorting, 1); /* in cIGraph_topological_sort.c */ /* Functions for reading graphs from files */ cIGraph_fileread = rb_define_module_under(cIGraph, "FileRead"); rb_include_module(cIGraph, cIGraph_fileread); #ifdef __APPLE__ rb_define_singleton_method(cIGraph_fileread, "read_graph_edgelist", cIGraph_unavailable_method, -1); rb_define_singleton_method(cIGraph_fileread, "read_graph_graphml", cIGraph_unavailable_method, -1); rb_define_singleton_method(cIGraph_fileread, "read_graph_ncol", cIGraph_unavailable_method, -1); rb_define_singleton_method(cIGraph_fileread, "read_graph_lgl", cIGraph_unavailable_method, -1); rb_define_singleton_method(cIGraph_fileread, "read_graph_dimacs", cIGraph_unavailable_method, -1); rb_define_singleton_method(cIGraph_fileread, "read_graph_graphdb", cIGraph_unavailable_method, -1); rb_define_singleton_method(cIGraph_fileread, "read_graph_gml", cIGraph_unavailable_method, -1); rb_define_singleton_method(cIGraph_fileread, "read_graph_pajek", cIGraph_unavailable_method, -1); #else rb_define_singleton_method(cIGraph_fileread, "read_graph_edgelist", cIGraph_read_graph_edgelist, 2); /* in cIGraph_file.c */ rb_define_singleton_method(cIGraph_fileread, "read_graph_graphml", cIGraph_read_graph_graphml, 2); /* in cIGraph_file.c */ rb_define_singleton_method(cIGraph_fileread, "read_graph_ncol", cIGraph_read_graph_ncol, 5); /* in cIGraph_file.c */ rb_define_singleton_method(cIGraph_fileread, "read_graph_lgl", cIGraph_read_graph_lgl, 3); /* in cIGraph_file.c */ rb_define_singleton_method(cIGraph_fileread, "read_graph_dimacs", cIGraph_read_graph_dimacs, 2); /* in cIGraph_file.c */ rb_define_singleton_method(cIGraph_fileread, "read_graph_graphdb", cIGraph_read_graph_graphdb, 2); /* in cIGraph_file.c */ rb_define_singleton_method(cIGraph_fileread, "read_graph_gml", cIGraph_read_graph_gml, 1); /* in cIGraph_file.c */ rb_define_singleton_method(cIGraph_fileread, "read_graph_pajek", cIGraph_read_graph_pajek, 2); /* in cIGraph_file.c */ #endif /* Functions for writing graphs to files */ cIGraph_filewrite = rb_define_module_under(cIGraph, "FileWrite"); rb_include_module(cIGraph, cIGraph_filewrite); #ifdef __APPLE__ rb_define_method(cIGraph_filewrite, "write_graph_edgelist", cIGraph_unavailable_method, -1); rb_define_method(cIGraph_filewrite, "write_graph_graphml", cIGraph_unavailable_method, -1); rb_define_method(cIGraph_filewrite, "write_graph_gml", cIGraph_unavailable_method, -1); rb_define_method(cIGraph_filewrite, "write_graph_ncol", cIGraph_unavailable_method, -1); rb_define_method(cIGraph_filewrite, "write_graph_lgl", cIGraph_unavailable_method, -1); rb_define_method(cIGraph_filewrite, "write_graph_dimacs", cIGraph_unavailable_method, -1); rb_define_method(cIGraph_filewrite, "write_graph_pajek", cIGraph_unavailable_method, -1); #else rb_define_method(cIGraph_filewrite, "write_graph_edgelist", cIGraph_write_graph_edgelist, 1); /* in cIGraph_file.c */ rb_define_method(cIGraph_filewrite, "write_graph_graphml", cIGraph_write_graph_graphml, 1); /* in cIGraph_file.c */ rb_define_method(cIGraph_filewrite, "write_graph_gml", cIGraph_write_graph_gml, 1); /* in cIGraph_file.c */ rb_define_method(cIGraph_filewrite, "write_graph_ncol", cIGraph_write_graph_ncol, 3); /* in cIGraph_file.c */ rb_define_method(cIGraph_filewrite, "write_graph_lgl", cIGraph_write_graph_lgl, 4); /* in cIGraph_file.c */ rb_define_method(cIGraph_filewrite, "write_graph_dimacs", cIGraph_write_graph_dimacs, 4); /* in cIGraph_file.c */ rb_define_method(cIGraph_filewrite, "write_graph_pajek", cIGraph_write_graph_pajek, 1); /* in cIGraph_file.c */ #endif /* Graph layout functions */ cIGraph_layout = rb_define_module_under(cIGraph, "Layout"); rb_include_module(cIGraph, cIGraph_layout); rb_define_method(cIGraph_layout, "layout_random", cIGraph_layout_random, 0); /* in cIGraph_layout.c */ rb_define_method(cIGraph_layout, "layout_circle", cIGraph_layout_circle, 0); /* in cIGraph_layout.c */ rb_define_method(cIGraph_layout, "layout_fruchterman_reingold", cIGraph_layout_fruchterman_reingold, 6); /* in cIGraph_layout.c */ rb_define_method(cIGraph_layout, "layout_kamada_kawai", cIGraph_layout_kamada_kawai, 5); /* in cIGraph_layout.c */ rb_define_method(cIGraph_layout, "layout_reingold_tilford", cIGraph_layout_reingold_tilford, 1); /* in cIGraph_layout.c */ rb_define_method(cIGraph_layout, "layout_reingold_tilford_circular", cIGraph_layout_reingold_tilford_circular, 1); /* in cIGraph_layout.c */ rb_define_method(cIGraph_layout, "layout_grid_fruchterman_reingold", cIGraph_layout_grid_fruchterman_reingold, 7); /* in cIGraph_layout.c */ rb_define_method(cIGraph_layout, "layout_lgl", cIGraph_layout_lgl, 7); /* in cIGraph_layout.c */ rb_define_method(cIGraph_layout, "layout_random_3d", cIGraph_layout_random_3d, 0); /* in cIGraph_layout3d.c */ rb_define_method(cIGraph_layout, "layout_sphere", cIGraph_layout_sphere, 0); /* in cIGraph_layout3d.c */ rb_define_method(cIGraph_layout, "layout_fruchterman_reingold_3d", cIGraph_layout_fruchterman_reingold_3d, 5); /* in cIGraph_layout3d.c */ rb_define_method(cIGraph_layout, "layout_kamada_kawai_3d", cIGraph_layout_kamada_kawai_3d, 5); /* in cIGraph_layout3d.c */ rb_define_singleton_method(cIGraph_layout, "layout_merge_dla", cIGraph_layout_merge_dla, 2); /* in cIGraph_layout.c */ /* Minimum cuts related functions */ cIGraph_mincuts = rb_define_module_under(cIGraph, "MinimumCuts"); rb_include_module(cIGraph, cIGraph_mincuts); rb_define_method(cIGraph_mincuts, "maxflow_value", cIGraph_maxflow_value, 3); /* in cIGraph_min_cuts.c */ rb_define_method(cIGraph_mincuts, "st_mincut_value", cIGraph_st_mincut_value, 3); /* in cIGraph_min_cuts.c */ rb_define_method(cIGraph_mincuts, "mincut_value", cIGraph_mincut_value, 1); /* in cIGraph_min_cuts.c */ rb_define_method(cIGraph_mincuts, "mincut", cIGraph_mincut, 1); /* in cIGraph_min_cuts.c */ /* Vertex and edge connectivity functions */ cIGraph_connectivity = rb_define_module_under(cIGraph, "Connectivity"); rb_include_module(cIGraph, cIGraph_connectivity); rb_define_method(cIGraph_connectivity, "st_edge_connectivity", cIGraph_st_edge_connectivity, 2); /* in cIGraph_connectivity.c */ rb_define_method(cIGraph_connectivity, "edge_connectivity", cIGraph_edge_connectivity, 0); /* in cIGraph_connectivity.c */ rb_define_method(cIGraph_connectivity, "st_vertex_connectivity", cIGraph_st_vertex_connectivity, 3); /* in cIGraph_connectivity.c */ rb_define_method(cIGraph_connectivity, "vertex_connectivity", cIGraph_vertex_connectivity, 0); /* in cIGraph_connectivity.c */ rb_define_method(cIGraph_connectivity, "edge_disjoint_paths", cIGraph_edge_disjoint_paths, 2); /* in cIGraph_connectivity.c */ rb_define_method(cIGraph_connectivity, "vertex_disjoint_paths", cIGraph_vertex_disjoint_paths, 2); /* in cIGraph_connectivity.c */ rb_define_method(cIGraph_connectivity, "adhesion", cIGraph_adhesion, 0); /* in cIGraph_connectivity.c */ rb_define_method(cIGraph_connectivity, "cohesion", cIGraph_cohesion, 0); /* in cIGraph_connectivity.c */ /* Community and modularity related functions */ cIGraph_community = rb_define_module_under(cIGraph, "Community"); rb_include_module(cIGraph, cIGraph_community); rb_define_method(cIGraph_community, "modularity", cIGraph_modularity, 1); /* in cIGraph_community.c */ rb_define_method(cIGraph_community, "community_to_membership", cIGraph_community_to_membership, 3); /* in cIGraph_community.c */ rb_define_method(cIGraph_community, "community_spinglass", cIGraph_community_spinglass, 8); /* in cIGraph_community.c */ rb_define_method(cIGraph_community, "community_spinglass_single", cIGraph_community_spinglass_single, 5); /* in cIGraph_community.c */ rb_define_method(cIGraph_community, "community_leading_eigenvector", cIGraph_community_leading_eigenvector, 1); /* in cIGraph_community.c */ rb_define_method(cIGraph_community, "community_leading_eigenvector_naive", cIGraph_community_leading_eigenvector_naive, 1); /* in cIGraph_community.c */ rb_define_method(cIGraph_community, "community_leading_eigenvector_step", cIGraph_community_leading_eigenvector_step, 2); /* in cIGraph_community.c */ rb_define_method(cIGraph_community, "community_walktrap", cIGraph_community_walktrap, 2); /* in cIGraph_community.c */ rb_define_method(cIGraph_community, "community_edge_betweenness", cIGraph_community_edge_betweenness, 1); /* in cIGraph_community.c */ rb_define_method(cIGraph_community, "community_eb_get_merges", cIGraph_community_eb_get_merges, 1); /* in cIGraph_community.c */ rb_define_method(cIGraph_community, "community_fastgreedy", cIGraph_community_fastgreedy, 0); /* in cIGraph_community.c */ rb_define_const(cIGraph, "VERSION", rb_str_new2("0.9.1")); rb_define_const(cIGraph, "EDGEORDER_ID", INT2NUM(1)); rb_define_const(cIGraph, "EDGEORDER_FROM", INT2NUM(2)); rb_define_const(cIGraph, "EDGEORDER_TO", INT2NUM(3)); rb_define_const(cIGraph, "OUT", INT2NUM(1)); rb_define_const(cIGraph, "IN", INT2NUM(2)); rb_define_const(cIGraph, "ALL", INT2NUM(3)); rb_define_const(cIGraph, "TOTAL", INT2NUM(4)); rb_define_const(cIGraph_components, "WEAK", INT2NUM(1)); rb_define_const(cIGraph_components, "STRONG", INT2NUM(2)); rb_define_const(cIGraph, "ARBITRARY", INT2NUM(0)); rb_define_const(cIGraph, "MUTUAL", INT2NUM(1)); rb_define_const(cIGraph, "EACH", INT2NUM(0)); rb_define_const(cIGraph, "COLLAPSE", INT2NUM(1)); rb_define_const(cIGraph_otherop, "GET_ADJACENCY_UPPER", INT2NUM(0)); rb_define_const(cIGraph_otherop, "GET_ADJACENCY_LOWER", INT2NUM(1)); rb_define_const(cIGraph_otherop, "GET_ADJACENCY_BOTH", INT2NUM(2)); rb_define_const(cIGraph, "ERDOS_RENYI_GNP", INT2NUM(0)); rb_define_const(cIGraph, "ERDOS_RENYI_GNM", INT2NUM(1)); rb_define_const(cIGraph_generate, "ADJ_DIRECTED", INT2NUM(0)); rb_define_const(cIGraph_generate, "ADJ_UNDIRECTED", INT2NUM(1)); rb_define_const(cIGraph_generate, "ADJ_MAX", INT2NUM(2)); rb_define_const(cIGraph_generate, "ADJ_MIN", INT2NUM(3)); rb_define_const(cIGraph_generate, "ADJ_PLUS", INT2NUM(4)); rb_define_const(cIGraph_generate, "ADJ_UPPER", INT2NUM(5)); rb_define_const(cIGraph_generate, "ADJ_LOWER", INT2NUM(6)); rb_define_const(cIGraph_generate, "STAR_OUT", INT2NUM(0)); rb_define_const(cIGraph_generate, "STAR_IN", INT2NUM(1)); rb_define_const(cIGraph_generate, "STAR_UNDIRECTED", INT2NUM(2)); rb_define_const(cIGraph_generate, "TREE_OUT", INT2NUM(0)); rb_define_const(cIGraph_generate, "TREE_IN", INT2NUM(1)); rb_define_const(cIGraph_generate, "TREE_UNDIRECTED", INT2NUM(2)); rb_define_const(cIGraph_connectivity, "VCONN_NEI_ERROR", INT2NUM(0)); rb_define_const(cIGraph_connectivity, "VCONN_NEI_INFINITY", INT2NUM(1)); rb_define_const(cIGraph_connectivity, "VCONN_NEI_IGNORE", INT2NUM(2)); rb_define_const(cIGraph_community, "SPINCOMM_UPDATE_SIMPLE", INT2NUM(0)); rb_define_const(cIGraph_community, "SPINCOMM_UPDATE_CONFIG", INT2NUM(1)); /* This class wraps the igraph matrix type. It can be created from and * converted to an Array of Ruby Arrays. */ cIGraphMatrix = rb_define_class("IGraphMatrix", rb_cObject); rb_define_alloc_func(cIGraphMatrix, cIGraph_matrix_alloc); rb_define_method(cIGraphMatrix, "initialize", cIGraph_matrix_initialize, -1); /* in cIGraph_matrix.c */ rb_define_method(cIGraphMatrix, "initialize_copy", cIGraph_matrix_init_copy, 1); /* in cIGraph_matrix.c */ //rb_define_singleton_method(cIGraphMatrix, "[]", cIGraph_matrix_initialize, -1); rb_include_module(cIGraphMatrix, rb_mEnumerable); rb_define_method (cIGraphMatrix, "each", cIGraph_matrix_each,0); /* in cIGraph_matrix.c */ rb_define_method(cIGraphMatrix, "[]", cIGraph_matrix_get, 2); /* in cIGraph_matrix.c */ rb_define_method(cIGraphMatrix, "[]=", cIGraph_matrix_set, 3); /* in cIGraph_matrix.c */ rb_define_method(cIGraphMatrix, "size", cIGraph_matrix_size, 0); /* in cIGraph_matrix.c */ rb_define_method(cIGraphMatrix, "nrow", cIGraph_matrix_nrow, 0); /* in cIGraph_matrix.c */ rb_define_method(cIGraphMatrix, "ncol", cIGraph_matrix_ncol, 0); /* in cIGraph_matrix.c */ rb_define_method(cIGraphMatrix, "max", cIGraph_matrix_max, 0); /* in cIGraph_matrix.c */ rb_define_method(cIGraphMatrix, "*", cIGraph_matrix_scale, 1); /* in cIGraph_matrix.c */ rb_define_method(cIGraphMatrix, "to_a", cIGraph_matrix_toa, 0); /* in cIGraph_matrix.c */ }
int main() { igraph_t g; igraph_vector_t v, v2; int i, ret; igraph_barabasi_game(&g, 10, 2, 0, 0, 1); if (igraph_ecount(&g) != 18) { return 1; } if (igraph_vcount(&g) != 10) { return 2; } if (!igraph_is_directed(&g)) { return 3; } igraph_vector_init(&v, 0); igraph_get_edgelist(&g, &v, 0); for (i=0; i<igraph_ecount(&g); i++) { if (VECTOR(v)[2*i] <= VECTOR(v)[2*i+1]) { return 4; } } igraph_destroy(&g); /* out degree sequence */ igraph_vector_resize(&v, 10); VECTOR(v)[0]=0; VECTOR(v)[1]=1; VECTOR(v)[2]=3; VECTOR(v)[3]=3; VECTOR(v)[4]=4; VECTOR(v)[5]=5; VECTOR(v)[6]=6; VECTOR(v)[7]=7; VECTOR(v)[8]=8; VECTOR(v)[9]=9; igraph_barabasi_game(&g, 10, 0, &v, 0, 1); if (igraph_ecount(&g) != igraph_vector_sum(&v)) { return 5; } igraph_vector_init(&v2, 0); igraph_degree(&g, &v2, igraph_vss_all(), IGRAPH_OUT, 1); for (i=0; i<igraph_vcount(&g); i++) { if (VECTOR(v)[i] != VECTOR(v2)[i]) { return 6; } } igraph_vector_destroy(&v); igraph_vector_destroy(&v2); igraph_destroy(&g); /* outpref, we cannot really test this quantitatively, would need to set random seed */ igraph_barabasi_game(&g, 10, 2, 0, 1, 1); igraph_vector_init(&v, 0); igraph_get_edgelist(&g, &v, 0); for (i=0; i<igraph_ecount(&g); i++) { if (VECTOR(v)[2*i] <= VECTOR(v)[2*i+1]) { return 7; } } if (!igraph_is_directed(&g)) { return 8; } igraph_vector_destroy(&v); igraph_destroy(&g); /* Error tests */ igraph_set_error_handler(igraph_error_handler_ignore); ret=igraph_barabasi_game(&g, -10, 1, 0, 0, 0); if (ret != IGRAPH_EINVAL) { return 9; } ret=igraph_barabasi_game(&g, 10, -2, 0, 0, 0); if (ret != IGRAPH_EINVAL) { return 10; } igraph_vector_init(&v, 9); ret=igraph_barabasi_game(&g, 10, 0, &v, 0, 0); if (ret != IGRAPH_EINVAL) { return 11; } igraph_vector_destroy(&v); return 0; }
//------------------------------------------------------------------------------------------------- int main(int argc, char **argv) { igraph_set_error_handler(igraph_error_handler_printignore); igraph_i_set_attribute_table(&igraph_cattribute_table); drawingcontrol=1; runningcontrol=0; cleared=1; graphisloaded=0; newgraph=1; usesteady=0; ispii=0; haveout=0; isrelaxed=0; havecstop=0; isdissipating=0; //RANDOM NUMBER GENERATOR INITIALISE init_genrand(0); //srand(3); //preloaded graph: { latticedim=2; latticeside=5; istoro=1; islattice=1; isclustered=0; israndomER1=0; generatelattice(2,5,1,0,0,0,0); //inizializations igraph_matrix_init(&state, 0, 0); igraph_matrix_init(&density, 0, 0); igraph_matrix_init(&densityold,0,0); igraph_matrix_init(&statenew, 0, 0); igraph_matrix_init(&flux, 0, 0); igraph_matrix_init(&loss, 0, 0); beginner=(nodesnumber/2); InitialStateTAS(beginner,0,totrun); igraph_vector_init(&gain,nodesnumber); graphisloaded=1; newgraph=1; haveloadedstate=0; drnodes=1; drlinks=1; drfluxes=0; } havepath=0; sprintf(path,"No path"); logDebug("\n DEFAULT ADJ MATRIX:\n"); print_matrix_ur(&admatrix,stdout); printf("\n"); printf("\n"); rewrite=1; CreateMyWindow(); //Fl::add_timeout(1.0,mainidle_cb); Fl::add_idle(mainidle_cb, 0); Fl::run(); histdist.Clear(); igraph_destroy(&graph); igraph_destroy(&sgraph); igraph_matrix_destroy(&admatrix); igraph_matrix_destroy(&layout); igraph_matrix_destroy(&density); igraph_matrix_destroy(&densityold); igraph_matrix_destroy(&state); igraph_matrix_destroy(&loadedstate); igraph_matrix_destroy(&statenew); igraph_matrix_destroy(&flux); igraph_vector_destroy(&gain); igraph_matrix_destroy(&loss); igraph_vector_destroy(&statstate); igraph_matrix_destroy(&estates); closeout(); return 0; }
int check_multi() { igraph_t g; igraph_vector_t vec; igraph_vector_t eids, eids2; int ret; long int i; igraph_real_t q1[] = { 0,1, 0,1 }; igraph_real_t q2[] = { 0,1, 0,1, 0,1 }; igraph_real_t q3[] = { 1,0, 3,4, 1,0, 0,1, 3,4, 0,1 }; igraph_vector_init(&eids, 0); /*********************************/ igraph_small(&g, /*n=*/ 10, /*directed=*/ 1, 0,1, 0,1, 1,0, 1,2, 3,4, 3,4, 3,4, 3,5, 3,7, 9,8, -1); igraph_vector_view(&vec, q1, sizeof(q1) / sizeof(igraph_real_t)); igraph_get_eids_multi(&g, &eids, &vec, 0, /*directed=*/ 1, /*error=*/ 1); igraph_vector_sort(&eids); print_vector(&eids, stdout); igraph_vector_view(&vec, q2, sizeof(q2) / sizeof(igraph_real_t)); igraph_get_eids_multi(&g, &eids, &vec, 0, /*directed=*/ 0, /*error=*/ 1); igraph_vector_sort(&eids); print_vector(&eids, stdout); igraph_vector_view(&vec, q2, sizeof(q2) / sizeof(igraph_real_t)); igraph_set_error_handler(igraph_error_handler_ignore); ret=igraph_get_eids_multi(&g, &eids, &vec, 0, /*directed=*/ 1, /*error=*/1); if (ret != IGRAPH_EINVAL) { return 1; } igraph_set_error_handler(igraph_error_handler_abort); igraph_destroy(&g); /*********************************/ /*********************************/ igraph_small(&g, /*n=*/10, /*directed=*/0, 0,1, 1,0, 0,1, 3,4, 3,4, 5,4, 9,8, -1); igraph_vector_view(&vec, q1, sizeof(q1) / sizeof(igraph_real_t)); igraph_get_eids_multi(&g, &eids, &vec, 0, /*directed=*/1, /*error=*/ 1); igraph_vector_sort(&eids); print_vector(&eids, stdout); igraph_vector_view(&vec, q3, sizeof(q3) / sizeof(igraph_real_t)); igraph_set_error_handler(igraph_error_handler_ignore); ret=igraph_get_eids_multi(&g, &eids, &vec, 0, /*directed=*/0, /*error=*/ 1); if (ret != IGRAPH_EINVAL) { return 2; } igraph_set_error_handler(igraph_error_handler_abort); igraph_destroy(&g); /*********************************/ igraph_vector_destroy(&eids); /*********************************/ /* Speed tests */ #define NODES 10000 igraph_barabasi_game(&g, /*n=*/ NODES, /*power=*/ 1.0, /*m=*/ 3, /*outseq=*/ 0, /*outpref=*/ 0, /*A=*/ 1, /*directed=*/ 1, IGRAPH_BARABASI_BAG, /*start_from=*/ 0); igraph_simplify(&g, /*multiple=*/ 1, /*loops=*/ 0, /*edge_comb=*/ 0); igraph_vector_init(&eids, NODES/2); igraph_random_sample(&eids, 0, igraph_ecount(&g)-1, NODES/2); igraph_vector_init(&vec, NODES); for (i=0; i<NODES/2; i++) { VECTOR(vec)[2*i] = IGRAPH_FROM(&g, VECTOR(eids)[i]); VECTOR(vec)[2*i+1] = IGRAPH_TO(&g, VECTOR(eids)[i]); } igraph_vector_init(&eids2, 0); igraph_get_eids_multi(&g, &eids2, &vec, 0, /*directed=*/ 1, /*error=*/ 1); if (!igraph_vector_all_e(&eids, &eids2)) { return 3; } /**/ for (i=0; i<NODES/2; i++) { VECTOR(vec)[2*i] = IGRAPH_TO(&g, VECTOR(eids)[i]); VECTOR(vec)[2*i+1] = IGRAPH_FROM(&g, VECTOR(eids)[i]); } igraph_get_eids_multi(&g, &eids2, &vec, 0, /*directed=*/ 0, /*error=*/ 1); if (!igraph_vector_all_e(&eids, &eids2)) { return 4; } igraph_vector_destroy(&eids); igraph_vector_destroy(&eids2); igraph_vector_destroy(&vec); igraph_destroy(&g); /*********************************/ return 0; }