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