int main() { igraph_t g; igraph_vector_ptr_t vecs; long int i; igraph_vs_t vs; igraph_ring(&g, 10, IGRAPH_DIRECTED, 0, 1); igraph_vector_ptr_init(&vecs, 5); for (i=0; i<igraph_vector_ptr_size(&vecs); i++) { VECTOR(vecs)[i] = calloc(1, sizeof(igraph_vector_t)); igraph_vector_init(VECTOR(vecs)[i], 0); } igraph_vs_vector_small(&vs, 1, 3, 5, 2, 1, -1); igraph_get_shortest_paths(&g, &vecs, 0, vs, IGRAPH_OUT); for (i=0; i<igraph_vector_ptr_size(&vecs); i++) { print_vector(VECTOR(vecs)[i]); igraph_vector_destroy(VECTOR(vecs)[i]); free(VECTOR(vecs)[i]); } igraph_vector_ptr_destroy(&vecs); igraph_vs_destroy(&vs); igraph_destroy(&g); return 0; }
void igraph_vector_ptr_null (igraph_vector_ptr_t* v) { assert(v != NULL); assert(v->stor_begin != NULL); if (igraph_vector_ptr_size(v)>0) { memset(v->stor_begin, 0, sizeof(void*) * (size_t) igraph_vector_ptr_size(v)); } }
int main() { igraph_t g; igraph_vector_ptr_t result; igraph_es_t es; igraph_integer_t omega; long int i, j, n; const int params[] = {4, -1, 2, 2, 0, 0, -1, -1}; igraph_set_warning_handler(warning_handler_ignore); igraph_vector_ptr_init(&result, 0); igraph_full(&g, 6, 0, 0); igraph_es_pairs_small(&es, 0, 0, 1, 0, 2, 3, 5, -1); igraph_delete_edges(&g, es); igraph_es_destroy(&es); for (j=0; j<sizeof(params)/(2*sizeof(params[0])); j++) { if (params[2*j+1] != 0) { igraph_cliques(&g, &result, params[2*j], params[2*j+1]); } else { igraph_largest_cliques(&g, &result); } n = igraph_vector_ptr_size(&result); printf("%ld cliques found\n", (long)n); canonicalize_list(&result); for (i=0; i<n; i++) { igraph_vector_t* v = (igraph_vector_t*) igraph_vector_ptr_e(&result,i); print_vector(v); igraph_vector_destroy(v); free(v); } } igraph_clique_number(&g, &omega); printf("omega=%ld\n", (long)omega); test_callback(&g); igraph_destroy(&g); igraph_tree(&g, 5, 2, IGRAPH_TREE_OUT); igraph_cliques(&g, &result, 5, 5); if (igraph_vector_ptr_size(&result) != 0) return 1; igraph_destroy(&g); igraph_vector_ptr_destroy(&result); return 0; }
/* For use with IGRAPH_FINALLY */ static void free_clique_list(igraph_vector_ptr_t *vp) { igraph_integer_t i, len; len = igraph_vector_ptr_size(vp); for (i=0; i < len; ++i) igraph_vector_destroy((igraph_vector_t *) VECTOR(*vp)[i]); igraph_vector_ptr_free_all(vp); }
int main() { igraph_t graph; igraph_vector_ptr_t separators; int i, n; igraph_small(&graph, 0, /*directed=*/ 0, 0,1,0,2, 1,3,1,4, 2,3,2,5, 3,4,3,5, 4,6, 5,6, -1); igraph_vector_ptr_init(&separators, 0); igraph_all_minimal_st_separators(&graph, &separators); n=igraph_vector_ptr_size(&separators); for (i=0; i<n; i++) { igraph_vector_t *sep=VECTOR(separators)[i]; igraph_vector_print(sep); igraph_vector_destroy(sep); igraph_free(sep); } igraph_vector_ptr_destroy(&separators); igraph_destroy(&graph); return 0; }
static int cliques_count_maximal_cliques(cliques *c) { unsigned int k; unsigned long int count; if (c == NULL) return -1; for (k = igraph_vector_ptr_size(&c->maximal_cliques_v_ptr) - 1; k >= 3; k--) { count = igraph_vector_ptr_size((igraph_vector_ptr_t*)VECTOR(c->maximal_cliques_v_ptr)[k]); if (count == 0) continue; printf("k: %i total: %li\n\n", k, count); VECTOR(c->maximal_cliques_count_v)[k] = count; c->maximal_cliques_total += count; } debug((DEBUG_NORMAL, "maximal_cliques_total %li", c->maximal_cliques_total)); return 0; }
int main() { igraph_t graph; igraph_vector_ptr_t separators; long int i, n; igraph_famous(&graph, "zachary"); igraph_vector_ptr_init(&separators, 0); igraph_all_minimal_st_separators(&graph, &separators); n=igraph_vector_ptr_size(&separators); for (i=0; i<n; i++) { igraph_bool_t res; igraph_vector_t *sep=VECTOR(separators)[i]; igraph_is_separator(&graph, igraph_vss_vector(sep), &res); if (!res) { printf("Vertex set %li is not a separator!\n", i); igraph_vector_print(sep); return 1; } } igraph_destroy(&graph); for (i=0; i<n; i++) { igraph_vector_t *v=VECTOR(separators)[i]; igraph_vector_destroy(v); igraph_Free(v); } igraph_vector_ptr_destroy(&separators); return 0; }
int igraph_attribute_combination_query(const igraph_attribute_combination_t *comb, const char *name, igraph_attribute_combination_type_t *type, void **func) { long int i, def=-1, len=igraph_vector_ptr_size(&comb->list); for (i=0; i<len; i++) { igraph_attribute_combination_record_t *rec=VECTOR(comb->list)[i]; const char *n=rec->name; if ( (!name && !n) || (name && n && !strcmp(n, name)) ) { *type=rec->type; *func=rec->func; return 0; } if (!n) { def=i; } } if (def==-1) { /* Did not find anything */ *type=IGRAPH_ATTRIBUTE_COMBINE_DEFAULT; *func=0; } else { igraph_attribute_combination_record_t *rec=VECTOR(comb->list)[def]; *type=rec->type; *func=rec->func; } return 0; }
int igraph_attribute_combination_remove(igraph_attribute_combination_t *comb, const char *name) { long int i, n=igraph_vector_ptr_size(&comb->list); /* Search, in case it is already there */ for (i=0; i<n; i++) { igraph_attribute_combination_record_t *r=VECTOR(comb->list)[i]; const char *n=r->name; if ( (!name && !n) || (name && n && !strcmp(n, name)) ) { break; } } if (i!=n) { igraph_attribute_combination_record_t *r=VECTOR(comb->list)[i]; if (r->name) { igraph_Free(r->name); } igraph_Free(r); igraph_vector_ptr_remove(&comb->list, i); } else { /* It is not there, we don't do anything */ } return 0; }
int igraph_i_largest_cliques_store(const igraph_vector_t* clique, void* data, igraph_bool_t* cont) { igraph_vector_ptr_t* result = (igraph_vector_ptr_t*)data; igraph_vector_t* vec; long int i, n; /* Is the current clique at least as large as the others that we have found? */ if (!igraph_vector_ptr_empty(result)) { n = igraph_vector_size(clique); if (n < igraph_vector_size(VECTOR(*result)[0])) return IGRAPH_SUCCESS; if (n > igraph_vector_size(VECTOR(*result)[0])) { for (i = 0; i < igraph_vector_ptr_size(result); i++) igraph_vector_destroy(VECTOR(*result)[i]); igraph_vector_ptr_free_all(result); igraph_vector_ptr_resize(result, 0); } } vec = igraph_Calloc(1, igraph_vector_t); if (vec == 0) IGRAPH_ERROR("cannot allocate memory for storing next clique", IGRAPH_ENOMEM); IGRAPH_CHECK(igraph_vector_copy(vec, clique)); IGRAPH_CHECK(igraph_vector_ptr_push_back(result, vec)); return IGRAPH_SUCCESS; }
/* call-seq: * graph.decompose(mode,maxcomp=-1,minelem=1) -> Array * * Create separate graph for each component of a graph. Returns an Array * of new IGraph object. mode specifies whether weakly and strongly connected * components are returned. Right now only the former is implemented. maxcomp * limits the number of components returned. Leave at the default -1 to return * all components. minelements specifies the minimum number of vertices a * component should contain before it is returned. Default 1 returns all * components. */ VALUE cIGraph_decompose(int argc, VALUE *argv, VALUE self){ igraph_t *graph; igraph_t *n_graph; igraph_vector_ptr_t components; VALUE mode,maxcomp, minelem, components_a; VALUE n_graph_obj; int i; rb_scan_args(argc,argv,"12", &mode, &maxcomp, &minelem); if(maxcomp == Qnil) maxcomp = INT2NUM(-1); if(minelem == Qnil) minelem = INT2NUM(1); igraph_vector_ptr_init(&components,0); Data_Get_Struct(self, igraph_t, graph); igraph_decompose(graph, &components, NUM2INT(mode), NUM2INT(maxcomp), NUM2INT(minelem)); components_a = rb_ary_new(); for(i=0; i<igraph_vector_ptr_size(&components); i++){ n_graph = VECTOR(components)[i]; n_graph_obj = Data_Wrap_Struct(cIGraph, cIGraph_mark, cIGraph_free, n_graph); rb_ary_push(components_a,n_graph_obj); } igraph_vector_ptr_destroy(&components); return components_a; }
/* Takes a pointer vector of vectors. Sorts each vector, then sorts the pointer vector */ void canonicalize_list(igraph_vector_ptr_t *list) { long i, len; len = igraph_vector_ptr_size(list); for (i=0; i<len; ++i) { igraph_vector_sort((igraph_vector_t *) VECTOR(*list)[i]); } qsort(&(VECTOR(*list)[0]), len, sizeof(void *), &compare_vectors); }
int main(int argc, char*argv[]) { // the graph is just a list og from to identifier pairs, one per line if (argc != 4) { fprintf (stderr, "Usage: %s <path to graph> <from id> <to id>\n", argv[0]); exit(1); } // 57572 DOCK6 // 7049 TGFBR3 // 2263 FGFBP3 igraph_vs_t vertex_to; igraph_integer_t vertex_from; vertex_from = atol(argv[2]); // in principle, unumber of "to" vertices is arbitrary, // but that is a piece of code I will write some other time //igraph_vs_vector_small(&vertex_to, 2263, 7049, -1); igraph_vs_vector_small(&vertex_to, atol(argv[3]), -1); igraph_t graph; /*The number of vertices in the graph. If smaller than the largest integer in the file it will be ignored. It is thus safe to supply zero here. */ igraph_integer_t zero = 0; FILE * infile = efopen(argv[1], "r") ; igraph_bool_t directed = IGRAPH_UNDIRECTED; igraph_read_graph_edgelist (&graph, infile, zero, directed); /* shortest path calculation: */ /* http://igraph.org/c/doc/igraph-Structural.html#igraph_get_all_shortest_paths int igraph_get_all_shortest_paths(const igraph_t *graph, igraph_vector_ptr_t *res, igraph_vector_t *nrgeo, igraph_integer_t from, const igraph_vs_t to, igraph_neimode_t mode); */ igraph_vector_ptr_t result; igraph_vector_t nrgeo; igraph_integer_t i; // the second argument here is the number of "to" vertices igraph_vector_ptr_init (&result, 1); igraph_vector_init(&nrgeo, 0); igraph_get_all_shortest_paths (&graph, &result, &nrgeo, vertex_from, vertex_to, IGRAPH_ALL); for (i=0; i<igraph_vector_ptr_size(&result); i++) { print_vector(VECTOR(result)[i]); } igraph_vector_ptr_destroy(&result); igraph_vs_destroy(&vertex_to); igraph_destroy(&graph); if (!IGRAPH_FINALLY_STACK_EMPTY) return 1; return 0; }
static int cliques_order_cliques_by_decreasing_k(cliques *c, const char *path) { unsigned int i, j, k; unsigned long int size; igraph_vector_t *k_clique_v; igraph_vector_ptr_t *maximal_k_cliques_v_ptr; FILE *output; if (c == NULL) return -1; cliques_count_maximal_cliques(c); igraph_vector_ptr_init(&c->plain_cliques_v_ptr, c->maximal_cliques_total); j = 0; for (k = igraph_vector_ptr_size(&c->maximal_cliques_v_ptr) - 1; k >= 3; k--) { maximal_k_cliques_v_ptr = (igraph_vector_ptr_t*) VECTOR(c->maximal_cliques_v_ptr)[k]; size = igraph_vector_ptr_size(maximal_k_cliques_v_ptr); if (size == 0) continue; // initialize the k_max if (c->k_max == 0) c->k_max = k; // for each size-maximal-clique store its pointer also in the // plain_cliques_v_ptr for (i = 0; i < size; i++) { k_clique_v = (igraph_vector_t*) VECTOR(*maximal_k_cliques_v_ptr)[i]; VECTOR(c->plain_cliques_v_ptr)[j++] = k_clique_v; } } // if path is not null try to write the previously computed // plain ordered list to the file specified by path if (path != NULL) { if ((output = fopen(path, "w")) == NULL) return -2; for (k = 0; k < c->maximal_cliques_total; k++) { k_clique_v = (igraph_vector_t*) VECTOR(c->plain_cliques_v_ptr)[k]; size = igraph_vector_size(k_clique_v); for (i = 0; i < size; i++) fprintf(output, "%li ", (long int) VECTOR(*k_clique_v)[i]); fprintf(output, "-1%s\n", ""); } fclose(output); } return 0; }
int igraph_vector_ptr_reserve (igraph_vector_ptr_t* v, long int size) { long int actual_size=igraph_vector_ptr_size(v); void **tmp; assert(v != NULL); assert(v->stor_begin != NULL); if (size <= igraph_vector_ptr_size(v)) { return 0; } tmp=igraph_Realloc(v->stor_begin, (size_t) size, void*); if (tmp==0) { IGRAPH_ERROR("vector ptr reserve failed", IGRAPH_ENOMEM); } v->stor_begin=tmp; v->stor_end=v->stor_begin + size; v->end=v->stor_begin+actual_size; return 0; }
void igraph_decompose_destroy(igraph_vector_ptr_t *complist) { long int i; for (i=0; i<igraph_vector_ptr_size(complist); i++) { if (VECTOR(*complist)[i] != 0) { igraph_destroy(VECTOR(*complist)[i]); igraph_free(VECTOR(*complist)[i]); } } }
void igraph_i_union_many_free3(igraph_vector_ptr_t *v) { long int i, n=igraph_vector_ptr_size(v); for (i=0; i<n; i++) { if (VECTOR(*v)[i] != 0) { igraph_vector_destroy(VECTOR(*v)[i]); igraph_Free(VECTOR(*v)[i]); } } }
void igraph_attribute_combination_destroy(igraph_attribute_combination_t *comb) { long int i, n=igraph_vector_ptr_size(&comb->list); for (i=0; i<n; i++) { igraph_attribute_combination_record_t *rec=VECTOR(comb->list)[i]; if (rec->name) { igraph_Free(rec->name); } igraph_Free(rec); } igraph_vector_ptr_destroy(&comb->list); }
void sort_cliques(igraph_vector_ptr_t *cliques) { int i, n=igraph_vector_ptr_size(cliques); for (i=0; i<n; i++) { igraph_vector_t *v=VECTOR(*cliques)[i]; igraph_vector_sort(v); } igraph_qsort(VECTOR(*cliques), (size_t) n, sizeof(igraph_vector_t *), sort_cmp); }
void print_and_destroy_cliques(igraph_vector_ptr_t *cliques) { int i; sort_cliques(cliques); for (i=0; i<igraph_vector_ptr_size(cliques); i++) { igraph_vector_t *v=VECTOR(*cliques)[i]; igraph_vector_print(v); igraph_vector_destroy(v); igraph_free(v); } }
/** * \ingroup vectorptr * \function igraph_vector_ptr_insert * \brief Inserts a single element into a pointer vector. * * Note that this function does not do range checking. Insertion will shift the * elements from the position given to the end of the vector one position to the * right, and the new element will be inserted in the empty space created at * the given position. The size of the vector will increase by one. * * \param v The pointer vector object. * \param pos The position where the new element is inserted. * \param e The inserted element */ int igraph_vector_ptr_insert(igraph_vector_ptr_t* v, long int pos, void* e) { long int size = igraph_vector_ptr_size(v); IGRAPH_CHECK(igraph_vector_ptr_resize(v, size+1)); if (pos<size) { memmove(v->stor_begin+pos+1, v->stor_begin+pos, sizeof(void*) * (size_t) (size-pos)); } v->stor_begin[pos] = e; return 0; }
void igraph_i_separators_free(igraph_vector_ptr_t *separators) { long int i, n=igraph_vector_ptr_size(separators); for (i=0; i<n; i++) { igraph_vector_t *vec=VECTOR(*separators)[i]; if (vec) { igraph_vector_destroy(vec); igraph_Free(vec); } } }
void igraph_i_cohesive_blocks_free3(igraph_vector_ptr_t *ptr) { long int i, n=igraph_vector_ptr_size(ptr); for (i=0; i<n; i++) { igraph_vector_t *v=VECTOR(*ptr)[i]; if (v) { igraph_vector_destroy(v); igraph_free(v); } } }
void igraph_i_free_vectorlist(igraph_vector_ptr_t *list) { long int i, n=igraph_vector_ptr_size(list); for (i=0; i<n; i++) { igraph_vector_t *v=VECTOR(*list)[i]; if (v) { igraph_vector_destroy(v); igraph_Free(v); } } igraph_vector_ptr_destroy(list); }
int print_and_destroy(igraph_vector_ptr_t *cliques) { int i, n=igraph_vector_ptr_size(cliques); sort_cliques(cliques); for (i=0; i<n; i++) { igraph_vector_t *v=VECTOR(*cliques)[i]; igraph_vector_print(v); igraph_vector_destroy(v); } igraph_vector_ptr_destroy_all(cliques); return 0; }
int print_and_destroy(igraph_vector_ptr_t *ptr) { long int i, n=igraph_vector_ptr_size(ptr); for (i=0; i<n; i++) { igraph_vector_t *v=VECTOR(*ptr)[i]; igraph_vector_print(v); igraph_vector_destroy(v); igraph_free(v); } igraph_vector_ptr_destroy(ptr); return 0; }
void igraph_i_cliques_free_res(igraph_vector_ptr_t *res) { long i, n; n = igraph_vector_ptr_size(res); for (i=0; i<n; i++) { if (VECTOR(*res)[i] != 0) { igraph_vector_destroy(VECTOR(*res)[i]); igraph_free(VECTOR(*res)[i]); } } igraph_vector_ptr_clear(res); }
igraph_bool_t igraph_i_separators_newsep(const igraph_vector_ptr_t *comps, const igraph_vector_t *newc) { long int co, nocomps=igraph_vector_ptr_size(comps); for (co=0; co<nocomps; co++) { igraph_vector_t *act=VECTOR(*comps)[co]; if (igraph_vector_all_e(act, newc)) return 0; } /* If not found, then it is new */ return 1; }
int check_evecs(const igraph_t *graph, const igraph_vector_ptr_t *vecs, const igraph_vector_ptr_t *evecs, int error_code) { igraph_bool_t directed=igraph_is_directed(graph); long int i, n=igraph_vector_ptr_size(vecs); if (igraph_vector_ptr_size(evecs) != n) { exit(error_code+1); } for (i=0; i<n; i++) { igraph_vector_t *vvec=VECTOR(*vecs)[i]; igraph_vector_t *evec=VECTOR(*evecs)[i]; long int j, n2=igraph_vector_size(evec); if (igraph_vector_size(vvec) == 0 && n2==0) { continue; } if (igraph_vector_size(vvec) != n2+1) { exit(error_code+2); } for (j=0; j<n2; j++) { long int edge=VECTOR(*evec)[j]; long int from=VECTOR(*vvec)[j]; long int to=VECTOR(*vvec)[j+1]; if (directed) { if (from != IGRAPH_FROM(graph, edge) || to != IGRAPH_TO (graph, edge)) { exit(error_code); } } else { long int from2=IGRAPH_FROM(graph, edge); long int to2=IGRAPH_TO(graph, edge); long int min1= from < to ? from : to; long int max1= from < to ? to : from; long int min2= from2 < to2 ? from2 : to2; long int max2= from2 < to2 ? to2 : from2; if (min1 != min2 || max1 != max2) { exit(error_code+3); } } } } return 0; }
int igraph_vector_ptr_push_back (igraph_vector_ptr_t* v, void* e) { assert(v != NULL); assert(v->stor_begin != NULL); /* full, allocate more storage */ if (v->stor_end == v->end) { long int new_size = igraph_vector_ptr_size(v) * 2; if (new_size == 0) { new_size = 1; } IGRAPH_CHECK(igraph_vector_ptr_reserve(v, new_size)); } *(v->end) = e; v->end += 1; return 0; }